WPF Still Going Strong - .NET 134
WPF Still Going Strong - .NET 134
Guests :
Hosts :
Published :
Sep 20, 2022
Duration :
53 Minutes
Show Notes
"I thought WPF was dead" is usually one of the first things that Kevin Bost hears when discussing today's topic. WPF is not dead. In fact, WPF is supported by .NET 6 and a plethora of third-party apps, extensions and packages. Kevin has been working with WPF for a long time and has become an expert on the framework. In today's episode we discuss some of the strengths and weaknesses of WPF, competing frameworks, open-source projects and the path forward. If you need to develop desktop apps for Windows, WPF is still the most mature framework out there. Have you worked with WPF? Are you currently developing applications with WPF? Let us know on Twitter at @dotnet_Podcast.
Sponsors
Links
- Kevin Bost - IntelliTect
- GitHub - MaterialDesignInXAML/MaterialDesignInXamlToolkit
- Windows Community Toolkit Documentation - Windows Community Toolkit
- Debugging WPF - Visual Studio (Windows)
- What is MahApps.Metro?
- GitHub - snoopwpf/snoopwpf
- GitHub - Keboo/XAMLTest
- KitoKeboo - Twitch
- Kevin Bost
- Twitter: @kitokeboo
Picks
Transcript
Shawn_Clabough:
Hello and welcome to another episode of Adventures in.NET. I'm Sean Kleber, your host, and with me today, co-hosts are Caleb Wells.
Caleb_Wells:
Hey, how's
Shawn_Clabough:
Thank
Caleb_Wells:
it going?
Shawn_Clabough:
you, good,
Kevin_Bost:
into
Shawn_Clabough:
good,
Kevin_Bost:
the
Shawn_Clabough:
good.
Kevin_Bost:
thicker client
Caleb_Wells:
Yeah.
Kevin_Bost:
applications,
Shawn_Clabough:
And, uh, way
Kevin_Bost:
a
Shawn_Clabough:
loo.
Kevin_Bost:
means of sort of leveraging that existing
Wai_Liu:
Sean,
Kevin_Bost:
knowledge
Wai_Liu:
Caleb,
Kevin_Bost:
that they
Wai_Liu:
how's
Kevin_Bost:
have around
Wai_Liu:
it going?
Kevin_Bost:
doing
Shawn_Clabough:
Hey.
Kevin_Bost:
it,
Caleb_Wells:
Hey,
Kevin_Bost:
which is, in my
Caleb_Wells:
it's
Kevin_Bost:
opinion,
Caleb_Wells:
good.
Kevin_Bost:
great.
Caleb_Wells:
It's cold down there,
Wai_Liu:
It's been
Caleb_Wells:
huh?
Wai_Liu:
a while since we've all been together, no?
Caleb_Wells:
It
Wai_Liu:
What
Caleb_Wells:
has,
Wai_Liu:
if I just...
Caleb_Wells:
it's
Shawn_Clabough:
It has been, yeah.
Caleb_Wells:
been a couple
Shawn_Clabough:
Yeah.
Caleb_Wells:
of
Shawn_Clabough:
We
Caleb_Wells:
weeks.
Shawn_Clabough:
all been busy, busy, busy.
Caleb_Wells:
Oh yeah,
Shawn_Clabough:
So
Caleb_Wells:
I did
Shawn_Clabough:
when's the
Caleb_Wells:
a
Shawn_Clabough:
last time
Caleb_Wells:
lunch
Shawn_Clabough:
you.
Caleb_Wells:
and learn on mediator today. So yeah, that was interesting.
Shawn_Clabough:
When's the last time you've seen snow, Wei?
Wai_Liu:
You know what, we go to this snow
Kevin_Bost:
Yeah.
Wai_Liu:
place like, it's like 45 minutes drive away from where I live
Kevin_Bost:
Yeah.
Wai_Liu:
but it's like, it's just fake snow and it's just
Kevin_Bost:
Yeah,
Wai_Liu:
like a, it's
Kevin_Bost:
and I
Wai_Liu:
just
Kevin_Bost:
will
Wai_Liu:
a
Kevin_Bost:
point
Wai_Liu:
wonderland
Kevin_Bost:
out too,
Wai_Liu:
mountain
Kevin_Bost:
I am not actually
Wai_Liu:
and it's just
Kevin_Bost:
the
Wai_Liu:
for
Kevin_Bost:
original
Wai_Liu:
kids to build a snowman
Kevin_Bost:
author of
Wai_Liu:
on,
Kevin_Bost:
the library,
Wai_Liu:
um,
Kevin_Bost:
for what it's
Wai_Liu:
but
Kevin_Bost:
worth.
Wai_Liu:
it's just, yeah, it's...
Kevin_Bost:
Several years ago, the
Wai_Liu:
But
Shawn_Clabough:
So
Kevin_Bost:
original
Wai_Liu:
it's
Shawn_Clabough:
you
Wai_Liu:
real
Shawn_Clabough:
wanna
Kevin_Bost:
author
Wai_Liu:
snow,
Shawn_Clabough:
build
Kevin_Bost:
was,
Shawn_Clabough:
a snowman?
Wai_Liu:
um, it's
Shawn_Clabough:
Mm-hmm.
Wai_Liu:
about three
Kevin_Bost:
I'll say,
Wai_Liu:
hours away,
Kevin_Bost:
I'll describe it as Fighting
Wai_Liu:
yeah.
Kevin_Bost:
Burnout. And I
Wai_Liu:
Such
Kevin_Bost:
was
Wai_Liu:
a good singing
Kevin_Bost:
a
Wai_Liu:
voice.
Kevin_Bost:
popular contributor, and so he asked me if I was interested
Caleb_Wells:
Man,
Shawn_Clabough:
Yeah.
Kevin_Bost:
in taking over
Caleb_Wells:
real
Kevin_Bost:
as
Caleb_Wells:
snow
Kevin_Bost:
maintainer
Caleb_Wells:
for me
Kevin_Bost:
of the
Caleb_Wells:
is
Kevin_Bost:
library.
Caleb_Wells:
like
Kevin_Bost:
And I was like,
Caleb_Wells:
at least six
Kevin_Bost:
yes.
Caleb_Wells:
or seven and that's in
Kevin_Bost:
I
Caleb_Wells:
the middle
Kevin_Bost:
do it
Caleb_Wells:
of
Kevin_Bost:
because
Caleb_Wells:
winter.
Kevin_Bost:
I find it fun.
Caleb_Wells:
So yeah,
Kevin_Bost:
Which
Caleb_Wells:
at
Kevin_Bost:
is
Caleb_Wells:
least.
Kevin_Bost:
also like, because I do live
Shawn_Clabough:
You
Caleb_Wells:
Anyway.
Shawn_Clabough:
can
Kevin_Bost:
coding
Shawn_Clabough:
borrow
Kevin_Bost:
on
Shawn_Clabough:
some
Kevin_Bost:
Twitch
Shawn_Clabough:
of mine.
Kevin_Bost:
for
Shawn_Clabough:
You can borrow
Kevin_Bost:
streaming.
Shawn_Clabough:
mine in the winter,
Caleb_Wells:
Ha
Shawn_Clabough:
definitely.
Kevin_Bost:
And...
Caleb_Wells:
ha ha.
Kevin_Bost:
Because people have asked me, oh, well, can you cover this? Can you do that? And I'm like,
Shawn_Clabough:
All
Kevin_Bost:
sure.
Shawn_Clabough:
right, let's
Kevin_Bost:
But
Shawn_Clabough:
bring
Kevin_Bost:
ultimately,
Shawn_Clabough:
out our guest.
Kevin_Bost:
I started doing this
Shawn_Clabough:
Let's
Kevin_Bost:
live
Shawn_Clabough:
welcome
Kevin_Bost:
coding because
Shawn_Clabough:
Kevin Bost.
Kevin_Bost:
I'm having
Shawn_Clabough:
Welcome,
Kevin_Bost:
fun
Shawn_Clabough:
Kevin.
Kevin_Bost:
and just kind of sharing that
Caleb_Wells:
Hey!
Kevin_Bost:
with everyone else of
Wai_Liu:
You care man?
Kevin_Bost:
let's have fun
Shawn_Clabough:
Hey.
Kevin_Bost:
building
Shawn_Clabough:
And
Kevin_Bost:
something.
Shawn_Clabough:
fluidous full disclosure
Kevin_Bost:
Let's have fun
Shawn_Clabough:
to
Kevin_Bost:
doing
Shawn_Clabough:
our
Kevin_Bost:
it.
Shawn_Clabough:
listeners,
Kevin_Bost:
And I figure if I'm having
Shawn_Clabough:
Kevin
Kevin_Bost:
fun,
Shawn_Clabough:
and I work together.
Kevin_Bost:
even
Shawn_Clabough:
So
Kevin_Bost:
if nobody else is watching or enjoying
Shawn_Clabough:
there's going
Kevin_Bost:
it,
Shawn_Clabough:
to
Kevin_Bost:
at
Shawn_Clabough:
be
Kevin_Bost:
least
Shawn_Clabough:
no
Kevin_Bost:
I'm enjoying
Shawn_Clabough:
softball
Kevin_Bost:
myself.
Shawn_Clabough:
questions,
Kevin_Bost:
And
Shawn_Clabough:
no softball
Kevin_Bost:
that
Shawn_Clabough:
questions.
Kevin_Bost:
gets me
Shawn_Clabough:
Yep.
Kevin_Bost:
at least through the
Caleb_Wells:
Haha
Kevin_Bost:
stream, however it works out. There are a couple
Shawn_Clabough:
All right,
Kevin_Bost:
other
Shawn_Clabough:
Kevin.
Kevin_Bost:
libraries
Shawn_Clabough:
So I
Kevin_Bost:
I would highlight
Shawn_Clabough:
think what we're
Kevin_Bost:
too
Shawn_Clabough:
going to
Kevin_Bost:
if
Shawn_Clabough:
talk
Kevin_Bost:
anybody
Shawn_Clabough:
about
Kevin_Bost:
is getting
Shawn_Clabough:
is
Kevin_Bost:
ready to dive
Shawn_Clabough:
WPF.
Kevin_Bost:
into WPF.
Shawn_Clabough:
What the hell
Kevin_Bost:
There's
Shawn_Clabough:
is
Kevin_Bost:
another
Shawn_Clabough:
that?
Kevin_Bost:
UI library called MA apps,
Caleb_Wells:
Heh.
Kevin_Bost:
M-A-H apps,
Wai_Liu:
Hehehe
Kevin_Bost:
that is exceptional. There's actually an integration package for My Material Design Library and MA apps, because they add a few additional controls that people want that aren't in the box. The other thing that they add is window Chrome support. So My Material Design Library doesn't do anything with your basic Windows Chrome, so the border around your window. If you want to customize that. you end up either dropping into some lower level APIs or just bring in something like my apps where they have a nice window base that you can then customize. So you wanna change up how the X thing looks you wanna make your window look like a Mac window for some reason, great have at it. You can do that, should you? Probably not, but you can. It's definitely a worthwhile thing to look at and like I said if you want to leverage it with the material design library there is a theme package that you can add in that then brings those same style theming ideas to the Ma Apps control as well. The other thing that got added in Visual Studio not that long ago, or I should say got better not that long ago, was their live visual debugging. Again, web developers were spoiled for so long. They fire up their application. They can go in and start mucking
Shawn_Clabough:
So
Kevin_Bost:
with
Shawn_Clabough:
when
Kevin_Bost:
their
Shawn_Clabough:
I'm making a WinForms
Kevin_Bost:
UI and
Shawn_Clabough:
app,
Kevin_Bost:
see things
Shawn_Clabough:
I'm
Kevin_Bost:
change
Shawn_Clabough:
behind
Kevin_Bost:
in real
Shawn_Clabough:
the times?
Kevin_Bost:
time and go, yeah, that's what I wanted it to look like. And us desktop developers have been going, man, that'd be really cool. But fairly recently, Microsoft did bring in Hot Reload to try to give us that kind of same functionality. It doesn't work nearly as reliably as the web stuff does, but when it works, it's really nice. At least because I like to be able to see what my app looks like while it's running,
Shawn_Clabough:
So
Kevin_Bost:
not seeing
Shawn_Clabough:
my VB6
Kevin_Bost:
a preview of
Shawn_Clabough:
stuff
Kevin_Bost:
it
Shawn_Clabough:
is
Kevin_Bost:
in
Shawn_Clabough:
still
Kevin_Bost:
the designer
Shawn_Clabough:
good.
Kevin_Bost:
of what it might look like when it's running. I want to... actually see
Caleb_Wells:
Somewhere.
Kevin_Bost:
the running application
Shawn_Clabough:
That was so
Kevin_Bost:
and
Shawn_Clabough:
great, you know,
Kevin_Bost:
I want
Shawn_Clabough:
drag
Kevin_Bost:
to move
Shawn_Clabough:
and
Kevin_Bost:
stuff
Shawn_Clabough:
drop
Kevin_Bost:
around and
Shawn_Clabough:
and
Kevin_Bost:
go,
Shawn_Clabough:
you know,
Kevin_Bost:
yeah
Shawn_Clabough:
edit
Kevin_Bost:
that
Shawn_Clabough:
and
Kevin_Bost:
button
Shawn_Clabough:
continue,
Kevin_Bost:
doesn't look like,
Shawn_Clabough:
you know,
Kevin_Bost:
let's
Shawn_Clabough:
worked
Kevin_Bost:
move it
Shawn_Clabough:
perfect.
Kevin_Bost:
over a little, right? And adjust that kind of thing. And so being able to see that stuff flow through has been really great. It does come with a visual tree inspector. For web developers, think of this like looking at your DOM. Because even though you write XAML for your WPF UI, the XAML that you write and the runtime tree are not equivalent, right? I may put one line of XAML that expands out at runtime into 300 lines of XAML. And so being able to go through and inspect that, oftentimes people are like, I put a button, how come I get all of this extra stuff onto it? It's like, well, when you brought in my material design library, you said button, and I've got a control template that says, well, a button consists of an icon here, a background border here, a text bit over here. Like, there's a bunch of things that go into making up what button is. And in terms of investigating it, the Visual Studio stuff is good, but there's another project out there called Snoop that has been around for much longer than the Visual Studio stuff has been and is absolutely exceptional. So it gives you a lot of the toys that you would hope would have been in the box out of the gate from breaking apart your visual tree. You can have it arbitrarily just invoke C-sharp methods for you. You can muck with properties at runtime. For fun, you can even take Snoop and point it at Visual Studio. There's been a number of times where I've had issues with like Visual Studio UI elements because I run my fonts at bigger than default And I'm fairly confident people don't test that case and so things get cut off. I don't see buttons It's like where's the okay button on this dialogue, so you can actually point snoop at any WPF Component and then go in and muck with it at runtime and just tweak stuff around and go Let me adjust that for you real quick and figure out what this is gonna look like so anybody doing WPF development I would highly recommend adding Snoop to your tool belt because it is very much a must-have tool for being able to Understand what's going on and then be able to tweak stuff back and forth So there's a couple ways to go about doing it. There is, and I'm probably going to butcher it, the UI automation stuff that existed in Windows hasn't received updates very much recently. It used to be the go-to option for most people because it was more or less the de facto only option there. Playwright has actually come out with a desktop head that you can use to go through and test it. So anybody who's used Playwright to go through and do UI testing for their web apps will probably feel fairly fairly close at home. With all of
Caleb_Wells:
No, I'm
Kevin_Bost:
Yeah,
Caleb_Wells:
curious,
Kevin_Bost:
which
Caleb_Wells:
Kevin.
Kevin_Bost:
I've been really impressed
Caleb_Wells:
I'm
Kevin_Bost:
with it.
Caleb_Wells:
a web guy,
Kevin_Bost:
It is amazing,
Caleb_Wells:
I mean, through and through,
Kevin_Bost:
especially
Caleb_Wells:
right?
Kevin_Bost:
for going through and doing
Caleb_Wells:
So
Kevin_Bost:
it. It's worth noting, though, when you're doing
Caleb_Wells:
I can't remember
Kevin_Bost:
UI
Caleb_Wells:
the
Kevin_Bost:
testing
Caleb_Wells:
last time
Kevin_Bost:
on
Caleb_Wells:
I did
Kevin_Bost:
a desktop
Caleb_Wells:
a
Kevin_Bost:
application,
Caleb_Wells:
desktop application.
Kevin_Bost:
most of these libraries
Caleb_Wells:
What kind of
Kevin_Bost:
go
Caleb_Wells:
applications
Kevin_Bost:
through the
Caleb_Wells:
do you develop with WPF these
Kevin_Bost:
automation
Caleb_Wells:
days?
Kevin_Bost:
APIs, which
Caleb_Wells:
What's
Kevin_Bost:
are
Caleb_Wells:
kind
Kevin_Bost:
aimed
Caleb_Wells:
of the
Kevin_Bost:
at
Caleb_Wells:
focus
Kevin_Bost:
simulating
Caleb_Wells:
that
Kevin_Bost:
user interaction,
Caleb_Wells:
you see
Kevin_Bost:
which is really
Caleb_Wells:
in
Kevin_Bost:
great
Caleb_Wells:
that area?
Kevin_Bost:
until you say that you want to write a UI test that validates that, say, your button turns red when there's invalid input. The automation APIs don't expose that information. And I love picking on background color, because that one feels like the most trivial thing to want to write a UI test on that just doesn't exist. So I've built out a handful of additional tools and libraries, largely driven by the material design project that I was working on. Because the material design project, it's a style and a theming library for WPF. That's really cool. really hard to write a unit test over. Like, how do you assert that the control looks right? That's not an easy assertion, and I wasn't about to start taking screenshots and doing bitmap comparison. That just felt like a nightmare to go through and do. I actually ended up building my own UI automation library called XAML test, specifically to go through and handle these cases. And it's worth noting, I don't think XAML test actually competes with the Playwright or the UI automation stuff because they're aimed at solving slightly different problems. If you are building an application and you want to simulate user interaction and build tests that way, that's coming at it at a slightly higher level. That's the black box level testing of your app where you're trying to just interact with what's there. XAML test takes a very different approach where it injects itself in to the running application. and aims to give you that low-level visual tree interaction. So I can go through and manipulate your UI elements. I can go through and pull out any property that I want. So if I want to validate that, yes, this button turned red when you typed in an invalid password, great. I can write that test and go through and build it out. It also was designed to be able to test, for the Material Design Library, a lot of the styles have triggers that allow you to do conditional style logic. And so being able to
Caleb_Wells:
Well,
Kevin_Bost:
validate
Caleb_Wells:
it is
Kevin_Bost:
that those
Caleb_Wells:
still
Kevin_Bost:
triggers
Caleb_Wells:
a thing,
Kevin_Bost:
are working
Caleb_Wells:
unfortunately.
Kevin_Bost:
correctly.
Caleb_Wells:
It
Kevin_Bost:
That
Caleb_Wells:
shouldn't
Kevin_Bost:
hey,
Caleb_Wells:
be.
Kevin_Bost:
when I click this, I expect
Caleb_Wells:
But yeah,
Kevin_Bost:
the thing to disable
Caleb_Wells:
no,
Kevin_Bost:
after
Caleb_Wells:
you're right.
Kevin_Bost:
it's been clicked
Shawn_Clabough:
I
Kevin_Bost:
once.
Shawn_Clabough:
think one
Kevin_Bost:
Great.
Shawn_Clabough:
of the
Kevin_Bost:
I
Shawn_Clabough:
biggest
Kevin_Bost:
want to
Shawn_Clabough:
struggles
Kevin_Bost:
write that
Shawn_Clabough:
that
Kevin_Bost:
test
Shawn_Clabough:
a web
Kevin_Bost:
where
Shawn_Clabough:
person has
Kevin_Bost:
I validate,
Shawn_Clabough:
when they try
Kevin_Bost:
you
Shawn_Clabough:
to
Kevin_Bost:
know,
Shawn_Clabough:
write
Kevin_Bost:
is
Shawn_Clabough:
a desktop
Kevin_Bost:
it enabled
Shawn_Clabough:
app
Kevin_Bost:
true? I click,
Shawn_Clabough:
is having
Kevin_Bost:
is enabled
Shawn_Clabough:
to really
Kevin_Bost:
false?
Shawn_Clabough:
worry about
Kevin_Bost:
It's a simple
Shawn_Clabough:
threading.
Kevin_Bost:
test for me to write and I want
Shawn_Clabough:
You
Kevin_Bost:
to
Shawn_Clabough:
know,
Kevin_Bost:
write
Shawn_Clabough:
on
Kevin_Bost:
it
Shawn_Clabough:
the
Kevin_Bost:
with
Shawn_Clabough:
web, you don't
Kevin_Bost:
what
Shawn_Clabough:
really,
Kevin_Bost:
feels like a
Shawn_Clabough:
you
Kevin_Bost:
unit
Shawn_Clabough:
don't, you're
Kevin_Bost:
testy
Shawn_Clabough:
not concerned
Kevin_Bost:
type framework,
Shawn_Clabough:
about locking the UI thread or
Kevin_Bost:
but
Shawn_Clabough:
anything.
Kevin_Bost:
without doing
Shawn_Clabough:
It just
Kevin_Bost:
it.
Shawn_Clabough:
kind of does
Kevin_Bost:
The other
Shawn_Clabough:
it
Kevin_Bost:
way
Shawn_Clabough:
and
Kevin_Bost:
people
Shawn_Clabough:
everything
Kevin_Bost:
sometimes
Shawn_Clabough:
runs itself.
Kevin_Bost:
write UI
Shawn_Clabough:
You
Kevin_Bost:
tests
Shawn_Clabough:
got to worry about
Kevin_Bost:
in
Shawn_Clabough:
that
Kevin_Bost:
WPF
Shawn_Clabough:
when you're doing
Kevin_Bost:
is
Shawn_Clabough:
any
Kevin_Bost:
they'll
Shawn_Clabough:
kind
Kevin_Bost:
just take
Shawn_Clabough:
of
Kevin_Bost:
their standard
Shawn_Clabough:
desktop
Kevin_Bost:
unit test
Shawn_Clabough:
application
Kevin_Bost:
library.
Shawn_Clabough:
stuff. You're going to lock up
Kevin_Bost:
and
Shawn_Clabough:
the
Kevin_Bost:
deal
Shawn_Clabough:
UI
Kevin_Bost:
with the
Shawn_Clabough:
and
Kevin_Bost:
threading
Shawn_Clabough:
people don't
Kevin_Bost:
that
Shawn_Clabough:
know
Kevin_Bost:
way.
Shawn_Clabough:
why or what's the best way to,
Kevin_Bost:
Because
Shawn_Clabough:
you know,
Kevin_Bost:
you
Shawn_Clabough:
prevent
Kevin_Bost:
have
Shawn_Clabough:
that and get around it.
Kevin_Bost:
the UI thread that you're dealing with, so without diving too deep into it, there's the apartment states of your thread, the single threaded versus the multi-threaded apartments, where your UI thread is STA, the single threaded apartment. For things like XUnit, there's extensions that will let you run a test where the thread running it runs as an STA thread. which lets you instantiate a UI object and then touch it and go back and forth and make some assertions on it. The part that I really did not like about that is then you are testing UI components outside of the WPF kind of rendering pipeline. And so WPF, when you put a control inside of a window, it will do things like automatically measure, lay out the control, all of the useful stuff. And I wanted to have something that would actually leverage that. rather than trying to simulate that in my test. Because manually calling like a range and measure and all of that to simulate what WPF would do when I put that control in a real window just left me with a bad taste in my mouth. There was too many cases where I was doing stuff in my test to mimic what the real app would do that I didn't want to bring it in. So it's definitely there and I've... Exactly. And so that's why I wrote... XAML test where it basically starts up a WPF shell that you can just dump arbitrary content into and then write tests back and forth. And so it's just gRPC between your test host and the running WPF application, just being able to do that communication. But it is two separate processes so that you have that full WPF app experience and you can get access to everything as though it were a running app. And again, I built it for the Material Design Library, but I've had a couple people say that they pulled it into other things. I'm like... Great, have at it. If it works for you, perfect. But again, it is testing at a little bit lower level. It's no longer black box level testing. So it does kind of depend on what you're looking to gain from the tests. But it does fill in kind of that middle ground that I felt was missing between kind of conventional UI tests and unit tests. Because it didn't feel like there was a lot of middle ground there for what I was building with a library. But it's been a very fun project to to work on and build. That's a good question. So. . Couple factors I would probably be looking at. One would be skill and knowledge of the team because again, knowledge of XAML and MVVM, like I said earlier, is a steep
Wai_Liu:
Do you
Kevin_Bost:
learning
Wai_Liu:
think it's
Kevin_Bost:
curve
Wai_Liu:
just... Do
Kevin_Bost:
but worth it. And
Wai_Liu:
you
Kevin_Bost:
I
Wai_Liu:
think
Kevin_Bost:
think
Wai_Liu:
it's just
Kevin_Bost:
it
Wai_Liu:
Microsoft
Kevin_Bost:
depends on if
Wai_Liu:
just
Kevin_Bost:
that's what
Wai_Liu:
not updating their
Kevin_Bost:
people
Wai_Liu:
like, Visual Studio
Kevin_Bost:
are knowledgeable
Wai_Liu:
template
Kevin_Bost:
on.
Wai_Liu:
for WPF because it's not
Kevin_Bost:
Because
Wai_Liu:
getting any love?
Kevin_Bost:
WinForms does, again, works very well. It is still a viable choice for some desktop applications. And depending on people's knowledge and
Shawn_Clabough:
Yeah,
Kevin_Bost:
skill set.
Shawn_Clabough:
says the Microsoft
Kevin_Bost:
One could
Shawn_Clabough:
person.
Kevin_Bost:
argue that it is easier in some ways to do it because you don't get as much magic out of the box, but you write the code and it does exactly what you tell it to do. Now, oftentimes you realize, oh, I have to write a bunch of lines of code to make it do exactly what I want, but I can write all those lines of code. I'm not trying to deal with kind of weird abstractions of, well, hang on, I wrote this in XAML and now how do I do the same thing in C sharp? How do I manipulate this? Like there's not that. extra learning curve that goes along with it. In my opinion, wind forms is very much you get exactly what you do. Yeah. Yeah. And the WYSIWYG editor on WinForms is very easy for people going. We've taught classes for university students quite a bit and there was a big debate about what framework do you actually teach them. Because the goal was to teach them event-based programming. And you know, click handlers on buttons are the easiest starting place. But then the question comes, okay, well what framework with a button do you want to teach them? And WinForms looked very appealing because it was... like you were saying, that very intuitive interface of, I drag a button onto my thing, it stays there, it works. There's not a lot of, there's not a lot of magic happening. Like, I put a button right there, there's a button right there, it doesn't go anywhere. But you also end up doing a bunch of other stuff, like WinForms, usually my biggest selling point is, everything default anchors top left, right? So you drag the window to make it bigger, and all the UI elements stay. fixed right where you left them. Which, again, it's doing exactly what you told it to do and nothing more. Whereas WPF, they actually change the defaults. They say, no, what we'd rather have is we'd rather have controls fill their containing space by default. Now, some controls don't, but at least by default most things are going to fill their container. Which then means that at least when I resize my window, things start to resize and I start to see that resizing rather than everything just staying fixed. for better or worse, sometimes debatable, but at least then you kind of get something that feels a little better, at least from an end user experience. But it, again, does add that developer complexity of, okay, now I have to remember I have to change these flags now to make it not do that, if that's what I'm... Yeah, if you're looking for cross-platform, Maui or Xamarin Forms are probably the best options. Maui is, I don't think I would pick Xamarin Forms now over Maui at all. Maui has some
Caleb_Wells:
Places.
Kevin_Bost:
rough edges, but the amount of magic that it brings and simplicity that it brings over Xamarin Forms is significant. So both of those do allow you to write your front end in XAML. Maui brings in an alternate approach for your UI as well with what they called MVU based
Shawn_Clabough:
So for somebody
Kevin_Bost:
on the Comet library
Shawn_Clabough:
that's never
Kevin_Bost:
that
Shawn_Clabough:
done
Kevin_Bost:
existed for Xamarin
Shawn_Clabough:
WPF
Kevin_Bost:
Forms.
Shawn_Clabough:
before,
Kevin_Bost:
So if you're still in Xamarin
Shawn_Clabough:
what
Kevin_Bost:
Forms
Shawn_Clabough:
are the
Kevin_Bost:
and you want MVU,
Shawn_Clabough:
key
Kevin_Bost:
you
Shawn_Clabough:
things
Kevin_Bost:
can pull
Shawn_Clabough:
to
Kevin_Bost:
in Comet
Shawn_Clabough:
know about
Kevin_Bost:
and get the same thing. They
Shawn_Clabough:
before
Kevin_Bost:
just brought
Shawn_Clabough:
you get
Kevin_Bost:
it into
Shawn_Clabough:
started
Kevin_Bost:
the box.
Shawn_Clabough:
and you first launch that
Kevin_Bost:
But
Shawn_Clabough:
template?
Kevin_Bost:
it lets you write your UI in
Shawn_Clabough:
I've gotten in there
Kevin_Bost:
kind
Shawn_Clabough:
sometimes
Kevin_Bost:
of a more C
Shawn_Clabough:
and
Kevin_Bost:
Sharpy
Shawn_Clabough:
I
Kevin_Bost:
layout
Shawn_Clabough:
kind of get lost
Kevin_Bost:
type
Shawn_Clabough:
with
Kevin_Bost:
approach.
Shawn_Clabough:
the layout because I'm
Kevin_Bost:
And
Shawn_Clabough:
used
Kevin_Bost:
it
Shawn_Clabough:
to
Kevin_Bost:
gets
Shawn_Clabough:
doing
Kevin_Bost:
you
Shawn_Clabough:
a web
Kevin_Bost:
there.
Shawn_Clabough:
layout and it
Kevin_Bost:
As
Shawn_Clabough:
does
Kevin_Bost:
far
Shawn_Clabough:
a lot of
Kevin_Bost:
as
Shawn_Clabough:
things differently
Kevin_Bost:
picking
Shawn_Clabough:
when
Kevin_Bost:
the
Shawn_Clabough:
I'm
Kevin_Bost:
other
Shawn_Clabough:
doing
Kevin_Bost:
choices,
Shawn_Clabough:
WPF versus
Kevin_Bost:
WinUI,
Shawn_Clabough:
a web layout.
Kevin_Bost:
like
Shawn_Clabough:
What
Kevin_Bost:
I
Shawn_Clabough:
are
Kevin_Bost:
said,
Shawn_Clabough:
the things that somebody
Kevin_Bost:
I'm
Shawn_Clabough:
needs
Kevin_Bost:
really
Shawn_Clabough:
to know
Kevin_Bost:
rooting
Shawn_Clabough:
to get
Kevin_Bost:
for
Shawn_Clabough:
started?
Kevin_Bost:
it to be that nice WPF replacement. I don't think it's mature enough there. There's also not a lot of the same third party support for extra controls. WPF and Windows Forms have been around for so long. All your big names, your Telerics, they've produced really nice libraries and there is a... breadth of third party support available to you, which makes it really nice. Like I said, WinUI 3, if I was building something simple, I could go to it. The other thing that I think people miss out on a lot is you can actually access the newer Window APIs too, even inside of Windows Forms and WPF. So all of the magical stuff that came with Windows 8, what was called Metro at the time, and all the new Windows 10 APIs. You can dive into that. Project Centennial, I believe, that was the code name for it. I don't remember if they renamed it or not when it came out. But you can actually get access to those. I don't know. Native APIs feels like the wrong term. But we'll say platform-specific APIs, if you want to be able to dive into there. Like leveraging the notifications are similar. Or the live tiles inside of the start and that kind of thing. So. That stuff is still available even on the older platforms. You just have to pull in the appropriate packages to do so. So, you say that, but that's actually possible, though. Ha ha! Yes, it absolutely is. I saw a really cool demo where they actually compiled ASP.NET Core into WebAssembly. And I believe the PM's description was, this is potentially the worst possible way to serve up a web page is to bundle the server into WebAssembly and then serve it up. It's like, but as a proof of concept, it worked. but definitely not recommended. That's a great question.
Shawn_Clabough:
Yeah,
Kevin_Bost:
So, um,
Shawn_Clabough:
yeah. You've been
Caleb_Wells:
Well,
Shawn_Clabough:
working
Caleb_Wells:
and
Shawn_Clabough:
on
Caleb_Wells:
material
Shawn_Clabough:
that for quite
Caleb_Wells:
is well
Shawn_Clabough:
some
Caleb_Wells:
thought
Shawn_Clabough:
time.
Kevin_Bost:
I think
Caleb_Wells:
out.
Kevin_Bost:
the one thing I would
Caleb_Wells:
Yeah.
Kevin_Bost:
want people to take away from
Shawn_Clabough:
Yeah,
Kevin_Bost:
it is
Shawn_Clabough:
you've been working on it quite some
Kevin_Bost:
the
Shawn_Clabough:
time,
Kevin_Bost:
obvious
Shawn_Clabough:
so
Kevin_Bost:
question
Shawn_Clabough:
how
Kevin_Bost:
of is
Shawn_Clabough:
complete
Kevin_Bost:
WPF
Shawn_Clabough:
is it
Kevin_Bost:
dead?
Shawn_Clabough:
compared to
Kevin_Bost:
My
Shawn_Clabough:
the full
Kevin_Bost:
strong opinion
Shawn_Clabough:
Google design?
Kevin_Bost:
is no.
Shawn_Clabough:
Have you
Kevin_Bost:
And
Shawn_Clabough:
implemented everything?
Kevin_Bost:
it's not going to die until Microsoft manages to port all of their somewhat, what I would argue, critical because Visual Studio is kind of critical off of it. I don't doubt that they've been considering ways of doing it, but it's been around. It is still a very viable platform to build desktop apps on. Still my go-to option of choice. I was building, just last night, a theme editor. So my Git tool of choice is GitKraken. And they added theming support. So naturally, I built a WPF application to go through and edit their theme files so that I could have, for when you want few shit in your Git client, because that's what you need. I mean, that was still one of those cases where I was like, yeah. I'm going to be I'm going to build a nice little desktop application to tweak these JSON files on my local system because that's what's fun and that's what's useful for doing. I will admit I'm a unicorn in that regard. Thank you. Yeah, like I said, it's one of those, I do it for fun. I, unfortunately, when I first started out in my career, I worked for a company that was building a wind forms application. And my team lead kind of on a whim where we had an innovation sprint decided, you know what, reporting this to WPF. I was like, in a sprint? That seems ridiculous. And we did it. And I... I quickly fell in love with WPF
Caleb_Wells:
How do you
Kevin_Bost:
and
Caleb_Wells:
do this?
Kevin_Bost:
I don't believe I've looked back since. So it's
Caleb_Wells:
Yeah,
Kevin_Bost:
very much
Caleb_Wells:
no,
Kevin_Bost:
one of those frameworks.
Caleb_Wells:
that makes perfect sense.
Kevin_Bost:
I don't
Caleb_Wells:
Give
Kevin_Bost:
doubt
Caleb_Wells:
people
Kevin_Bost:
it's going
Caleb_Wells:
the
Kevin_Bost:
to go
Caleb_Wells:
control
Kevin_Bost:
away at
Caleb_Wells:
to
Kevin_Bost:
some
Caleb_Wells:
do what
Kevin_Bost:
point.
Caleb_Wells:
they want to do, even
Kevin_Bost:
That
Caleb_Wells:
if
Kevin_Bost:
point
Caleb_Wells:
it's
Kevin_Bost:
is not today
Caleb_Wells:
in poor
Kevin_Bost:
or
Caleb_Wells:
taste.
Kevin_Bost:
this year,
Caleb_Wells:
So
Kevin_Bost:
but
Caleb_Wells:
how does
Kevin_Bost:
I've
Caleb_Wells:
this
Kevin_Bost:
loved it
Caleb_Wells:
work
Kevin_Bost:
so far.
Caleb_Wells:
in XAML? How
Kevin_Bost:
I'm
Caleb_Wells:
do
Kevin_Bost:
hoping
Caleb_Wells:
you,
Kevin_Bost:
it...
Caleb_Wells:
because I'm, right, I know
Kevin_Bost:
I
Caleb_Wells:
what
Kevin_Bost:
probably
Caleb_Wells:
XAML
Kevin_Bost:
will
Caleb_Wells:
is,
Kevin_Bost:
be.
Caleb_Wells:
but
Kevin_Bost:
One of the
Caleb_Wells:
I
Kevin_Bost:
last
Caleb_Wells:
don't use
Kevin_Bost:
ones still
Caleb_Wells:
it.
Kevin_Bost:
sitting there.
Caleb_Wells:
How
Kevin_Bost:
Run my own
Caleb_Wells:
do
Kevin_Bost:
private
Caleb_Wells:
you
Kevin_Bost:
fork of the repo as long as I
Caleb_Wells:
inject
Kevin_Bost:
possibly can.
Caleb_Wells:
or handle styling and JavaScript and webby stuff in XAML?
Kevin_Bost:
I very much love all.NET stuff. Yeah, it's definitely one of those skill sets that it's not overly highly desired if you look at like job postings or what's there.
Wai_Liu:
And what are the styles
Kevin_Bost:
But
Wai_Liu:
we should in?
Kevin_Bost:
it's one of those people who have, when it's
Wai_Liu:
Like
Kevin_Bost:
needed,
Wai_Liu:
what is it? CSS
Kevin_Bost:
it's hard
Wai_Liu:
or what
Kevin_Bost:
to
Wai_Liu:
are
Kevin_Bost:
find.
Wai_Liu:
the styles? Like
Kevin_Bost:
Because
Wai_Liu:
what
Kevin_Bost:
I know
Wai_Liu:
language
Kevin_Bost:
we've definitely,
Wai_Liu:
isn't in here?
Kevin_Bost:
Rashaun and I work, we've at times struggled to try to hire people that know it well enough to work on it. It's not common for our clients to want WPF work, but the few that do really
Wai_Liu:
Hehehe
Kevin_Bost:
want it.
Caleb_Wells:
making a face.
Shawn_Clabough:
Yeah.
Wai_Liu:
Hehehe Hehehe
Caleb_Wells:
I'm like
Kevin_Bost:
Yes.
Caleb_Wells:
anyway yeah.
Kevin_Bost:
I'm hoping. I'm hoping. I'm hoping. I'm hoping. Yeah. Yeah, yeah and I think that's the thing is most people slowly start to upgrade and I think that's to Microsoft's credit they've done a really good job of trying to bring things like the project centennial so that people can keep their WPF applications and slowly work them forward or even when because.NET Core 3.1 was when they finally ported WPF over to Core and making it so that people do have those nice upgrade paths so it's not like well WPF only works on Windows 7, and Windows 7 falls out of support whenever, and now you're dead. Making sure that it's still running and going forward, I think shows that there's at least that admission of we can't just leave this in maintenance mode and let it time out with support end dates. It has to be something that's supported going forward.
Caleb_Wells:
can say this then that makes it all
Kevin_Bost:
Yeah,
Caleb_Wells:
that more important or
Kevin_Bost:
I
Caleb_Wells:
valuable
Kevin_Bost:
think
Caleb_Wells:
or
Kevin_Bost:
that's the hint to
Caleb_Wells:
should
Kevin_Bost:
you,
Caleb_Wells:
be
Kevin_Bost:
Sean,
Caleb_Wells:
appreciated that
Kevin_Bost:
that
Caleb_Wells:
you've
Kevin_Bost:
high pay raise
Caleb_Wells:
developed
Kevin_Bost:
is coming.
Caleb_Wells:
this library that does it for people right so they don't have to get into all the nasty
Kevin_Bost:
Excellent.
Caleb_Wells:
XML trees with the styling or whatnot so thank you I mean I'm not use WPF and and I can tell you right now thank you if I used it I'd be all over it
Kevin_Bost:
Yeah, so you can find all of my links at kibu.dev. That's K-E-B-O-O dot D-E-V That'll get you links to Twitch YouTube any socials that I'm active on you can find all of it there Feel free to drop me a follow Anybody who drops in on my my YouTube or twitch videos. I'm very happy to answer questions There's been quite a few streams where if I've got people in asking questions about something I do not mind rabbit trails at all. I usually go into a stream with an idea of something that I want to do, but that's usually an idea that's loosely held. If people are interested in something, I'm very happy
Caleb_Wells:
There you
Kevin_Bost:
to
Caleb_Wells:
go.
Kevin_Bost:
either divert or learn other things or even if you just want to leave a comment
Caleb_Wells:
Absolutely.
Kevin_Bost:
on one of the videos of something you'd like to see covered in the future, I've put together quite a few videos just based upon requests of, hey, I'd love to see it if you would cover this library or that. Always happy to interact with people.
Shawn_Clabough:
So how about testing with WPF? You're going to test most of your backend cone just using regular X unit tests and things like that. But how about UI testing with WPF? What's that like?
Kevin_Bost:
Cool, so mine, I love board games. My wife and I spend a great deal of time doing it. One that recently came out is called Blood on the Clock Hour. It's a, I'll say a party social deduction game. So for people who might be familiar with things like One Night Ultimate Werewolf or maybe the video game Among Us where there's traitors and the townsfolk have to suss out who is. who is good and who is lying to them. It is a wonderful game, so that would be my pick for this week.
Shawn_Clabough:
Well that's nice because I just picked up on Playwright. So that was on one of the projects that I'm working on. I had to go out and
Caleb_Wells:
Yeah.
Shawn_Clabough:
find the tools and ended up on Playwright.
Kevin_Bost:
Possibly. Does it say tabletop simulator if you're not familiar with it? Does...work for that? Thanks all.
Caleb_Wells:
You shouldn't have to duplicate that stuff, basically. Right? Yeah.
Wai_Liu:
So just wanted to ask, like if I got marked into my manager's office or something and they're like, we need to build a new desktop app, in which scenario would I kind of recommend using WPF? WinForms is, I think it's so intuitive when you think about it. Because Microsoft is doing all this citizen developer stuff with, you know, on the Power Platform with their Canvas apps and all that stuff. And it's very, very similar to WinForms. And I think it is just like that because for a non-developer, if you're targeting a low-code audience, it is actually the easiest place to start. Well, what about the others? Like, what about, because WPF is not cross-platform, right?
Caleb_Wells:
Yeah.
Shawn_Clabough:
Caleb might want to throw in Blazor into that mix, you know, Blazor Desktop.
Wai_Liu:
Mm-hmm
Caleb_Wells:
Well, yeah,
Shawn_Clabough:
Oh yeah,
Caleb_Wells:
it is. And yeah,
Shawn_Clabough:
it's buff.
Caleb_Wells:
yeah, Blazer's taking over the world. And I'm OK with that because I'm a Blazer guy. But yeah, there's some very interesting stuff you can do with Blazer these days. And they just keep pushing the boundaries. So time will tell. But it's a. It's a wonderful new world in the web where you can do C sharp all the way up and down. Yep.
Shawn_Clabough:
Okay, Kevin, so what things that we should cover that we haven't about WPF and.
Caleb_Wells:
Nice. Nice.
Wai_Liu:
I'm just gonna say you're so prolific. I've never seen anyone who is that passionate about WPF. Honestly, like, I kind of miss the train when... Yeah. Yeah. Yeah. Well, awesome. That's awesome. Great. I feel like you'll be there till the end, won't
Shawn_Clabough:
Hehehe
Wai_Liu:
you?
Shawn_Clabough:
That's what makes
Caleb_Wells:
Well, you know,
Shawn_Clabough:
Kevin
Caleb_Wells:
here's,
Shawn_Clabough:
great to work with.
Caleb_Wells:
yeah, yeah.
Shawn_Clabough:
He's always involved. He's always enthusiastic. He does user group stuff. He does the Twitch stuff. He's always ready to just jump in and make it something fun to work on.
Caleb_Wells:
We know
Wai_Liu:
That's awesome.
Caleb_Wells:
there is definitely, well, I was going to say, there's definitely some benefits to sticking with a framework or technology or language or whatever and becoming a master of your craft and not jumping to the next thing, right? Because in the web world, it's easy to jump to the next thing. You know, Angular, Vue, React next week. Oh, there's this new one called. Kooby dooby doo, let's try it out, right? I mean, whatever. So the fact that WFPF has been around this long and it works really well. Like you said, it's really mature and it's something that you know really well. I see that as a benefit or a bonus all the way around.
Wai_Liu:
Definitely it will become like the cobol of the Windows desktop world where you get paid like you know stupid amounts of money just to because you're the only one who knows that type thing. Ha ha ha
Caleb_Wells:
Hahaha
Shawn_Clabough:
I'm still waiting for somebody to need classic ASP work done and pay me really,
Wai_Liu:
Hahaha
Shawn_Clabough:
really good money. So they still kind of give that love for WPF and bring that into core, but they won't do it for web forms. Dang it. Alright, my bank account is waiting for it. Alright, Kevin. Great discussion. Really good. So if our listeners have questions and they want to either watch a code or get in touch, what's the best way for them to do that? Okay, and if our listeners want to get in touch with the show, we'd love to hear from you. They can get in touch with me on Twitter. I am at.NET Superhero.
Caleb_Wells:
da da da and I'm at Caleb Wills Codes but
Shawn_Clabough:
All right,
Caleb_Wells:
are we
Shawn_Clabough:
yep,
Caleb_Wells:
doing pics?
Shawn_Clabough:
yep, we're doing picks. We're doing
Caleb_Wells:
Okay
Shawn_Clabough:
picks, so,
Caleb_Wells:
okay we're
Shawn_Clabough:
yep,
Caleb_Wells:
just we're flip-flopping because
Shawn_Clabough:
yep, flip and flopping. So
Caleb_Wells:
okay
Shawn_Clabough:
they can, you know,
Caleb_Wells:
okay
Shawn_Clabough:
hear about us
Caleb_Wells:
I'm okay
Shawn_Clabough:
and contact
Caleb_Wells:
with that
Shawn_Clabough:
us and then we can do our picks. So yeah, go ahead. Let's go away, what's your pick?
Wai_Liu:
So my pick this week is um, it's just a TV show called Bob's Burgers. It's actually like really old But um my my Netflix list is so backed up that um, I hardly ever gets chance to watch TV So I'm starting to go through all the stuff from like 10 years ago. So but yeah Bob's Burgers It's kind of like a funny kind of like a animated sitcom, I guess and Yeah, it's got like it's got 10 season. I don't know if it's ended yet, but um It's gonna take me a while to get through it. So, yeah, I thought that'd be my pick.
Shawn_Clabough:
Okay, Caleb, what's your pick?
Caleb_Wells:
My pick is kind of similar to one you did. Maybe it was last episode or episode before about throwaway emails, right? Mine is not throwaway emails, but it is an email that will remove all trackers and all things that are following you. Duck, duck, go. Now you can now get an email. with an at duck.com and forward it to whatever emails you choose. Um, and if you use that and you're signing up for an account, right? You're going to get newsletters, emails and stuff. When the email comes in, it'll tell you remove tracker from this, remove tracker from this, remove tracker from this. So it's basically removing all of that information that's, you know, tracking you and following you from the emails and you still get them. So. I've used
Wai_Liu:
And
Caleb_Wells:
it a few times.
Wai_Liu:
does it cover your, does it hide your original email address as well?
Caleb_Wells:
Yep,
Wai_Liu:
So then
Caleb_Wells:
yep, they
Wai_Liu:
you have
Caleb_Wells:
do
Wai_Liu:
an
Caleb_Wells:
not
Wai_Liu:
alias
Caleb_Wells:
have
Wai_Liu:
basically.
Caleb_Wells:
your, they don't have it. All they have is your.com email.
Wai_Liu:
Oh, that's pretty cool actually.
Caleb_Wells:
Yeah, right?
Shawn_Clabough:
Yeah, cool. Nice.
Caleb_Wells:
So yeah.
Shawn_Clabough:
All right, so my pick this week is a TV show. It's an Amazon TV show and it's, I haven't watched it yet, but I watched the previews and the shows will have started coming out just prior to this being published. So listeners, they can probably go out and watch the show now and I got to pick the Rings of Power. You know,
Caleb_Wells:
Oh, it's already come
Shawn_Clabough:
the
Caleb_Wells:
out?
Shawn_Clabough:
previews of it looks really, really nice. And I've always been... Tolkien fan and like that
Caleb_Wells:
Yeah.
Shawn_Clabough:
you know read The Hobbit way way back in the day so I love that show I love the movies everything so the show starts September 1st and
Caleb_Wells:
Okay,
Shawn_Clabough:
so yeah definitely check it out
Caleb_Wells:
gotcha, yeah. I was
Shawn_Clabough:
it
Caleb_Wells:
like,
Shawn_Clabough:
looks
Caleb_Wells:
wait
Shawn_Clabough:
good
Caleb_Wells:
a minute, I've been watching the trailers, I'm ready for the first episode, I hope it doesn't suck. But okay, it hadn't come out just yet. Gotcha,
Shawn_Clabough:
Yeah,
Caleb_Wells:
yep. Ha ha
Shawn_Clabough:
they've
Caleb_Wells:
ha.
Shawn_Clabough:
got like five different trailers out there, so
Caleb_Wells:
Right,
Shawn_Clabough:
they all look good.
Caleb_Wells:
right.
Wai_Liu:
So it's in the
Caleb_Wells:
Yeah.
Wai_Liu:
Lord of the Rings world, I'm guessing.
Shawn_Clabough:
Yep.
Caleb_Wells:
It's
Shawn_Clabough:
Yep.
Caleb_Wells:
before the rings basically. It's like pre pre.
Wai_Liu:
So before
Caleb_Wells:
Yes.
Wai_Liu:
the Hobbit, is it?
Shawn_Clabough:
Yep, so
Caleb_Wells:
Yeah.
Shawn_Clabough:
this is kind of like how the rings got made,
Caleb_Wells:
Yeah.
Wai_Liu:
Oh, okay.
Shawn_Clabough:
how they came about.
Wai_Liu:
So the original author had, wasn't the book written by the original author or anything?
Caleb_Wells:
Well,
Shawn_Clabough:
Uh, I, this
Caleb_Wells:
they made
Shawn_Clabough:
is just
Caleb_Wells:
this stuff
Shawn_Clabough:
based on
Caleb_Wells:
up.
Shawn_Clabough:
his stuff. Yeah. He
Wai_Liu:
Oh,
Shawn_Clabough:
never
Caleb_Wells:
Yeah.
Wai_Liu:
okay.
Shawn_Clabough:
wrote this. He never wrote this. He, they just kind of based it. And of course they probably had to work with the family because the family is still pretty, pretty, uh,
Caleb_Wells:
protective
Shawn_Clabough:
protective and make sure that everything that they, that happens is something they agree with. So. Yep. They do that. All right, Kevin, what do you got for picks?
Caleb_Wells:
Man,
Shawn_Clabough:
Okay.
Caleb_Wells:
I used to love board games. I just don't have a lot of friends around here to play them with anymore. I wonder if, you know, we need to develop a remote desktop video app where you can play board games across the world. Can
Wai_Liu:
We could
Caleb_Wells:
we do
Wai_Liu:
use
Caleb_Wells:
that, Kevin?
Wai_Liu:
WPF, maybe.
Caleb_Wells:
Exactly. Yeah, yeah. Anyway, it's
Shawn_Clabough:
Hi
Caleb_Wells:
a thought.
Shawn_Clabough:
guys, great show, great show.
Caleb_Wells:
Yep.
Shawn_Clabough:
Thanks to our listeners for tuning in and we'll catch everybody on the next episode of AdventuresIn.net.
Caleb_Wells:
Bye
Wai_Liu:
See ya's.
Caleb_Wells:
y'all.