0:03

So I've been I've been focused

0:05

on the code to cloud journey

0:08

I like to call it for

0:10

the template and Two years ago

0:13

my goal was to provide a

0:15

solution that could take you from

0:17

code to cloud in 45 minutes

0:20

or less So I wanted it

0:22

to be file new project to

0:25

deployed solution on Asia because that's

0:27

where my main focus is Within

0:29

45 minutes Welcome friends to the

0:32

Modern.net show, the Premier.net podcast focusing

0:34

entirely on the Knowledge

0:36

Tools and Frameworks that

0:38

all.net developers should have in

0:40

their toolbox. We are the

0:43

go-to podcast for.net developers worldwide

0:45

and I am your host

0:47

Jamie Goprogman Taylor. In

0:49

this episode Jason Taylor, no

0:51

relation, joined us to talk

0:53

about his journey from classic

0:55

ASP to.net and Azure. He

0:57

also discusses clean architecture's maintainability

0:59

and his open source clean

1:01

architecture solution template for ASP.netcore

1:03

along with strategies for learning

1:05

new frameworks and dealing with

1:07

complexity. Right now the template

1:09

supports post-crescual sequel line and

1:12

sequel server, if you want

1:14

to support my sequel, it's

1:16

relatively easy to do because

1:18

there's already a bicep module or a

1:20

terraform module that you can go in

1:22

and use it. So I went from

1:24

45 minutes so now I can get

1:27

things up and running and like, I

1:29

don't know, two minutes of effort and

1:31

15 minutes of waiting around while I

1:33

met my coffee. Along the way we

1:35

talk about some of the complexities involved

1:38

with creating a template which supports multiple

1:40

different front-end technologies and dot-net aspire, which

1:42

was news to me when we recorded.

1:44

All the while maintaining the goal of

1:46

being the simplest approach for enterprise development

1:49

with clean architecture. Anyway,

1:51

without further ado, let's

1:53

sit back, open up

1:55

a terminal, type in.net

1:57

new podcast, I

2:00

will dive into the call of

2:03

modern.net. So Jason, thanks for joining

2:05

us on the show. It's an

2:07

incredible pleasure to have you on

2:09

the show. I know we're on

2:11

literally the other side of the

2:13

planet from each other. So this

2:15

is, it's a marvel of modern

2:17

technology is what I'll say it

2:19

is. Thanks Chairman. It's great to

2:21

meet with you again, not in

2:23

person, but over this podcast. And

2:26

yes, thanks for having me on

2:28

board. I'm really appreciable to come

2:30

and talk to you today. And

2:32

no worries, man, no worries, it's

2:34

great to have you on. For

2:36

folks who were listening in, Jason

2:38

and I first got connected in

2:40

real life over at MVP Summit

2:42

last year? Last year? Last year,

2:44

the year before? Yeah. Yeah. Which

2:47

will be even further in the

2:49

past because this will be going

2:51

out in 2025, so it's the

2:53

year before the year before. I

2:55

don't know, I'm really confused. Time

2:57

is confused. We'll take some time,

2:59

we'll take some notes, we'll figure

3:01

it out and get back to

3:03

you. Absolutely, absolutely, because we're recording

3:05

this in the present which will

3:07

be the past by the time

3:10

people are listening, but they're listening

3:12

in the present which is in

3:14

the future for us. Oh my

3:16

gosh, as you start, I'm lost

3:18

now. Is that what I've been

3:20

doing this for seven years? Jason,

3:22

I wonder, would you mind giving

3:24

us a sort of brief introduction

3:26

to yourself? Maybe like an elevator

3:28

picture about some of the highlights

3:31

of you and the work that

3:33

you do that kind of thing?

3:35

Yeah, for sure. Okay. Well, my

3:37

name is Jason Taylor. I'm from

3:39

Brisbane, Australia. And I'm a solutions

3:41

architect and software engineer. And I've

3:43

been in the industry now for,

3:45

I think, 24 years. When I

3:47

first started, I was working with

3:49

Classic AsP and BB Script, which

3:52

was a lot of fun. Prior

3:54

to that, I think I did

3:56

a little bit of Visual Basic

3:58

Five. Prior to that it might

4:00

have been basic on the Com

4:02

of 64. I've been programming for

4:04

a long time. time now. My

4:06

focus nowadays is.net and Azure so

4:08

I help customers to design, develop,

4:10

test and deploy custom solutions to

4:12

the cloud, primarily web-based solutions. And

4:15

yeah, I guess I'm known for

4:17

my work around clean architecture, the

4:19

talks that I've done, the workshops

4:21

that I've run, the template that

4:23

I've built that I've built, the

4:25

template that I've built, the template

4:27

that I've built. and that's what

4:29

we're here to talk about today

4:31

is there anything else you want

4:33

to know about my background I

4:36

would like to hear more about

4:38

I mean that's that's a really

4:40

cool intro for me because like

4:42

you said that you started sort

4:44

of on basic yeah on the

4:46

Commodore 64 that's very similar to

4:48

my origin story not on the

4:50

Commodore 64 but with basic so

4:52

on one of those cheap home

4:54

computers yeah that was so great

4:56

Do you know, I remember, I

4:59

used Basic probably right up until

5:01

2007, so VB.net at that stage.

5:03

It wasn't until around 2007 that

5:05

I moved over to C Sharp,

5:07

which is a long time ago

5:09

now. Was that 17 years? It

5:11

is, it is. It is. Time

5:13

moves fast, man. So fast. Yes.

5:15

So you, solutions architect and developer.

5:18

So you solutions architect and developer.

5:20

So like. That's right. We'll come

5:22

back to the conversation about clean

5:24

architects because I feel like it's

5:26

related, but like I've never understood

5:28

the direction like how you get

5:30

to solutions architect. Is it just

5:33

being really good at development and

5:35

just being really good at like

5:37

architecting applications? This isn't a job

5:39

interview by the way. Oh, that's

5:41

alright, I'm glad. I'm not prepared,

5:43

it's too late at night. So

5:45

it's a, for those listening, it's

5:48

8 20 p.m. at night, and

5:50

the kids are on school all

5:52

day, so it's been a day,

5:54

so it's been a big day,

5:56

so it's been a big day

5:58

for me. So how do you

6:00

get to be a great solutions

6:03

architect and and and and still

6:05

be a great developer? Well, I

6:07

think that's are linked together, it's

6:09

hard to be a great solution

6:11

to suffocate if you're not also

6:13

a great developer. I think it's

6:15

easy to... to kind of fall

6:18

back onto kind of the ivory

6:20

tower mentality where you look at

6:22

solution designs in a textbook and

6:24

stick close to that. But unless

6:26

you've actually cut the code and

6:28

tried the design and seen it

6:30

in the real world, I don't

6:33

think you can make great decisions

6:35

as a solution architect. So that's

6:37

why I like to think about

6:39

myself as both the solutions architect

6:41

and a software engineer. Yeah, that

6:43

makes sense, right? I like to

6:46

become a, I can't think of

6:48

the best way to put it,

6:50

I want to say physical architecture,

6:52

right? If I want to design

6:54

a bridge or a building, I

6:56

need to know enough about engineering

6:58

to know that what I'm suggesting

7:01

is feasible, right? Yeah, for sure.

7:03

For sure. Interesting, okay. Well, I

7:05

mean, that leads us nicely on

7:07

to one of the things that

7:09

you're particularly well known for, which

7:11

is the Clean Architecture get hub

7:13

repo. So I guess before we

7:16

talk about the repo itself, so

7:18

what is the clean architecture? Or

7:20

is it clean architecture? Is it

7:22

a clean architecture? Like is the

7:24

the? required. I haven't thought about

7:26

the the too much in clean

7:28

architecture. I tend to just refer

7:31

it to it as clean architecture.

7:33

It's pretty simple really. I like

7:35

to think of clean architecture as

7:37

an approach or a pattern in

7:39

which the code that you're building

7:41

is separated or organized into layers.

7:43

So it's promoting separation of concerns.

7:46

In addition to that, we apply

7:48

the dependency inversion principle to ensure

7:50

that core business logic remains independent

7:52

of external dependencies. So databases and

7:54

new I framework. And it's that

7:56

independence, it's that kind of encapsulation

7:59

of the core business logic, independent

8:01

of everything external, that makes the

8:03

system more maintainable, testable and especially

8:05

adaptable to future changes. And it's

8:07

worth remembering that clean architecture is

8:09

really an approach for an enterprise

8:11

application development. It's not an approach

8:14

for... are small to your application.

8:16

It's on an approach for a

8:18

POC or something that's thrown away.

8:20

It's for enterprise applications, something that's

8:22

going to be around for more

8:24

than a few years, something that's

8:26

probably going to be around for

8:29

20 years. And so we need

8:31

that independence of databases and UI

8:33

frameworks, especially your I frameworks, because

8:35

those things just changed so much.

8:37

the core business logic doesn't tend

8:39

to, requirements will change, new things

8:41

will come along, but the core

8:44

business logic can remain fairly static

8:46

over the period of 20 years.

8:48

That's kind of in a nutshell

8:50

what clean architecture is. So being

8:52

able to sort of like you

8:54

said separate those concerns of how

8:56

we are storing the information, put

8:59

that over there somewhere behind a

9:01

number of interfaces perhaps. but perhaps

9:03

the UI stuff over there behind

9:05

some kind of contract or interface

9:07

over there and be able to

9:09

sort of focus, hyper focus I

9:11

guess on What is the business

9:14

need? Like not making a shiny

9:16

user interface. That is cool. That

9:18

is a business need. But you

9:20

can get away with a not

9:22

so shiny user interface, right? And

9:24

do we really need to use

9:27

whatever kind of database technology? Maybe

9:29

we do, maybe we don't. We

9:31

can leave that decision for later.

9:33

But what we need to do

9:35

is really focus, hyper focus on

9:37

the business logic, right? Exactly. I

9:39

work really well with metaphors and

9:42

analogies right so like I should

9:44

if clean architecture was applied to

9:46

say a car I should within

9:48

certain limits be able to lift

9:50

the engine from one car and

9:52

put it down in another car

9:54

exactly because the business logic is

9:57

moving the car to and from

9:59

different locations that's it whereas the

10:01

user interface the way that the

10:03

user interacts with it the steering

10:05

wheel could be on the right

10:07

it could be on the left

10:09

all of the different controls it

10:12

could be a manual transmission automatic

10:14

transmission it doesn't really matter because

10:16

the engine which has the business

10:18

logic of providing local motion to

10:20

the wheels somehow. We're going to

10:22

be given some kind of fuel,

10:24

some kind of user input. We're

10:27

going to be told which gear

10:29

we're in and we're just going

10:31

to do something with that fuel

10:33

to move some wheels to get

10:35

us to move in a direction,

10:37

right? Yeah, I like your analogy,

10:39

but I can't help but think

10:42

that the engine is something that

10:44

we could replace. And maybe what

10:46

we're left is just the frame

10:48

of the car. and the seats

10:50

can change, the engine can change,

10:52

the wheels can change, the fuel

10:55

tank can change, all of those

10:57

things can change, but maybe somewhere

10:59

in that framework, is the little

11:01

computer that's running our software even,

11:03

that's going, that's probably going too

11:05

deep now. The atoms and the

11:07

molecules, that's where it is. I

11:10

think of... too deep, too deep,

11:12

back it up. Okay. When I

11:14

think of that, I think about

11:16

the engine, I think about, well,

11:18

yeah, that's like one of the

11:20

things with clean architecture. It's independent

11:22

of the database, right? So maybe,

11:25

you know, the engine is sequel

11:27

server. We're going to switch it

11:29

out and we're going to throw

11:31

PostQQUEL in there. The user doesn't

11:33

care. They can still drive the

11:35

car. Maybe it costs a little

11:37

bit less. I guess it depends

11:40

a little bit more. We can

11:42

change that. It's not too difficult

11:44

independent of the database. We can

11:46

switch that. It's fairly easy to

11:48

do. But the thing there is

11:50

that we can also test everything

11:52

independent of those things. We can

11:55

test our core business logic without

11:57

a database, without a web server,

11:59

without a user, and we can

12:01

test it to a very deep level. You

12:03

know, a lot of the time when we're

12:05

unit testing or writing any kind

12:08

of test, we're kind of aiming

12:10

for 80% right? But when you're

12:12

talking about your business logic,

12:14

the code that you've written,

12:16

the code that's most important

12:19

to the organization that you're

12:21

working for, really you want

12:23

closer to 100%. Because there's no

12:25

database code in there, there's no UI,

12:27

there's no frameworks, it's just business logic.

12:30

And clean architecture kind of makes it

12:32

easy to do that, which is something

12:34

that I really love. Yeah, because like

12:36

you don't want some kind of corner

12:39

case in the business logic or your

12:41

application of the business logic that says

12:43

like on a Tuesday, don't store whatever,

12:45

don't do this process. Yeah. Because it's

12:48

some kind of bug, right? You want

12:50

to be able to be able to

12:52

test for all possible. parts of that

12:54

whereas like maybe maybe with

12:56

the UI it doesn't really

12:58

matter too much if the

13:00

UI tests state that you know

13:03

this particular button is unreachable at

13:05

this moment in time because we're

13:08

going to fix that but like

13:10

because we are taking the rules

13:13

of the business and digitizing them

13:15

yes so that then the business

13:17

can continue to run and do

13:20

whatever it does using our

13:22

software We need to make sure

13:24

that that is, I hate the term,

13:26

but bulletproof. I like it, I like

13:29

it. That's it, for sure.

13:31

And you know, even those

13:33

UI elements, like a button,

13:35

not being enabled or being

13:37

disabled, let's, you know, as

13:39

you say, on a Tuesday,

13:41

that can be tested inside

13:43

of core as well, inside

13:45

of that business logic, because

13:47

we can return from our

13:50

business logic a view model.

13:52

that represents the data and the

13:54

state of the UI. So all

13:56

we need to really do is

13:58

test that view more. model. And

14:00

C, is that button disabled on the

14:02

view model? Because the view model is

14:05

just going to bind, sorry, that view

14:07

is just going to bind to that

14:09

view model. So if it says, you

14:12

know, dispatch, disabled, as a bullying property

14:14

on the view model, the UI is

14:16

fairly simple. It's just going to bind

14:18

to that. So we make a bit

14:21

of an assumption. We'll say, well look,

14:23

if disabled is true on the view

14:25

model, then it should be right on

14:28

the view model, then it should be

14:30

right on the right on the view.

14:32

And that's where we can focus our

14:34

tests, but it doesn't mean we're not

14:37

going to write UI tests, we're not

14:39

going to write integration tests. It's just

14:41

really nice to know that for all

14:43

of that business logic that we've worked

14:46

so hard to build, we can test

14:48

it to a very thorough level. Right,

14:50

yeah, because at the end of the

14:53

day, I guess, we have a finite

14:55

number of engineers and a finite number

14:57

of time for them to write the

14:59

tests. Yes. And so you want to

15:02

maybe... focus their abilities and availability on

15:04

the tests that are, and this is

15:06

not meant to say that UI isn't

15:09

important, but like focus their time and

15:11

ability on the parts of the system

15:13

that are important, which we've already discussed

15:15

is the business logic, right? That's it?

15:18

If Amazon's internal system. allowed you to

15:20

buy a book without paying for it

15:22

on a particular day of the week

15:25

because of a set of conditions. That

15:27

would be a failure of their business

15:29

logic unless they wanted you to have

15:31

the book for free. Yeah. And so

15:34

you would need to test for that

15:36

rather than testing that the UI looks

15:38

nice and loads really quickly and has

15:40

all of the photographs and has the

15:43

videos and stuff. Exactly. You need to

15:45

make sure that Amazon can continue to

15:47

make money. For sure. Yeah, that's it.

15:50

Love it. Love it. The thing with

15:52

clean architecture that you're pretty famous for

15:54

is one of the many things is

15:56

that there is this open source repo

15:59

that you have which has clean architecture.

16:01

for an ASP.net core application. So I

16:03

wonder, can we talk about that a

16:06

little bit? I mean, we've got a

16:08

link for the Show Note, so if

16:10

folks are listening in going, oh my

16:12

goodness, this sounds amazing, before they've even

16:15

talked about it, and I don't want

16:17

to see it. Check the Show Notes,

16:19

folks. Wonderful. Yeah, I'd love to talk

16:22

about it. So I first discovered clean

16:24

architecture probably about seven years ago. And

16:26

I was sitting for a little bit

16:28

of inspiration. And I'll try to provide

16:31

you with a link to the book.

16:33

I'll have to dig it up. But

16:35

anyway, I came across a section on

16:37

clean architecture and it was just a

16:39

small part of this book. It wasn't

16:42

the main focus, but something about it

16:44

kind of caught my attention. It

16:46

sounded like the solution I'd been

16:48

looking for without even knowing it.

16:50

And so, like most of us

16:52

do, when something clicks, I just

16:54

started researching it more deeply, looking

16:57

for... everything that I could find

16:59

about the topic and at the time

17:01

I also been working on a new

17:03

project it was Northwind traders and Northwind

17:05

traders of course there's nothing new but

17:07

I wanted to build it for ASP

17:09

net core and EF core because.net core

17:12

was new and I wanted something to

17:14

play around with so I built this

17:16

solution for the sole purpose of of

17:18

playing around and trying new things with

17:20

dot net. So I just learned about

17:23

clean architecture so naturally I decided to

17:25

update Northwind traders to follow this clean

17:27

architecture process. That man, the process couldn't

17:29

have been easier. The architecture just, it

17:32

just made so much sense. That was,

17:34

yeah, as I said, that was seven

17:36

years ago, and I've been using

17:38

clean architecture ever since. But probably

17:40

two years after that, I had a bit

17:43

of a problem. I was using it all

17:45

the time. I worked at a consultancy,

17:47

so in the consultancy, I got

17:49

to go file a new project

17:51

a lot, which is exciting, right?

17:53

Greenfield's projects. But the thing was

17:55

that... even though clean architecture

17:59

was really nice for structuring solutions,

18:01

creating a new project or a whole

18:03

set of new projects, all of the

18:05

boilerplate code that I needed was just

18:07

really time consuming. It was painful. So

18:09

that was when I decided to create

18:12

the Clean Architecture Solution template. So that

18:14

was in October of 2019, so about

18:16

five years ago now. Simply put, the

18:18

Clean Architecture Solution template provides the simplest

18:20

approach to enterprise application development with ASPNet

18:22

Core and Clean Architecture. I'd say.net project

18:24

template, so it's deployed to New Get,

18:26

and you can create a new solution

18:28

from the command line using.net new or

18:30

Visual Studio 2022. Well should I pause

18:33

there? I should give you a second.

18:35

I've been talking a long time. No,

18:37

no, that's fine. That's fine. One of

18:39

the many things I like about the.net

18:41

new template thing engine dot new three

18:43

is the once you've installed the templates

18:45

Visual Studio, Rider, Visual Studio with Code

18:47

with the C-sharp Devkit extension. They can

18:49

all see those templates. I love that.

18:51

And like you said, you can do

18:54

it from the command line, right? It

18:56

doesn't matter what tool you use. You

18:58

can just go file new and there's

19:00

your project templates. That's so cool. Do

19:02

you know I didn't realize that it

19:04

was supported in Rider as well? Because

19:06

I don't use Rider. I know it's

19:08

a great product. We'll use it at

19:10

some point. We'll use it at some

19:12

point. We'll use it at some point.

19:15

We'll use it at some point. We'll

19:17

use it at some point. We'll use

19:19

it at some point. We'll use it.

19:21

We'll use it. We'll use it at

19:23

some point. We'll use it. We'll use

19:25

it. We'll use it at some point.

19:27

We'll use it. We'll use it. We'll

19:29

use it. We'll use it. We'll use

19:31

it. We'll use it. We'll use it.

19:33

We'll All three, well, okay, so let

19:36

me just backtrack a second. Visual Studio

19:38

Code by itself won't see it, unless

19:40

you do.net new in the command line.

19:42

But if you use the C-sharp Devkit

19:44

extension, which requires a visual studio license,

19:46

and there's a whole thing about that,

19:48

there's a whole, yes. I've talked to

19:50

Leslie on the team about that for

19:52

the show. there's an episode about that,

19:54

about how you get access to that.

19:57

But like, if it is relevant. to

19:59

the way that you work, you can

20:01

use the sort of free license, the

20:03

community license to get access to that.

20:05

Some people like that, some people don't.

20:07

But if you have that, you can

20:09

then do the equivalent of file a

20:11

new project and it will display all

20:13

of your templates. You can do, like

20:15

you said, inside of Visual Studio, file

20:18

a new project and it will display

20:20

all these templates. With the little, and

20:22

the best bit is the little icons.

20:24

Yeah. I love that when you've got

20:26

a icon for your project. For your

20:28

project, it just shows up. It's so

20:30

cool. And yeah, the same thing with

20:32

Rider because they're all my understanding is

20:34

that behind the scenes it does the.net

20:36

new CLI command and just reads the

20:39

metadata from the Jason templates and stuff.

20:41

Wonderful. Which is really cool. Well, I

20:43

didn't realize that the C sharp extension

20:45

supported it as well. So I'm learning

20:47

all sorts of things tonight. So that's

20:49

great. I do have a nice icon

20:51

so you'll see that come up if

20:53

you check it out in Visual Studio

20:55

or Rider or maybe DS code. Well

20:57

maybe that's it maybe everyone needs to

21:00

install the template and tweet at me

21:02

or X at me or however you

21:04

say it now whatever the verb is

21:06

a screenshot of you doing file new

21:08

projects so we can see what it

21:10

looks like in all the different all

21:12

the different ideas so go ahead and

21:14

do that folks that would be cool

21:16

I would love to see it There's

21:18

also obviously.net scaffold as well so I'd

21:21

be interested if you've this is me

21:23

dropping this on you right now so

21:25

I don't know if you've ever actually

21:27

tried this I haven't it's on my

21:29

it's on my list I got the

21:31

I got the email in my box

21:33

the other day and I like that

21:35

sounds interesting I'm in the middle of

21:37

preparing for a talk so I had

21:39

to just add it to my list

21:42

so I haven't I haven't read the

21:44

post yet have you read it I

21:46

have, it looks really cool, like an

21:48

interactive version of the.net new command line,

21:50

which is really cool. That sounds really

21:52

nice. I'm going to jump on that

21:54

pretty quickly, I think. Well, you heard

21:56

it here, folks. Not necessarily first, but

21:58

you heard it here. All right. So

22:00

yeah, it's a.net project ten. So then

22:03

you said when we were discussing what

22:05

clean architecture was, you were saying that

22:07

because you can sort of... separate out

22:09

those concerns to do with database technologies,

22:11

UI and all the other different technologies

22:13

that you may be using for your

22:15

application. Does that mean, and I am,

22:17

I've seen the template folks, so I

22:19

know the answer to this one, but

22:21

I'm getting the answer for you all,

22:24

does that mean that your clean architecture

22:26

template has no UI or that it

22:28

just uses, you know, rendered HDML or

22:30

like, how does that work then? It has

22:32

a UI, so the idea behind

22:34

the template is to try and

22:37

provide something that can help people

22:39

get up and running quickly. And

22:41

so I provide three different options

22:44

at the moment. I provide

22:46

an angular front end with a

22:48

web API back end, a react

22:50

front end with a web API

22:52

back end, or just web-made PI

22:55

by itself. In the future, I'd

22:57

like to add a view, and I'd also

22:59

like to add... laser web assembly.

23:01

So there'll be five different options,

23:04

aside from web API by itself,

23:06

that you'll see in the template.

23:09

And with each of those

23:11

options, there's a really nice open

23:13

API integration, which is really one

23:15

of the primary reasons that I

23:18

like to include a front end

23:20

because for me, having

23:22

open API integration. kind of

23:24

between say angular and the

23:27

web API means that I'm

23:29

not just generating an open

23:31

API spec I'm also generating

23:33

a typescript client for your

23:35

angular or react front end that

23:37

has all of the DTOs that are

23:39

defined on the back end and it also

23:42

has some really nice clients for

23:44

interacting with the web API so

23:46

you don't have to write all

23:48

of this code by hand. It's

23:50

generated for you. And when your

23:52

web API, when you change that

23:54

on the back end, when you

23:56

introduce a new endpoint, it auto

23:59

generates for you. And that just comes

24:01

with so many benefits, so it's a

24:03

really nice feature. But yes, to answer

24:05

your question, I do have a UI,

24:07

angular, react, views coming, Blaisal Web Assembly

24:09

is coming, all with an ASPNet core

24:11

web API in the back end, using

24:13

minimal API. The following is a paid

24:15

advertisement. Welcome back,.net enthusiasts. This is another

24:17

episode of the modern.net show, and today

24:19

we have a unique collaboration with industry

24:21

expert Jamie Taylor. Known for his insights

24:23

on our show over the past seven

24:25

years, he now brings those expertise to

24:27

your doorstep as an external contractor at

24:29

RJJ software in both B2B and C2C

24:31

engagements. Jamie has been instrumental in helping

24:33

businesses across the UK harness their digital

24:35

potential through custom software development tailored to

24:37

their specific needs. For our US-based clients,

24:39

he's facilitated transformational change by integrating cutting-edge

24:41

AI technologies into their systems, all while

24:43

maintaining his stellar reputation as a thought

24:45

leader in the field of Donnet and

24:47

software consultancy. Whether your company is looking

24:49

to elevate its UK operations or reshape

24:51

its US strategy, Jamie can provide tailored

24:53

solutions that exceed expectations. Reach out through

24:55

RJJ software today. and let's unlock your

24:57

business's digital potential. The audio for this

24:59

advertisement was created with AI. For a

25:01

potentially silly question, does that mean then

25:03

that I need to have node installed

25:05

and set up on my computer because

25:07

I know that angular and react and

25:09

view all make use of node, right?

25:11

Yeah, at this stage you do, at

25:13

this stage you do, but I'll look

25:15

at that a little bit in the

25:17

future. Obviously, one solution is deaf containers.

25:20

I've got a basic implementation. poor you

25:22

there, but I've also got to dive

25:24

in a little bit deeper and have

25:26

a look at what.net aspire is doing

25:28

with that regard because I think a

25:30

lot of a lot of that integration

25:32

could be sorted out just with.

25:34

with .NET Aspire. But

25:36

yes, at this

25:38

stage, if you're using

25:40

Angular React, you'll

25:42

need Node installed. But

25:44

if you're going

25:46

with a Web API

25:48

only solution, then

25:50

no, you won't need

25:52

it. You just

25:54

dropped that on me

25:56

there. I didn't

25:58

even realize that .NET

26:00

Aspire was on

26:02

the potential agenda. That

26:04

is really cool.

26:06

Sorry. It's a recent

26:08

introduction actually. I

26:10

added it to the

26:12

template last week.

26:14

Yes. So last week,

26:16

I had support

26:18

for .NET Aspire. It's

26:20

just an option.

26:22

If you're using the

26:24

IDE, you check

26:26

a box. If you're

26:28

on the command

26:30

line, you just go

26:32

dash, dash, use-Aspire.

26:34

And it'll be included

26:36

in your project.

26:38

And it currently supports

26:40

two integrations. You

26:42

can use Postgres or

26:44

SQL Server. And

26:46

it will spin up

26:48

those containers for

26:50

you. And have it

26:53

all ready to

26:55

go. So that's

26:57

another dependency, of course. You need

26:59

Docker if you're going to use

27:01

certain configurations of Aspire and Postgres

27:03

and SQL Server. It depends. I

27:05

like how, like, coolly you dropped

27:07

that there. It's like, yeah, it

27:09

sort of supports .NET Aspire, which,

27:11

you know, it requires a fair

27:13

amount of setup to do that.

27:15

So I've done it. It's fine.

27:17

It's not a problem. Man. You've

27:21

got to think it does

27:23

require a fair amount of setup,

27:25

maybe not for a simple

27:27

project. For a simple project, it's

27:29

okay. But for a complex

27:31

project, yeah, jumping through hoops. For

27:33

a template that produces more

27:35

than 12 different combinations of projects,

27:37

it was significant effort. Yeah.

27:39

But that's the thing with my

27:41

template, right? It's the simplest

27:43

approach to enterprise application development with

27:45

ASP .NET Core and Clean Architecture.

27:47

Once you go .NET new,

27:49

once you go file a new

27:51

project, the template itself, it's

27:53

getting a little bit complex. It's

27:55

not hard to maintain because

27:58

I have some really good tests

28:00

sitting behind it. But yeah,

28:02

there is complexity in building the

28:04

template. in producing that simplest approach. That's now got me

28:06

thinking there should be some questions about how in the heck

28:08

you manage all of that. So maybe we'll come back to

28:10

that in a moment. Yeah, for sure. I just

28:12

want to say that I really like

28:14

the idea because like the open API

28:16

stuff and typescript like generating that contract

28:18

ahead of time and you said like

28:20

every time that I make a change

28:22

to maybe one of my DTOs of

28:25

your models when I hit build it

28:27

will. rebuild those for me as

28:29

well. So then my UI and or

28:31

my UI engineer perhaps has all of

28:33

that detail up to date every time

28:36

that I maybe commit. Maybe I'm just

28:38

doing a belt or no, but like

28:40

every time I do that, it's automatically

28:42

done for me. I really like that.

28:44

That's it. I just want to say

28:47

real quick, and this is available for

28:49

free folks. That's it. Yeah, it's for

28:51

great. That's it. It's a work of

28:53

love and I'm always excited when I

28:55

can use it in my own projects,

28:58

but I'm very excited when people

29:00

all around the world are using

29:02

it for their projects and telling

29:04

me how they found value because

29:06

then I think I'm making a

29:08

difference more than in just my

29:10

small little space. So then how

29:12

do you manage all of that complexity?

29:14

So like are there specific challenges involved

29:16

with supporting? angular and react and perhaps

29:18

blazer in the future and perhaps viewing

29:21

the future and all that kind of

29:23

stuff because I can imagine like they

29:25

all have their own release cadences or

29:27

cadence I don't know you say it

29:29

but like they all have their own

29:32

release cadences and so like when a

29:34

new version of angular comes out are

29:36

you just going hey you know I'm

29:38

gonna release an update and you can

29:40

get the latest version or are you

29:43

happy to sort of sit? with a

29:45

specific version for a while or is

29:47

it like it's up to the implementer

29:49

once you've done.net new yes that's on

29:51

you to keep everything up today well

29:53

that's the thing with the templates actually

29:56

we've got we've got we've got a

29:58

few questions to address there so with

30:00

the template I'm driven by the.net

30:02

release cycle and so a lot

30:04

of my motivation comes around.net comp

30:06

time when we're going to release

30:08

say.net nine I'll start I'll start

30:10

working on the template prior to

30:12

that so you'll see a new

30:14

a new branch appear and maybe

30:16

it's um you know.net nine preview

30:19

six or something like that and

30:21

that's why I attempt to start

30:23

bringing the latest version of.net in

30:25

and I try to release that

30:27

new version as close to.net conference

30:29

possible so that people who are

30:31

excited who want to start working

30:33

with the latest version can do

30:35

so with the template. I don't

30:37

have that motivation. for my front

30:39

end frameworks for Engle and React.

30:41

So a lot of time, that'll

30:43

be driven by the community. So

30:46

it might be someone raising an

30:48

issue and saying, hey, Engle's getting

30:50

a bit old, do you think

30:52

we can upgrade to Engle 18?

30:54

Or they might even better, they

30:56

might be a pull request, or

30:58

that I can quickly review and

31:00

get that upgraded. So, so.net is

31:02

my driving force. and I take

31:04

care of that every year, but

31:06

for the front ends it's the

31:08

community who tends to drive that.

31:10

That makes a lot of sense,

31:12

right? Because you're just one person.

31:15

Yes. And you don't have infinite

31:17

amount of time. You mentioned earlier

31:19

on that you've got little ones.

31:21

We all have our own responsibilities

31:23

during the day, you can't actually

31:25

be out at the back and

31:27

call of quick update this thing

31:29

and update that thing, this new

31:31

package has come out, right? That's

31:33

right. Obviously the joke is that

31:35

in the node world there's a

31:37

new version of something every couple

31:39

of seconds, which is, there's an

31:42

element of truth there. That's one

31:44

of the reasons that makes clean

31:46

architecture so powerful. Having that independence

31:48

of the UI means that we're

31:50

able to kind of... operate in

31:52

a world where a web framework

31:54

is created every minute. Interesting. And

31:56

then I suppose a side question

31:58

before you get to the others,

32:00

let's say Jamie you comes out.

32:02

If I take the clean architecture

32:04

template that you've got, create a

32:06

new application with it, so I

32:09

create an instance of the clean

32:11

architecture using that template, and then

32:13

I want to implement Jamie UI,

32:15

it's just a case of making

32:17

a few relatively small changes, and

32:19

dada, there's my UI, right? Maybe.

32:21

It depends on the UI, and

32:23

this is something that I was

32:25

thinking about probably an hour ago,

32:27

because... I've built a clean architecture

32:29

template for Blazer in the past.

32:31

It's called Rapid Blazer. I have

32:33

been thinking about what to do

32:35

as Rapid Blazer. Should I upgrade

32:38

it to.net 9? It's getting a

32:40

bit out of date. Should I

32:42

bring a Blazer front end to

32:44

the main clean architecture template? And

32:46

what do we do about all

32:48

the different hosting models for Blazer?

32:50

We've got server site, we've got

32:52

web assembly, we've got what is

32:54

the other one? The unified, the

32:56

unified, not unified, not unified. I

32:58

forget now, there's some other model

33:00

of Blazer which I can't quite

33:02

recall at this stage. Now with

33:05

Blazer Web Assembly, it's relatively simple

33:07

for me to bring that into

33:09

the Clean Architecture template because it's

33:11

going to be a Blazer front-ent

33:13

communicating with an ASPNet core back-end,

33:15

right, which is exactly what angular

33:17

reactant view would do. But for

33:19

Blazer server... Well it doesn't actually

33:21

require an API because it's happening

33:23

on the server side. So if

33:25

Jamie UIs like Blaze a server,

33:27

that's a bit trickier. And it's

33:29

not a bit trickier because it's

33:32

difficult to do a clean architecture.

33:34

No you could easily bring Jamie

33:36

UI in. It's tricky because I

33:38

would have to introduce new data

33:40

structures into the template. to support

33:42

that different style of UI, which

33:44

would then move the template away

33:46

from being the simplest approach. He

33:48

would have some complexity built in

33:50

there because it needs to support

33:52

anger, it needs to support view,

33:54

it needs to support react, and

33:56

it needs to support laser server.

33:58

So for you, you can easily

34:01

create a new solution with Jamie

34:03

UI. For me in the template,

34:05

it can be a little bit

34:07

trickier. I've got a little bit

34:09

more to think about. Okay, okay.

34:11

There's always a solution, but it

34:13

might cost a lot of complexity.

34:15

Sure. Perhaps I should have been

34:17

a little clearer with my question.

34:19

Let's say that Jamie Y is

34:21

a node-based UI JavaScripty frontendy thing.

34:23

And it just it behaves similarly

34:25

to angular and react and most

34:28

of the others it has similar

34:30

sort of APIs and stuff like

34:32

that. Then adding that in. should

34:34

from my perspective as a dev

34:36

who is using the template I

34:38

should just be able to go

34:40

hey you know NPM ad package

34:42

that's it so when I said

34:44

small I meant sort of like

34:46

in comparison to the size of

34:48

the the template right yeah I

34:50

should have been able I should

34:52

be able to make some small

34:55

in comparison to the size of

34:57

the template changes to be able

34:59

to implement my new UI and

35:01

it just sort of works that's

35:03

it yeah for sure for sure

35:05

and it depends on also the

35:07

capabilities of the You might need

35:09

to think about how your UI

35:11

is going to spin up in

35:13

the local development environment, how it's

35:15

going to proxy requests back to

35:17

the API, because the hosting model

35:19

that we have in development of

35:21

course is completely different to what

35:24

we have in production. So we

35:26

have a few moving parts that

35:28

we set up just to make

35:30

sure that our development time experience

35:32

is nice. And you'll also want

35:34

to... update the open API integration,

35:36

just change the configuration slightly so

35:38

that you can generate a nice

35:40

client for Jamie UI using any

35:42

number of methods. And that makes

35:44

sense, right? It's because we've separated

35:46

that concern, let's put Blazer to

35:48

one side for a moment. Yes.

35:51

Because of the different hosting models

35:53

and the complexity. Because you've separated

35:55

that concern that makes that way

35:57

easier to do. It's not like,

35:59

oh no, we have to re-archate

36:01

the entire app because the UI

36:03

and the API are so tightly

36:05

connected because I've worked on, I'm

36:07

sure we've all worked on projects

36:09

somewhere. Yes. A decision has been

36:11

made that the UI and the

36:13

API are so... tightly interconnected that

36:15

if you take one away the

36:18

other doesn't work. Yeah for sure

36:20

sometimes there's a decision made to

36:22

do exactly that to have that

36:24

very specific back end for front

36:26

end but in this case I've

36:28

tried to be a little bit

36:30

more generic. Sure just real quick

36:32

from my perspective there's nothing wrong

36:34

with having a specific back end

36:36

for front end because you may

36:38

never change that front end right?

36:40

we talk a lot about in

36:42

the software engineering space about but

36:44

what if you want to change

36:47

the technology you've used but also

36:49

what if you never change the

36:51

technology that you've used right what

36:53

if you settle on angular right

36:55

for it I'm just literally picking

36:57

one out the air I have

36:59

no preference for angular react over

37:01

you but let's say you pick

37:03

angular and you settle on that

37:05

then you know having a specific

37:07

back end for that front end

37:09

is totally fine because you've taken

37:11

the dependency on we will never

37:14

change from angular and that is

37:16

cool that is that works right

37:18

exactly I often find that some

37:20

projects go 100% the other way

37:22

and they're like well we need

37:24

to build interfaces for the interfaces

37:26

and separate everything out even though

37:28

we're never going to change it

37:30

but what if in the future

37:32

in five years time we decide

37:34

to change it and I'm like

37:36

well that's cool but can you

37:38

see a need to change it

37:41

Don't put that complexity in there.

37:43

Yeah. And can you, can you

37:45

afford to build that system? And

37:47

can you afford to maintain that

37:49

system? And will the people who

37:51

come after you understand why you've

37:53

done what you've done and why

37:55

you made those decisions? Nothing's free.

37:57

All of these things that we

37:59

built into our solutions. Even with

38:01

clean architecture, independent of UI, database,

38:03

frameworks, that takes time and effort

38:05

to build that in. And so

38:07

yeah, if you don't need that

38:10

flexibility, then maybe clean architecture is

38:12

not the right choice. It's a

38:14

very interesting point. We've just said,

38:16

hey, maybe you shouldn't end up

38:18

with it. I think everyone should

38:20

check out your clean architecture repo

38:22

for sure. But then I think

38:24

the importance is in being pragmatic,

38:26

right? And actually saying actually, does

38:28

this... thing that I'm looking at

38:30

helped me to solve the problem.

38:32

Like you said, does it add

38:34

the relevant amount of complexity? You

38:37

know, because like you said, nothing

38:39

is free. That's it. Yeah. It's

38:41

the same thing with design patterns.

38:43

Design patterns are there to solve

38:45

a problem. If you don't have

38:47

that problem and you apply the

38:49

design pattern, all you've added is

38:51

unnecessary complexity. It's the same

38:53

thing with clean architecture. If you

38:55

don't need to be independent of

38:58

the database frameworks, UI, if you

39:00

have an application that's only going

39:02

to be around for a few

39:04

years and doesn't require that level

39:06

of flexibility, then you might have

39:08

added complexity to your solution unnecessarily.

39:10

But we build enterprise applications. And

39:12

so that's why this is the

39:14

typical approach for me. Those applications,

39:17

whether or not, they say it's

39:19

just a... a proof of concept,

39:21

it's just a temporary thing. They're

39:23

going into production and they're still

39:25

going to be there in 20

39:27

years' time and you'll have to

39:29

support them. Too many proof of

39:31

concepts that have gone into production

39:33

are no better now. Yeah, I

39:36

think we all have. I have

39:38

a story from my past where

39:40

I built an MVP that had

39:42

no functionality in whatsoever. It was

39:44

a Windows Forms. MVP just showing

39:46

off what I thought the UY

39:48

could look like. And I showed

39:50

it to the boss and three

39:52

days later he'd sold it to

39:54

someone and I'm like, it doesn't

39:57

do anything boss, it's just the

39:59

UY. Wonderful. Lesser learned. So we've

40:01

talked a little bit about the

40:03

front end stuff. I know that

40:05

there was lots of dangling questions

40:07

that I had. I don't know

40:09

if you want to cover some

40:11

of those or whether you're happy

40:13

to move. I know that there'll

40:16

be people listening go, wait, you

40:18

asked a bunch of questions there

40:20

Jamie and I'm hooked and I

40:22

can't remember what you asked. Oh

40:24

my gosh. We might have to

40:26

have a conversation after the podcast

40:28

then maybe we can... will be

40:30

active in the in the comment

40:32

section and provide a little bit

40:35

of feedback that way. Totally. If

40:37

you're enjoying this show would you

40:39

mind sharing it with a friend

40:41

or colleague? Check out Podcatcher for

40:43

a link to the show notes

40:45

which has an embedded player within

40:47

it and a transcription all that

40:49

stuff and share that link with

40:51

them. I'd really appreciate it if

40:53

you could indeed share the show

40:56

but if you'd like a few

40:58

other ways to support it you

41:00

could. Leave a rating or review

41:02

on your podcast or choice. So

41:04

if you head over to dot

41:06

netco or dot show slash review

41:08

You'll find loads of ways to

41:10

do that. You could consider buying

41:12

the show of coffee The buy

41:15

me a coffee link is available

41:17

on each show's show notes page

41:19

on the website This is a

41:21

one-off financial support option. You could

41:23

become a patron This is a

41:25

monthly subscription based financial support option

41:27

and the link to that is

41:29

included on each episode show notes

41:31

page as well I'd love it

41:33

if you could share the show

41:36

with a friend or colleague or

41:38

leave a rating or review. The

41:40

other options are completely up to

41:42

you and are not required at

41:44

all to continue enjoying the show.

41:46

Anyway, let's get back to it.

41:48

Yeah, yeah, we can do that.

41:50

So let's talk about CICD then

41:52

because that's a big thing for

41:55

pretty much enterprise full stop. So

41:57

here's a thing right there are

41:59

a few things that I even

42:01

when I'm working on a personal

42:03

project I will not work on

42:05

it without get or some kind

42:07

of source control and some kind

42:09

of CICD pipeline I'll maybe do

42:11

a.net new and get a template

42:14

or I'll do like the bare

42:16

bones of functionality if I'm splitting

42:18

into a UI and an API

42:20

right I'll spin up an API

42:22

that just returns hello and a

42:24

UI that reads the hell out

42:26

right and then I'm like right

42:28

cool commit that to source control

42:30

build a CIC pipeline because then

42:32

that's done yeah so CICD and

42:35

all that kind of stuff super

42:37

important so does your clean architecture

42:39

repo support that stuff? Is that

42:41

baked in? Or because it's on

42:43

GitHub, am I going right? I

42:45

need to create a get up

42:47

folder and create some workflows and

42:49

stuff. Like how does all that

42:51

work? It's baked in. Yeah, it's

42:54

actually been a really big focus

42:56

for me over the past couple

42:58

of years. So I've been focused

43:00

on the code to cloud journey

43:02

I like to call it for

43:04

the template. And two years ago,

43:06

my goal was to provide a

43:08

solution that could take you from

43:10

code to cloud in 45 minutes

43:13

or less. So I wanted it

43:15

to be a whole new project

43:17

to deployed solution on Asia, because

43:19

that's where my main focus is

43:21

within 45 minutes. And so I

43:23

actually upgraded the template and there's

43:25

a bunch of scripts in there,

43:27

there's pipelines as code, this infrastructure

43:29

as code with Bicep. And I

43:31

did it. It was like 20

43:34

minutes from new project production, you

43:36

know, even just waiting around for.

43:38

infrastructure to be provisioned and projects

43:40

to be deployed. But I had

43:42

a bit of a problem because

43:44

it wasn't the simplest approach. It

43:46

was going to be difficult for

43:48

me to maintain because I built

43:50

all this stuff from scratch. And

43:53

so anything that was wrong with

43:55

the script that you know potentially

43:57

removed resources that it shouldn't have,

43:59

that was a bit of a

44:01

problem for me. So it wasn't

44:03

the simplest solution. So at that

44:05

stage I started looking around and

44:07

Fortunately for me, a team at

44:09

Microsoft was already working on the

44:12

Azure developer, CLI, or AZD for

44:14

short. So I started working with

44:16

that and I really was blown

44:18

away by how well it aligned

44:20

for that vision that I had

44:22

for the simplifying the code to

44:24

cloud journey. So this is a

44:26

tool that integrates with us as

44:28

developers, our developer workflow. And so

44:30

right from project scaffolding through the

44:33

infrastructure set up, through the deployment,

44:35

all with a few commands. And

44:37

these commands you can run them

44:39

from the command line. or you

44:41

can run them through a VS

44:43

code extension, if you like. And

44:45

so the Clean Architecture Solution template

44:47

is ACD compatible now. And what

44:49

that means is, is that it

44:52

comes with a set of CICD

44:54

pipelines, both GitHub actions and Azure

44:56

pipelines. It comes with a set

44:58

of infrastructure as code. At the

45:00

moment, it's supporting just by set.

45:02

but I'd like to add terraform

45:04

soon. And it also comes with,

45:06

not just the bare bones minimal

45:08

infrastructure as code, it also comes

45:11

with a bunch of extra modules.

45:13

And these modules actually come from

45:15

the Microsoft team at AZD. They

45:17

built this whole. Bicep's starter kit

45:19

and this terraform starter kit. So

45:21

if you want to go in

45:23

there right now the template sports

45:25

postcrescual SQL item sequel server if

45:27

you want to support my sequel

45:29

it's relatively easy to do because

45:32

there's already a Bicep module or

45:34

a terraform module that you can

45:36

go in and use it. So

45:38

I went from 45 minutes to

45:40

now I can get things up

45:42

and running in like I don't

45:44

know two minutes of effort and

45:46

15 minutes of waiting around while

45:48

I make my coffee. Wow. It's

45:51

cool. Really good stuff. Yeah, that

45:53

is genuinely amazing. And you know

45:55

what you said? You said, you

45:57

know, I don't start coding until

45:59

I have a local get repository.

46:01

maybe have a something on GitHub,

46:03

CICD, pipeline, you want to get

46:05

it deployed to Asia. I could

46:07

do all of that in two

46:09

commands. So if I run dot

46:11

net new CA dash solution,

46:14

that'll create my clean architecture

46:16

solution, and then I run

46:19

AZD, pipeline, config, and that's

46:21

going to do everything else.

46:24

So it will go

46:26

and create a local Git

46:28

repository. It will note

46:30

that we don't have a remote configured,

46:33

it will ask us if we'd like

46:35

to put one on GitHub. It's got

46:37

the GitHub CLLI kind of installed as

46:39

a dependency of ACD, so it'll go,

46:42

yeah, sure, we'll create that for you.

46:44

What do you want to call it?

46:46

We'll call it Modern.Nan. So you'll create

46:48

that for you, what do you want

46:50

to call it? We'll call it. This

46:52

is Modern.com. This is just all for

46:55

the command line. And so it will

46:57

go off the repository on GitHub. and

46:59

then it'll go over to Asia, and

47:01

it'll create a service principle

47:03

with federated credentials so that

47:06

GitHub actions can now communicate

47:08

securely with Asia to provision

47:11

your infrastructure, and then

47:13

eventually to deploy your solution.

47:15

And it's also going to add

47:17

a bunch of GitHub actions,

47:19

variables so that the pipeline

47:22

can run and know about

47:24

the environment and the resource

47:26

group and all of those

47:28

sort of things. So yeah,

47:30

it's really like two commands

47:32

and two minutes and no

47:34

shortcuts. Yeah, proper CICD pipeline,

47:36

proper infrastructure, just ready to

47:38

go. Focus on business value, right?

47:40

Not the boring stuff. And I'll

47:42

repeat again. This is entirely

47:44

free. Being able to

47:46

issue two commands and

47:49

just let it do its thing

47:51

and have everything set up

47:53

in a number of minutes

47:55

is, wow, that is the

47:58

dream. That is the dream. Yeah,

48:00

like even so I use Obsidian

48:02

to make loads of notes about

48:04

stuff. I do not use Obsidian

48:06

without get because I know that

48:08

I can undo things and get

48:10

the information back or I can

48:12

have a log of what I've

48:14

worked on. So even in my

48:16

plain text life working on notes

48:18

for things, I use Git. I

48:20

love that for sure. So like

48:22

being able to just go, here's

48:24

two commands. Perhaps even with a

48:26

double ampersand if you're on a

48:28

Unix-like or a semicolon, if you

48:30

run a window, like run them

48:32

both in one step and just

48:34

watch them go. That is just

48:36

wow. That's it. And it is

48:39

the dream, right? That was my

48:41

dream. I wanted to be able

48:43

to start work on a new

48:45

client's side. And if we're able

48:47

to hit the ground running, then

48:49

I want to take the first

48:51

15 minutes to get something deployed.

48:53

before the first planning meeting so

48:55

that we've got something that we

48:57

can see I can go grab

48:59

a coffee and we can sit

49:01

down and think about what's the

49:03

first feature we can build we've

49:05

got the basics done you know

49:07

good teams take a couple of

49:09

weeks to do this we've done

49:11

it in two minutes what feature

49:13

can we build yeah because then

49:15

it's no longer theoretical it's like

49:17

because a lot of software development

49:19

is very wooly it's very theoretically

49:21

you can't see it and you

49:23

can't touch it until you have

49:25

a user interface and so if

49:27

you're spending a couple of weeks

49:29

setting everything up getting CICD pipelines

49:31

going, making sure that there is

49:33

some kind of UI, that's maybe,

49:35

if you do sprints, that's maybe

49:37

two sprints worth of work, that

49:39

you can't present to the customer,

49:41

the client, the whomever, and say,

49:43

hey, here is the thing that

49:45

you can interact with. Whereas, like

49:48

you said, if you can go

49:50

into that first meeting with them

49:52

and say, okay, cool, this is

49:54

not what it's going to look

49:56

like, but this is just a

49:58

starting place. But this whole thing

50:00

works. Yeah, that's it. It's ready

50:02

to go. So is that the

50:04

end goal of the template then?

50:06

You've used the echo. of phrases

50:08

like code to cloud in two

50:10

minutes is that the well two

50:12

minutes plus or minus 15 for

50:14

Asia to do its thing but

50:16

like code to cloud in two

50:18

minutes of user effort yeah is

50:20

that the end goal hmm it's

50:22

a good point well there's more

50:24

to the template than that so

50:26

once you've got that up and

50:28

running We have a bunch of

50:30

tests that are built in to

50:32

help you with how you go

50:34

to structure and test your logic.

50:36

And we also have a couple

50:38

of item templates that are built

50:40

in as well, just to help

50:42

you create your, or at least

50:44

structure your application logic. So I'll

50:46

be interested to see if people

50:48

are using the item templates and

50:50

how they might think they could

50:52

be changed or if things could

50:54

be added to them in the

50:57

future. So no. The goal is

50:59

to get up and run in

51:01

quickly and then yeah it's kind

51:03

of set you on your way

51:05

so that you can start delivering

51:07

business value the better it is

51:09

right because you've said it a

51:11

bunch of times the user of

51:13

the application the consumer the client

51:15

whoever's paying you to build it

51:17

they probably don't care about Are

51:19

we using react? We're using postgress.

51:21

We're using x-white. They don't care

51:23

about that. They care that when

51:25

a user pushes the button, they

51:27

somehow get money. That's all they

51:29

care about, right? Yeah, and they've

51:31

hired us as specialists. And as

51:33

specialists, we have specific technologies that

51:35

I'm good at that I can

51:37

use. And I can add. others

51:39

but they will be within my

51:41

specialization or they will be so

51:43

simple to add that it just

51:45

makes sense that yes of course

51:47

we should add that support for

51:49

the community because they'll get so

51:51

much value and it doesn't greatly

51:53

increase the complexity of the template.

51:55

I think people should think about

51:57

kind of this template and maybe

51:59

Maybe if it's not aligned with

52:01

their specialization, then they could consider

52:03

creating their own template. I think

52:06

everyone should have a goal to

52:08

go from new project to the

52:10

cloud or to a deployed system

52:12

within 45 minutes. You can do

52:14

it unless that's great, but within

52:16

your specialization, within the technologies that

52:18

you have great experience with, so

52:20

that you can focus on the

52:22

fun stuff as well, not the

52:24

boring stuff. So maybe that should

52:26

be. a long phone code cutter, right? I

52:29

know a lot of people like

52:31

to do practicing, like, as if

52:33

they are a martial artist, right?

52:35

The cutter is like a repeatable

52:37

exercise to build up muscle memory

52:39

and make you faster and make

52:41

you better at certain things. So

52:43

maybe one of the code catters

52:45

could be, I've got no project,

52:47

I do the equivalent of file

52:49

new, and then I get to...

52:51

deployment as fast as possible if

52:53

that's deployed to the cloud, if

52:55

that's a binary somehow. Maybe not

52:57

fast as possible, but like in a

52:59

speedy manner. Like you said, so that

53:01

then you can then abstract that stuff

53:04

away and get to the good fun

53:06

stuff. What a great exercise. That is

53:08

really cool. And you can tackle that

53:10

from whatever level you're at. I mean,

53:12

yeah, you might be a white belt.

53:15

You might be, let's say your X

53:17

Copy deploying. Well, that's fine. You can

53:19

improve on that. you can build up through

53:21

the levels and keep running that carter

53:23

until you are a black belt until

53:25

you do you can do it in

53:27

two minutes to a level that aligns

53:30

with your specialization. That's really cool. Yeah

53:32

because like there's nothing wrong with, okay

53:34

so how do I put this, when

53:36

I've talked to people who are excited

53:38

about technology in the past, who want

53:41

to learn development, there's lots of different

53:43

types of people and as soon as

53:45

you start saying they're different types

53:47

of people you're dealing with absolutes which

53:49

only you know only the safe deal

53:51

with absolutes but when you get to

53:53

that point I've seen a small group

53:55

of people who are like maybe they're

53:57

taking a course right and the course

53:59

requires them to use Windows and they're

54:01

like I'm not going to do that

54:04

I'm going to use Linux and I'm

54:06

going to use Docker and I'm going

54:08

to and they reel off a huge

54:10

list of technologies and I'm like that

54:12

is awesome but how about you start

54:15

with the stuff that the course tutor

54:17

want you to use first and then

54:19

slowly start replacing those things when you

54:21

get a better understanding right? Because like

54:23

you said right if you're doing X

54:25

copy to deploy or right click publish

54:28

to deploy That's cool that takes care

54:30

of all of that complexity for now

54:32

you can focus on the other steps

54:34

required to get you to right click

54:36

deploy yes then when you're happy with

54:39

those steps you can go right how

54:41

do I change that x copy deploy

54:43

or right click deploy to be something

54:45

scriptable yeah what does that look like

54:47

I can learn that separately at a

54:50

time when that makes sense for me

54:52

to take that in because the last

54:54

thing anyone wants when they're learning and

54:56

developing or trying to build out their

54:58

understanding of something is to learn too

55:01

much at once. Exactly. Because if everything's

55:03

moving and something breaks, you don't know

55:05

what's moving that's broken it, right? And

55:07

then getting someone's help when there are

55:09

so many moving parts becomes super difficult

55:11

because then they've got to understand what

55:14

you're trying to do. So I like

55:16

your idea or focus on maybe build

55:18

the app first and use right click

55:20

publish for now. Yeah, when you're ready.

55:22

Move on to that and then you

55:25

can step up through the different colored

55:27

belts or through the different levels. I

55:29

really like that idea. Me too. It

55:31

almost seems like a program that developers

55:33

could follow throughout their entire career. Absolutely.

55:36

Okay, so how about this? Hey, you're

55:38

a.net Dev who uses React and Angela

55:40

and Postgress and sequel server, but you

55:42

want to learn rust. Well, okay, let's,

55:44

yeah, you may want to skip over

55:47

Hello World, but let's figure out what

55:49

a rust application looks like, and we'll

55:51

use some kind of automatic deploy thing.

55:53

That's not a problem. Because you don't

55:55

need to worry about the intricacy of

55:58

deploying rust, but let's build it first.

56:00

Yes. Now we'll learn how to deploy

56:02

it. Yeah, that's such a brilliant idea.

56:04

I love the Carter element of it

56:06

because you're also I'm going to be

56:08

thinking, when I create this project, what's

56:11

the quickest way for me to initialize

56:13

a local get repository? What's the quickest

56:15

way for me to put it in

56:17

Azure Devops or on GitHub actions? And

56:19

these are all small improvements that you

56:22

can make. And those are all those

56:24

tiny little things along the way, whether

56:26

it's... creating the repo or pushing changes

56:28

or provisioning infrastructure or packaging application. These

56:30

are all things that you'll need to

56:33

consider if you want to go from

56:35

code to cloud in two minutes plus

56:37

processing time as we mentioned before. I

56:39

like it. Maybe you could use it

56:41

as like a course that you can

56:44

do. Maybe one of the NDCs or

56:46

something. Yeah, that would be a good

56:48

idea. I thought about that. I think

56:50

it would be fun. I think... There's

56:52

so much value in building these templates

56:54

and thinking about all these little moving

56:57

parts that it should be a skill

56:59

that we can learn and build upon.

57:01

We shouldn't have to hunt all around

57:03

the net to find all these disparate

57:05

pieces of information so that we can

57:08

have this skill. It'd be good if

57:10

someone did a course. Maybe me. I

57:12

agree with you. I think even just

57:14

from an organizational point of view, having

57:16

a this is how we build applications

57:19

template as a starter. place right just

57:21

do file new cool this is my

57:23

Acme default template cool that's taking care

57:25

of all of that stuff for me

57:27

like you said I've hit the ground

57:30

running I'm building it now yeah that's

57:32

it love it and then you use

57:34

your lunch and learns or whatever to

57:36

teach people have to build those because

57:38

you've built it internally and then you're

57:40

always passing on that new knowledge to

57:43

people as they come into the company

57:45

and come into the team and then

57:47

you're spreading that knowledge far and wide

57:49

I love it Wonderful. So we've been

57:51

chatting about the clean architecture repository and

57:54

the template and how it can help

57:56

folks. I think this was something you'd

57:58

said when we were coming up with

58:00

our notes, our plan for the conversation

58:02

was that be an accelerator or a

58:05

magical force multiplier is what these kinds

58:07

of things do. And I think you're

58:09

absolutely right. Being able to just code

58:11

to cloud in two minutes plus processing

58:13

time is just, and that processing time

58:16

will eventually get shorter. Oh yes. But

58:18

without any input from us, from you,

58:20

from me, from a user of the

58:22

template at all, because the cloud stuff

58:24

will get faster. So like without even

58:26

putting any effort into that part of

58:29

it. that will eventually get faster. There

58:31

is no reason not to try this

58:33

out. That's it. That's it. Yeah. Once

58:35

we've run those couple of commands, we

58:38

walk away. We're already making a coffee

58:40

as your or AWS. We'll do all

58:42

the hard work. We'll get our coffee

58:44

ready and sit back down to a

58:47

deployed solution. I love it. And I think

58:49

that even if you're not interested in clean

58:51

architecture, you should check out the repo. There

58:53

will be a link in the in the

58:56

show notes. Check out the repo because then

58:58

you can understand how it's put together. And

59:00

maybe like Jason and I have alluded to,

59:02

you can use that as a learning step.

59:04

Start that journey of like how do I

59:07

do I do this with node? Or maybe

59:09

I use go. Like how do I get

59:11

to the clean architecture repo that Jason has

59:13

put together, but with go or with. rust

59:15

or with some other, or even I'm going

59:18

to do it with ASP.netcore as well, but

59:20

I'm just going to recreate it in my

59:22

own way. For sure. Like I feel like

59:24

reading through it will help you to figure

59:26

that out for yourself. Yeah, that's it. That's

59:29

it. And reach out to me if you

59:31

get stuck. I have a little bit of

59:33

experience now building.net project templatesates. So I'm happy

59:35

to point you in the right direction. Amazing,

59:37

well Jason it's been fantastic talking with you

59:39

today. I wish we could talk about this

59:42

loads more but it is now super late

59:44

your time and super early my time and

59:46

none of that matters because people are listening

59:48

to this in the future which will

59:50

be the present for them and they're

59:52

listening to us in the past which

59:55

is the present for us and time

59:57

just doesn't make sense anymore. But I

59:59

really appreciate you being on the show.

1:00:01

Thanks Jamie. It's been wonderful. I've learned

1:00:03

some things myself. I'm excited to try

1:00:05

out some new things. And yeah, no,

1:00:07

I appreciate you having with me and

1:00:09

I enjoyed the conversation. So one last

1:00:11

thing, if folks are interested in getting

1:00:13

in touch, you know, you said earlier

1:00:16

on getting in touch, if you get

1:00:18

stuck, I might be able to help

1:00:20

out, is that a LinkedIn thing, is

1:00:22

that an X thing, is that a

1:00:24

blue sky thing, like how do folks

1:00:26

reach out and say, hey Jason, I've

1:00:28

tried to do this thing, I'm a

1:00:30

little bit stuck, can I get five

1:00:32

minutes of your time? I've got a

1:00:34

little bit of a link tree there

1:00:36

and you can connect me any way

1:00:38

you like whether it's LinkedIn or X

1:00:40

or whatever new social media platform I

1:00:42

add to it in the future. So

1:00:45

yeah connect. Jason Taylor. Dev. Nice, I

1:00:47

get a link to that, put that

1:00:49

in the Show Notes. I've collected a

1:00:51

whole bunch of links whilst we've been

1:00:53

talking anyway, but those in the Show

1:00:55

Notes as well. Awesome. Thank you ever

1:00:57

so much Jason Jason, I really appreciate

1:00:59

it. Thanks Jerry. Thank you for listening

1:01:01

to this episode of the Modern.net show

1:01:03

with me, Jamie Taylor. I'd like to

1:01:05

thank this episode's guest for graciously sharing

1:01:07

their time, expertise and knowledge with us.

1:01:09

Be sure to check out the show

1:01:12

notes for a bunch of links to

1:01:14

some of the stuff that we covered

1:01:16

and a full transcription of the interview.

1:01:18

The show notes as always can be

1:01:20

found at the podcast's website and there'll

1:01:22

be a link directly to them in

1:01:24

your podcatcher. And don't forget to spread

1:01:26

the word. Leave a rating or review

1:01:28

on your podcast or of choice. Head

1:01:30

over to dot netco.show slash review for

1:01:32

ways to do that. Reach out via

1:01:34

our contact page at dot netco.show slash

1:01:36

contact or join our discord server at

1:01:39

dot netco.show slash discord all of which

1:01:41

are linked in the show notes. But

1:01:43

above all I hope you have a

1:01:45

fantastic rest of your day and I

1:01:47

hope that I'll see you again next

1:01:49

time for some more.net goodness. I'll see

1:01:51

you again real soon. See you later

1:01:53

folks.