WPF Still Going Strong - .NET 134

Adventures in .NET

Level up your .NET skills with our weekly discussion of C# and other Microsoft technologies for developers.

WPF Still Going Strong - .NET 134

Guests :
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


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.