0:04

Hey folks, welcome back to

0:06

another Ruby Roaves this week

0:08

on our panel. We have

0:11

Ayush Nuatia. Hello. Hello? We

0:13

also have Valentino Stoll. And

0:15

now I'm Charles Max

0:17

Wood from Top Endeves. And

0:19

this week we have a

0:21

special guest and that's Emil

0:23

Kump. Hey everybody. So Emil,

0:26

I'm just gonna clear my

0:28

throat because wow. Okay, let

0:30

me try that again. So

0:32

Emil, I found you, I've

0:34

been corresponding with people, some

0:36

on the discord for Kamal,

0:39

which is the deployment technology

0:41

that DHH put out. I

0:43

think he made kind of

0:45

a deal about it at

0:47

Rails World last year and

0:50

then a whole bunch of

0:52

exciting stuff this year with

0:54

Kamal proxy and stuff like

0:56

that. I mean, I switched

0:58

over to... I switched over

1:00

from Kamal to Kamal to

1:03

with a whole bunch of

1:05

help from you and others

1:07

on there. And I have

1:09

to say, switching over was

1:11

a little rough. Having switched

1:14

over, it's a lot nicer.

1:16

Anyway, so beyond kind of

1:18

what I know about you

1:21

from that, what should people

1:23

know about you? First off,

1:25

I am a mountaineer and

1:27

in order to facilitate that

1:30

I live in a very

1:32

flat country so I do

1:34

a lot of running and

1:36

then I need to pay

1:38

for my travels so I

1:41

do also engineering and I've

1:43

made a career of

1:45

doing sort of critical

1:47

infrastructure or things that

1:49

have real world impact

1:51

and real world consequences

1:54

if something goes wrong, right?

1:56

So both in terms of

1:58

security and robust. and things

2:01

like that. And that's

2:03

everything from the FinTech

2:06

or the payment

2:08

industry to civil

2:10

engineering to online

2:12

voting. Wow. Yeah, it sounds

2:15

like kind of what our

2:17

topic is here, which

2:20

is building critical infrastructure.

2:23

So you've done some

2:25

stuff that I kind of

2:27

need to work. I guess. So

2:30

a banking obviously needs to

2:32

work, right? People get sort

2:34

of pissed if they don't

2:36

get their money. And then

2:39

for civil engineering, I worked

2:41

on tools that the engineers

2:43

would use to build the

2:46

airplanes, and run tests on

2:48

them, right? So both test

2:50

benches and design benches for

2:53

airplanes. And I mean, that

2:55

has a real world. consequence

2:57

because they fall out of

3:00

the sky right if you

3:02

mess it up yeah and

3:04

then yeah online voting that's

3:06

a whole thing and you

3:08

guys in the US just went

3:11

through one one of these

3:13

messy events and they're

3:15

messy everywhere right

3:17

oh yeah and recently I

3:20

moved to two compliance

3:22

and sort of making

3:24

trying to trying to make

3:27

trying to make that

3:29

easier and a better

3:31

experience to become compliant

3:33

and to obtain certifications.

3:36

Right, makes sense. So, let's

3:38

just dive in. I mean, I'm

3:41

not, I'm trying to think if

3:43

I've ever worked on anything

3:45

that was, you know, kind

3:47

of at the level of, hey, if

3:49

this breaks, then, you know,

3:52

really bad things happen. I

3:54

mean, if it breaks, I've... I've had

3:56

them come to me and be upset like

3:58

really bad thing happened, but right. It doesn't

4:00

affect society at large. What's

4:03

the difference between working

4:05

on those apps and working on

4:07

just kind of your, you know, you

4:09

mentioned not e-commerce or not, you

4:11

know, hey, I've got to manage

4:14

my social media or, you know, get

4:16

podcasts out on time. Yeah,

4:18

I mean, there's nothing, just

4:20

to be clear, there's absolutely

4:22

nothing wrong with that, right?

4:24

That's just, I... I started

4:26

out in that area as

4:28

many developers do, right, building

4:30

like some ad system when

4:32

I was very young and

4:34

then moved to some, you

4:37

know, sort of offer platform

4:39

and then I sort of

4:41

realized that it was, it

4:43

was just incontiquential

4:45

in a way, right? I looked at

4:47

people. I have people around me, my

4:49

father is a civil engineer, right? And

4:51

so I have people in my, sort

4:54

of my family, my near family, that

4:56

was building things in the real world.

4:58

And I was like, I want to

5:00

do that, but I do like this

5:03

computer stuff. So can we sort of

5:05

maybe find a way where I can

5:07

build things in the real world, just

5:09

using my computer? And so I slowly

5:11

started to shift over into something that

5:14

was... founded more

5:16

in civil engineering

5:18

and sort of

5:20

industry rather than commerce.

5:23

And then I started

5:25

in a FinTech company

5:27

where we were, where

5:30

I was part of

5:32

building out and continuing

5:34

to build on a

5:36

system where you can

5:39

basically, it's like

5:42

direct debits. bank

5:44

transfers but worldwide.

5:46

Okay. So and and there

5:48

it doesn't necessarily mean a

5:50

lot to you and me

5:52

and it's the same with there's

5:55

a bunch of them now

5:57

right like these same money

5:59

home. types of things. It doesn't

6:01

mean a lot to you and me,

6:04

but it does mean a ton to

6:06

those who is on the receiving end

6:08

of that, right? Because that's

6:11

like half a year's pay or

6:13

something that comes in, right? So

6:15

it does matter to those people.

6:17

So yeah, that was sort of

6:19

where I ended up and we

6:22

are moving a lot of money.

6:24

It seems it's one of those

6:26

where little like it's it's a

6:28

lot of tiny things that add

6:30

up right there's like millions and

6:33

millions of dollars being

6:35

moved around for that purpose and

6:37

you don't want to miss

6:39

handle those money right so you

6:41

are hooking into the banking

6:44

infrastructure into swift and into

6:46

the I-band network and the

6:49

whole sort of PC compliance

6:51

and everything with that, right? So

6:54

you need to make sure that

6:56

the software is robust, well

6:58

tested. Testing has been a

7:00

main thing of mine for

7:02

a long time because of

7:04

that. And also documented well,

7:06

right? So that's where I

7:08

sort of started out with

7:10

being required to document

7:12

what I was doing and how

7:15

it was supposed to work, rather

7:17

than just shipping fast and breaking

7:19

things. I was required to test.

7:22

and document, then test, then

7:24

stage it, then test

7:26

some more, then ship and

7:29

not break things. So that

7:31

was a different paradigm. So

7:33

that's sort of where I

7:36

first met that, right? And

7:38

that was a pretty great

7:40

experience. And so I was like,

7:42

oh, can I have more of this?

7:45

Can I maybe even get

7:47

even closer, right? Yeah, so

7:49

that's where all that started.

7:51

And then I was hooked on the

7:53

whole, can we test it? Can

7:56

we build something that runs Ruby

7:58

on rails, but make? the difference

8:00

to people's lives, like in

8:02

real world, right? And so this

8:04

was basically a payment situation

8:07

just built in Rubian

8:09

rails. And back then, many of

8:11

the banks didn't have a proper

8:14

API. So we ended up scraping

8:16

a lot. And that's, you know,

8:18

against terms of policy and terms

8:20

of service and all of that.

8:22

And they were really mad. And

8:25

we went through that whole shebang

8:27

of getting, you know, sort of...

8:29

scolded and far for that for

8:31

a while. Yeah, so it was a

8:34

bit the Wild West back then,

8:36

but it's definitely gotten

8:38

better and I think

8:40

there's a lot of,

8:43

again, sort of compliance work

8:45

and legal work that went

8:47

into the EU did a lot

8:49

to make sure that banks would

8:52

have... Not standardized APIs,

8:54

but a minimum level

8:56

of information that you

8:58

could retrieve with an

9:00

API, which made all of

9:02

that a lot easier, right? It

9:04

also means that I can technically

9:07

build my own banking app for

9:09

my own bank account because I

9:11

have API access to it. It

9:13

may not be obvious. It may

9:16

be put documented, but

9:18

it is there. And so I think

9:20

that's pretty cool. Yeah. I'm

9:22

curious Valentinor, Iyush, have experienced

9:25

doing this stuff. Nothing

9:27

that critical, no. The closest I

9:29

kind of came to anywhere near that

9:31

world was when I worked for transfer

9:33

wise, but I was an iOS developer,

9:35

so I didn't really have to do any

9:37

of the hard stuff. I just

9:39

made API calls, but I know

9:42

they were also doing quite a

9:44

lot of the scraping and stuff.

9:46

There's a lot of salinium going

9:49

on behind there to get into

9:51

different bank accounts. It's all a

9:53

bit scary when you think about

9:55

it. Yeah, yeah it really

9:58

is because like

10:00

your whole banking experience is

10:02

tied up on some scraper

10:04

working correctly and not messing

10:06

around with the the thousands

10:08

of dilemmters and the the

10:10

cent commas are different on

10:13

different regions right so you

10:15

don't want to mess around

10:17

with that and I did

10:19

transfer some money incorrectly the

10:21

the backbone banking system is

10:23

pretty robust as well so

10:25

we were able to basically

10:27

not move the money anyways

10:29

right but it far too

10:32

many money, the wrong place.

10:34

Whoops. Yeah, I will say

10:36

that. Oh, never mind. That

10:38

was a backbreaking day. I'll

10:40

bet. So I'm a little

10:42

curious as we get into

10:44

this. Like, you mentioned testing.

10:46

What does your testing setup

10:48

look like? Because I mean,

10:50

I'm sorry. When I write

10:53

my test is like. Okay,

10:55

it's good at like I'm

10:57

I'm reasonably confident right, but

10:59

I'm not like ironclad confident

11:01

like baking level confident that

11:03

my code works right Yeah,

11:05

yeah, that's a good question

11:07

I tend to not be

11:09

too dogmatic. I know there's

11:12

a lot of like do

11:14

this or do that paradigm

11:16

or do test first or

11:18

whatever and I I tend

11:20

to just play around with

11:22

it and make myself certain

11:24

first that this is going

11:26

to work whatever I'm sitting

11:28

with. And then when I

11:31

know that it, you know,

11:33

sort of I can see,

11:35

okay, it works, it does

11:37

what I needed to do,

11:39

then it is worth testing,

11:41

right? And then it's, I

11:43

try and test on the

11:45

lowest possible level first, which

11:47

means I will start with

11:49

something like unit tests. And

11:52

for that. I want to

11:54

permute everything right you want

11:56

to make. make sure that

11:58

every argument, so you basically

12:00

start with the least amount

12:02

of arguments for a method

12:04

and then you add an

12:06

argument slowly in I use

12:08

aspects, so it's in every

12:11

context block or in every

12:13

described block, right? So you're

12:15

certain that every version of

12:17

every argument is tested and

12:19

has been permitted. Yeah, so

12:21

that everything, like every variable

12:23

has been tested on its

12:25

own so you know how

12:27

it behaves both with and

12:29

without that particular variable and

12:32

you also know how it

12:34

behaves if the variable has

12:36

the wrong type right and

12:38

so because Ruby isn't quite

12:40

where we have type safety

12:42

yet and there's a lot

12:44

of work going on with

12:46

that but we aren't there

12:48

yet so I, you know,

12:51

you want to make sure

12:53

that we can handle strings,

12:55

numbers, not strings, truths, bullions,

12:57

whatever. There's like, I have

12:59

a little thing that basically

13:01

says, take this and just,

13:03

you know, cycle it through

13:05

all of the different types

13:07

it can be and just

13:09

put in garbage so that

13:12

I know it can not,

13:14

it doesn't break when a

13:16

number is presented rather than

13:18

a string or something stupid

13:20

like that, right? And then

13:22

you sort of, you slowly

13:24

move up. So you're confident

13:26

that this method works and

13:28

then you move up to

13:31

ever called it and then

13:33

you, what I do is

13:35

I, then I go through

13:37

and test that. But I

13:39

think, opposed to what is

13:41

DHH preaches or at least

13:43

sort of, he has this

13:45

idea that you would go

13:47

through the entire stack and

13:50

I believe that they had

13:52

their test to do that.

13:54

I tend to not I

13:56

tend to sort of stop

13:58

testing at each level, right?

14:00

So model tests are their

14:02

own thing. And then when

14:04

you test the controller, you

14:06

basically verify that the model

14:08

is being called with the

14:11

expected parameters because you know

14:13

you've already dealt with the

14:15

parameters on a lower level.

14:17

So it's not mocking per

14:19

se, it's just that I

14:21

only need to test that

14:23

the... model was created or

14:25

was called, I don't really

14:27

need to test that it

14:30

was the correct argument, right?

14:32

Because I'm certain about the

14:34

correctness of the arguments on

14:36

a lower level than that.

14:38

And then you saw slowly

14:40

move up, which means that

14:42

I find that that means

14:44

that the individual testing levels,

14:46

it gives you a little

14:48

bit more freedom to sort

14:51

of move a model around

14:53

because it's coupled somewhat on

14:55

a test level, but not.

14:57

tremendously, right? I only coupled

14:59

the controller to the model

15:01

in the sense that I

15:03

checked that the model was

15:05

called, not that it was

15:07

called with a particular set

15:10

of arguments. So it makes

15:12

it a little bit easier

15:14

to also restructure your tests

15:16

when your code change. But

15:18

yeah, it's just a lot

15:20

of work on lower level

15:22

things. I'm a big fan

15:24

of sobe, but it's not.

15:26

It's not quite there yet.

15:29

I think it works reasonably

15:31

well, but it's very hard

15:33

for developers to use and

15:35

so I think we need

15:37

to do there there needs

15:39

to be a lot of

15:41

work done in terms of

15:43

making it nice and sexy

15:45

to use so that we

15:47

can get people to use

15:50

it, right? I'd love to

15:52

dig in a little bit

15:54

more on the testability aspect

15:56

because one of the biggest

15:58

things I see miss is

16:00

maybe like skipping over like

16:02

the maybe some lower level

16:04

implementations and then like a

16:06

system update breaks something and

16:09

it just wasn't covered. right

16:11

like how do you go

16:13

about like you know waiting

16:15

whether or not that it's

16:17

worth it to like actually

16:19

run like a system command

16:21

or an external API call

16:23

or something like that? Yeah

16:25

so system commands I usually

16:27

check just that the signature

16:30

of the call is correct

16:32

and probably that it returned

16:34

the right thing right so

16:36

that if I hit the

16:38

OS I'm I'm basically testing

16:40

that I gave it these

16:42

parameters and I expected something

16:44

back like a string or

16:46

whatever it is, right? Because

16:49

it's so hard to know

16:51

what it was supposed to

16:53

be because sometimes the system

16:55

commands will change their their

16:57

signature but not necessarily the

16:59

signature. So that's that's very

17:01

hard. not go there. I

17:03

try really hard not to

17:05

go there because it is,

17:08

it's out of my control,

17:10

right? And on the other

17:12

end, when I call other

17:14

APIs, I definitely test that.

17:16

I use something like MECR

17:18

or something I capture all

17:20

the network traffic and I

17:22

make sure to do the

17:24

same kinds of sort of

17:26

making sure that if I

17:29

call it with... these arguments

17:31

that I have controlled over

17:33

I get this particular response

17:35

and if I do something

17:37

else then then it breaks

17:39

right or it gives me

17:41

the incorrect response and and

17:43

I also found that for

17:45

example with with banking that

17:48

one of the cool things

17:50

we did was that we

17:52

basically took all of the

17:54

historical records right that we

17:56

had for all the bank

17:58

accounts and we basically used

18:00

it as a testbed Because

18:02

then you can train on

18:04

that you can basically say

18:06

If I feed it all

18:09

of this information that we

18:11

know happened and it happened

18:13

correctly because it happened a

18:15

year ago or two or

18:17

whatever, it should result in

18:19

a particular set of like

18:21

it should result in a

18:23

particular value on the account,

18:25

right? So you can actually

18:28

use historical data as a

18:30

testbed. And that means that

18:32

you have a factual. way

18:34

to check if it's correct

18:36

or not. So yeah, I

18:38

tend to use that as

18:40

well. I also use that

18:42

when I did software for

18:44

the for the sort of

18:47

civil engineering and building flights

18:49

and testing that, right? We

18:51

also used a lot of

18:53

existing information to make sure

18:55

that we had input output.

18:57

So we understood that given

18:59

these inputs, this is the

19:01

output that we would expect,

19:03

right? We could basically take

19:05

old designs and try and

19:08

run them through and you

19:10

can see if does it

19:12

break it down that you

19:14

would expect does it run

19:16

the does it sort of

19:18

fit to the engineering standard

19:20

design standard that we were

19:22

implementing against they also have

19:24

test value that you can

19:27

use right or test data.

19:29

So it's also about going

19:31

out finding big test data

19:33

sets that you can use

19:35

to also make a statistical

19:37

sort of approach, right? I'm

19:39

not making any statistical claims,

19:41

but I am running a

19:43

lot of tests on a

19:45

lot of data that, you

19:48

know, you can be reasonably

19:50

certain that if there were

19:52

errors in your system, it

19:54

would have been caught by

19:56

this because it's so much

19:58

effective production data, right? Yeah,

20:00

I imagine that working with

20:02

like the public sector that

20:04

you would have a lot

20:07

of of access to that

20:09

data, right? I guess depending

20:11

where you live. Yeah, I

20:13

mean, I mean, interestingly enough,

20:15

none of this is for

20:17

the public sector, which is

20:19

a little bit weird. You

20:21

would think that it was,

20:23

but it actually isn't like

20:26

the regulation of the aerospace

20:28

is public sector, right? But

20:30

the actual building of airplanes

20:32

is a private commerce, right,

20:34

private industry. And likewise with

20:36

banking the... the regulation of

20:38

it is public but the

20:40

actual banks are private entities

20:42

and likewise with... Do you

20:44

find that difficult for like

20:47

the data access like is

20:49

that data proprietary then for

20:51

like doing large swaths of

20:53

tests or finding them? Yes

20:55

but most of the times

20:57

the companies are interested in

20:59

providing it right like if

21:01

you if you go on

21:03

to big airplane airplane or

21:06

an aerospace company and you

21:08

need to design a test

21:10

system for them or something

21:12

to help them build right?

21:14

They are interested in giving

21:16

you that kinds of data.

21:18

So it wasn't that it

21:20

was hard, it's just that

21:22

it is also quite narrow

21:24

in scope, like it's more

21:27

or less only for that

21:29

one, right? So in banking

21:31

it would be a lot

21:33

of records, but only for

21:35

one bank. So you would

21:37

only know how it looked.

21:39

in one type of account

21:41

system, right? And then you

21:43

would run over a test

21:46

on that. And now, two

21:48

seconds. Okay. All right. Okay.

21:50

Okay. There we go. Hello.

21:52

in terms of sort of

21:54

like what. Yeah, it doesn't

21:56

have a lot of breadth

21:58

you get it for like

22:00

one bank or one airplane

22:02

company or You get it

22:05

for one company who runs

22:07

elections, right? Public elections is

22:09

a bit different By definition,

22:11

you don't have any test

22:13

data because all of the

22:15

records are sort of you

22:17

don't know who voted so

22:19

you can't know How to

22:21

test that right so you

22:23

have to do a different

22:26

testing paradigm there Yeah,

22:30

that makes sense. I mean here in

22:32

the US we have a anonymous ballot

22:34

as well, right? Yeah. And I don't

22:36

know how they do it in other

22:38

states. I mean, I'm involved in the

22:41

process here in Utah. And yeah, you

22:43

send in your envelope and they with

22:45

your ballot in it and they validate

22:47

that your like your signature matches and

22:49

stuff off the envelope. But then they

22:52

pull your ballot out of the envelope

22:54

and put it in the pile to

22:56

be counted. And right,

22:58

they don't track who you voted

23:00

for in that case, or at

23:03

least they're not supposed to. Correct.

23:05

And that is also the case

23:07

for the digital solutions. Right. A

23:10

friend of a colleague of mine,

23:12

Stefan, who is a cryptographer, he

23:14

or previous colleague of mine, he

23:17

did a lot of work of

23:19

sort of gathering together, a lot

23:21

of the academic work so that

23:24

we could exactly do that in

23:26

a, in a, cryptography safe way

23:28

but online. And you could also

23:31

do it in a way that

23:33

it was, you know, you could

23:35

track it and you could ensure

23:38

that this was in fact the

23:40

case. Like you could give the

23:42

log data and the trace data

23:45

to mathematicians and they could verify

23:47

that mathematically it could only error

23:49

have worked if these rules were

23:52

followed, which was like, you know,

23:54

you anonymized and you did, you

23:56

did mixing and you did a

23:59

lot of these things, right? Right.

24:01

So you protect the identity of

24:03

the... voter, but you also ensure

24:05

that only people who are legally

24:08

permitted to vote, vote, and that

24:10

they're only cast one ballot and

24:12

things like that. Yeah, exactly. And

24:15

the test, the test, sort of

24:17

the build idea for that and

24:19

the testing regime for that is

24:22

significantly different, right? Because this is

24:24

in fact, the public space, to

24:26

your point earlier, Valentino, this is

24:29

a public domain, right? So you.

24:31

You are a bit more scrutinized,

24:33

you're also publicly scrutinized by everybody,

24:36

right? Because we all know how

24:38

it went with the dominion voting

24:40

machine case, right? That went real

24:43

fast, real downhill downhill. So, yeah.

24:45

Well, and you bring up the

24:47

dominion voting machine case, and whether

24:50

you believe that they worked or

24:52

didn't, there's... If there's

24:54

enough population that doesn't trust

24:56

it, then it causes problems,

24:58

right? Yeah. And that's the

25:00

same everywhere, right? And that's,

25:02

I found that sort of

25:04

on a completely different but

25:06

somehow related topic, I really

25:09

found that the aerospace or

25:11

the airplane industry was really

25:13

good because the, what's the

25:15

American one, the TSP. Transportation

25:17

Safety Board, is that Tuesday?

25:19

Yeah, TSB, right? Yeah, those

25:21

are the ones that do

25:23

crash audits, that sort of

25:25

like go through. Oh yeah,

25:27

the NTSB, yeah. Both them

25:29

and the European counterparts have

25:31

a really, really cool way

25:33

of going about it. They

25:35

don't ever go and say,

25:37

oh, it was that person's

25:39

fault. Right. If the person

25:41

hadn't slept enough. If the

25:43

person couldn't read the dials,

25:45

it is the fault of

25:48

their plan that that made

25:50

him not have enough hours

25:52

to sleep and it is

25:54

the fault of the dial

25:56

for not being visible enough.

25:58

Right? So it's not they

26:00

don't ever cast personal blame

26:02

or they very rarely cast

26:04

personal blame and I really

26:06

thought that was a super

26:08

cool way of going about

26:10

it. Also just from a

26:12

sort of like evaluating if

26:14

something works well, right? Just

26:16

like from a human perspective

26:18

and when you do leadership

26:20

in tech or if you

26:22

guide or lead others that

26:24

I found that really valuable

26:27

so that that whole way

26:29

of thinking about it. And

26:31

they also they collect a

26:33

ton of evidence right and

26:35

they have a very structured

26:37

way of collecting that before

26:39

they then conclude that it

26:41

works or didn't work or

26:43

that this was the fault.

26:45

But they also, I think

26:47

I learned a lot also

26:49

in terms of like having

26:51

redundancy. Like what happens if

26:53

this thing break? What happens

26:55

if your job runner doesn't

26:57

run? How are you alerted?

26:59

What happens if your email

27:01

doesn't send? How are you

27:04

alerted? How do you have

27:06

alternative options? Do you have

27:08

an alternative email provider that

27:10

you can switch to easily?

27:12

Do you have alternate job

27:14

runners that you can switch

27:16

to easily? Do you have

27:18

any of this, right? So

27:20

that redundancy ideology was pretty

27:22

cool. And for like large

27:24

scale systems, it pays off

27:26

to have extras of these.

27:28

Even though. you know you

27:30

use somebody like send grid

27:32

or use somebody like a

27:34

male chimp or something and

27:36

you know they say that

27:38

they scale and they do

27:40

right but then ever so

27:43

often it's down and it's

27:45

pretty nice to have a

27:47

backup even if it's a

27:49

tiny backup and even if

27:51

it's just you know up

27:53

and coming fairly cheap one

27:55

it will do the job

27:57

for like a day right

27:59

and you will actually still

28:01

send stuff out or you

28:03

will still process jobs or

28:05

you will still whatever it

28:07

is right and also running

28:09

like on the big scale

28:11

running something like Multicloud or

28:13

running something like an open

28:15

stack where you can actually

28:17

move to somewhere else pretty

28:19

fast. There was that case

28:22

with that the Australian case

28:24

where the where the bank

28:26

got taken down because someone

28:28

at Google decided to delete

28:30

their account right for like

28:32

160 million US worth of

28:34

service just got nuked. So

28:36

for those cases, it's pretty

28:38

nice to have a second

28:40

provider backup and some way

28:42

of getting there, right? That

28:44

is more a Devops problem.

28:46

It's not really a problem

28:48

that I've ever solved. It's

28:50

a problem that I have

28:52

sort of like assisted with

28:54

and talked about and verbalized

28:56

a lot in companies, but

28:58

it is to a high

29:01

degree a Devops solution that

29:03

needs to go in there

29:05

and not one that I

29:07

am. gonna build. So you're

29:09

talking a lot about like

29:11

people's lives and you know

29:13

their livelihood their money like

29:15

things that sustain life right

29:17

and so like obviously these

29:19

infrastructures are critical like what

29:21

tools you're using are critical

29:23

so I'm curious like what

29:25

about like Ruby and rails

29:27

you know specifically feature-wise like

29:29

do you see as being

29:31

like? part of that critical

29:33

process. I think the main

29:35

part for me is that

29:38

it can be built, you

29:40

can write it so that

29:42

it is absolutely readable and

29:44

understandable what's going on, so

29:46

you can reason about the

29:48

what's going to happen even

29:50

without necessarily understanding the language

29:52

fully or even without understanding

29:54

what This active record method

29:56

is going to do underneath

29:58

because stuff is named. well

30:00

and because it's ordered and

30:02

organized well, you can reason

30:04

about what's gonna happen and

30:06

you can have an expectation

30:08

that makes it a lot

30:10

easier to build complicated things.

30:12

Like you can go and

30:14

test it afterwards, right? But

30:17

just getting something that's complicated

30:19

up, like just getting it

30:21

up on its legs, it's

30:23

really nice to have something

30:25

that that is structured well

30:27

and that you can reason

30:29

about and that you talk

30:31

about the sort of... What's

30:33

the consequence of this method

30:35

or that method, right? Yeah.

30:37

There we go. So that's

30:39

a guest co-host. Yeah, exactly.

30:41

But I think and also

30:43

I find that it's I

30:45

mean, I've done a few

30:47

frameworks throughout my career, right?

30:49

I've always come back to

30:51

rails and ruby, and I've

30:53

also started there, so maybe

30:56

I'm biased, but I haven't

30:58

found any of the other

31:00

frameworks that provides the same

31:02

sort of consistent experience through

31:04

every part of the application,

31:06

whether or not you're doing

31:08

low-level active record stuff or

31:10

you're doing high-level system tests

31:12

or whatever you're doing. It's

31:14

consistently the same experience. Which

31:16

means that it's fairly easy

31:18

for a developer to switch

31:20

gears and do something else,

31:22

right? In the stack, I

31:24

mean. So like you can

31:26

have a person who is

31:28

sitting and doing the swift

31:30

transfer one week, right? And

31:32

then he can go and

31:35

he can look at the

31:37

web scraper the next, because

31:39

it's consistently the same experience.

31:41

and you can write it

31:43

in a way if you

31:45

have a good sort of,

31:47

if you have a good

31:49

style guide and you have

31:51

good code review, you can

31:53

get it to a point

31:55

where it's the same experience

31:57

every time. And you can

31:59

get abstraction levels and abstraction

32:01

layers that feels the same.

32:03

And that makes it easy

32:05

to build something that, where

32:07

you can also easily plug

32:09

out something and put something

32:12

else in, right? Like you

32:14

can switch out one database

32:16

provider for the other without

32:18

much. Or you can do

32:20

whatever, whatever it is that

32:22

you feel like you need

32:24

to change. can be quite

32:26

easy and quite straightforward if

32:28

you've set it up. To

32:30

be, and I'm not necessarily

32:32

talking about modularity in the

32:34

site work level of aggressiveness

32:36

that that Shopify has, right?

32:38

But you can definitely do

32:40

something along those lines with

32:42

just talking about it, organizing

32:44

the code. and just sort

32:46

of thinking about how is

32:48

this going to be tested.

32:51

I find that that's also

32:53

part of it, right? It's

32:55

like, how are we going

32:57

to test this? Because if

32:59

we are going to, if

33:01

we're going to test it

33:03

in this particular way or

33:05

that particular way, then that

33:07

informs the the API and

33:09

the sort of the interface

33:11

for it. a database you

33:13

tend to test the same

33:15

way, you know, if it's

33:17

file uploading or downloading, you

33:19

tend to test that the

33:21

same way, which makes it

33:23

easy to switch out one

33:25

component for the other if

33:27

your test paradigm is the

33:30

same, right, for that component.

33:32

So I feel that's that's

33:34

some of the reasons that

33:36

I've chosen this again and

33:38

again, right. And also like...

33:40

is a DJ set on

33:42

his keynote. This is a

33:44

one, like it can be

33:46

a one man army, right?

33:48

You can. can be pretty

33:50

fast and pretty dangerous with

33:52

it, which means you actually

33:54

need fairly low headcount to

33:56

get somewhere really fast. And

33:58

you can actually get something

34:00

that's really secure, solid, safe,

34:02

robust and easy on the

34:04

eyes and nice to use

34:07

with only a handful of

34:09

people, right? You can get

34:11

somewhere with just one person,

34:13

but you can definitely get

34:15

a long way with a

34:17

handful of people. You are

34:19

so speaking my language men.

34:21

This is why I'm here.

34:23

Yeah. So one thing that

34:25

I'm wondering about with all

34:27

of this is, you know,

34:29

it sounds like depending on

34:31

what the concerns are in

34:33

the app, right? So whether

34:35

it's banking or voting or,

34:37

right, you may have different

34:39

concerns about uptime or stability

34:41

or... you know, resumability, you

34:43

know, if Google deletes all

34:46

1800 year servers or, you

34:48

know, whatever, right? So how

34:50

do you begin to start

34:52

looking at your application and

34:54

saying, well, you know, for

34:56

example, in banking, right? We

34:58

have to make sure that

35:00

we don't have any of

35:02

these kinds of issues, bugs,

35:04

show up, right? you know,

35:06

make sure our accounting is

35:08

super robust. But then you're

35:10

talking about the voting and

35:12

it's, hey, we've got to

35:14

protect user data and make

35:16

sure that you're right. So

35:18

the areas of concern are

35:20

different. So how do you

35:22

start to address that? And

35:25

then from there, where do

35:27

you start to dive in

35:29

and make sure that you've

35:31

got a sound strategy for

35:33

making sure that you're meeting

35:35

those requirements? Yeah, that's a

35:37

good question. So for let's

35:39

just take voting because it's

35:41

up and hot and topic

35:43

these days, right? And so

35:45

it's just that there. Always.

35:47

So one of the things

35:49

there is that you definitely

35:51

want, so like, use them

35:53

previously, there's a few right

35:55

there. like the whole user

35:57

privacy and then there's the

35:59

vote secrecy and then there

36:01

is the use it needs

36:04

to be receipt free and

36:06

like there's a bunch of

36:08

these academic properties of vote

36:10

and an election right and

36:12

you go through each of

36:14

those and you you effect

36:16

you just sort of sit

36:18

down and you start at

36:20

one and then you try

36:22

and figure out how to

36:24

do that right this is

36:26

really the job of the

36:28

photographer? Like how do we

36:30

get this organized so that

36:32

we match all of these?

36:34

And then once we have

36:36

a viable protocol that will

36:38

do this, then the developers

36:41

come in and we look

36:43

at the protocol and we

36:45

go like, okay, this thing

36:47

is about encrypting the vote.

36:49

That needs to happen as

36:51

early as we can possibly

36:53

get it to happen, which

36:55

means it needs to have

36:57

an in the voters device,

36:59

right? So... We need to

37:01

generate, we need to pick

37:03

a curve, a cryptography curve,

37:05

and then we need to

37:07

basically generate key paths in

37:09

the device and we need

37:11

to encrypt it as early

37:13

as possible. And so you

37:15

go through sort of like

37:17

rigorously and slowly and just

37:20

sort of reason about when

37:22

will this part of the

37:24

process happen and where does

37:26

it need to happen? Sort

37:28

of more on a timeline.

37:30

Then we need to transmit

37:32

the vote. We transmit the

37:34

vote to the server and

37:36

then the server needs to

37:38

basically allow, if you need

37:40

to allow tracking or if

37:42

you need to allow receipts

37:44

or whatever is the property

37:46

you need to have, then

37:48

you need to figure out

37:50

a way to provide that

37:52

at this point. And then

37:54

you go on to something

37:56

like anonymization, which is effectively

37:59

where you take one. envelope

38:01

out of the other envelope

38:03

right to do the the

38:05

analogy That needs to happen

38:07

in a way that you

38:09

can prove that it happened.

38:11

So you need to have

38:13

a good trace here. You

38:15

need to have good locks

38:17

and traces that you can

38:19

publicly show. And then, you

38:21

know, so you sort of

38:23

move through the chain, sort

38:25

of like the event of

38:27

a thing, right? It's the

38:29

same. And so you sort

38:31

of... need to reason about

38:33

where is it going to

38:36

happen? That gives you some

38:38

ideas of should we need,

38:40

do we need a web

38:42

app, do we need a

38:44

mobile device, do we need,

38:46

do we need to run

38:48

cryptography, do we need to

38:50

run something advanced on the

38:52

user's device or is the

38:54

user's device just a portal?

38:56

And that gives you sort

38:58

of ideas on or some

39:00

inside into how this should

39:02

be organized, how this should

39:04

be tested, how this should

39:06

be planned out, right? But

39:08

most importantly for voting is

39:10

basically making sure that everything

39:12

is tracked. And we grabbed

39:15

part of the concept of

39:17

blockchain, which is has chain,

39:19

right? To basically hash everything

39:21

together. So you can't move

39:23

stuff in the middle without

39:25

everybody being able to know,

39:27

right? Things like that. Yes,

39:29

next week. Yeah, tomorrow public

39:31

escape, that's another thing. Say,

39:33

hey, God, you know. Then

39:35

we're at two. Did we

39:37

all this? Where's the rest

39:39

of sleep? No, it's him

39:41

at a toast. Yeah, they

39:43

are all. They're more of

39:45

man. Wow. And for, for

39:47

like, um... For

39:50

banking, right you want to you

39:52

want to make sure that see

39:55

the point is to get money

39:57

from A to B So you

39:59

want to reason about well first

40:01

off How am I going to

40:04

get the number that they intend

40:06

to send, right? Like, where does

40:08

that come from? Where does the

40:11

sort of outgoing amount of money

40:13

come from? This is the second

40:15

one. It's hard to be home

40:17

alone with kids. But so you

40:20

want to basically say, okay, so

40:22

where does the money come from?

40:24

And then you want to reason

40:27

about, well, How can I prove

40:29

that the money that came from

40:31

there that I got it right?

40:34

Like how can I make sure

40:36

that the intent was to send

40:38

it to me? How can I

40:40

make sure that the amount was

40:43

correct? Right? Because like, like we

40:45

talked about earlier with transfer wise,

40:47

for example, there is a lot

40:50

of web scraping. There is a

40:52

lot of this sort of craziness

40:54

going around. Less so now, more

40:56

so then, right? and you want

40:59

to make sure that you have

41:01

either done it a few times

41:03

that you're quite confident that you've

41:06

run it on big data sets

41:08

like you need to be certain

41:10

that you can pass these things

41:12

correctly and then you want to

41:15

sort of grab that information and

41:17

then we get into the whole

41:19

banking of how do they move

41:22

them there's like swift and that's

41:24

pretty taken care of the only

41:26

problem here was that it was

41:28

slow right So what we would

41:31

do is that we would basically

41:33

assume that if we could read

41:35

the intended money here, we could

41:38

effectively pay it out here immediately

41:40

and then just do the in-between

41:42

transfer later. So we would basically

41:44

have big stacks of money around

41:47

the world and we could immediately

41:49

pay out locally or take money

41:51

in locally and then we would

41:54

transfer later. So in that case

41:56

it was more question of... Can

41:58

you verify the amount here and

42:00

can you verify that it's the

42:03

sort of the correct amount and

42:05

the correct intendant? amount and can

42:07

you then make that payout over

42:10

here? Yeah, that's good. So, can

42:12

you do the payout here? Is

42:14

there sufficient funds? And then after

42:16

that, you sort of say, okay,

42:19

now we've, we've effectively solved the

42:21

user journey, right? We've taken money

42:23

in, we've paid money out. Where

42:26

effectively the user is happy or

42:28

both users are happy, right? Nobody

42:30

knows that we didn't actually move

42:32

the money. And then we can

42:35

take, you know, take it slow,

42:37

just do it properly, make sure

42:39

that we interact with the Swift

42:42

network, that's a bit slower. So

42:44

you need to have a buffer

42:46

in both ends to do it,

42:48

right? And the... ability to scrape

42:51

right so one of the critical

42:53

points here was that you have

42:55

to be able to always scrape

42:58

these websites in some capacity and

43:00

you have to actually write your

43:02

your code back then it was

43:04

you know scraping you have to

43:07

write it quite robustly and sort

43:09

of reason about what happens if

43:11

the layout changes because banks change

43:14

the layout surprisingly more than you

43:16

would think Because they don't care

43:18

about your ability to scrape it.

43:20

That's not their business, right? Which

43:23

is fair. It just means that

43:25

you have to be, you have

43:27

to think about the robustness of

43:30

a scraper like that, because what

43:32

happens if the item is not

43:34

classified, the same if the dumb

43:36

element doesn't have the same class

43:39

or the same ideas it used

43:41

to have, can we find it

43:43

by reasoning with words? Like can

43:46

we figure out, well, if it's

43:48

like, if it says some, can

43:50

we maybe then... figure out what's

43:52

over here next to it because

43:55

that might be the number I'm

43:57

looking for, right? So there's sort

43:59

of like reasoning like that, that

44:02

goes on. That's, yeah, and then

44:04

there's accounting, like a lot of

44:06

accounting, a lot of keeping tracks

44:08

just for legal and compliance reasons

44:11

on where is the money going,

44:13

who's it going to, KYC, all

44:15

of these, there's a bunch of

44:18

tooling after that, right? which is

44:20

sort of where I was introduced

44:22

to this whole compliance thing like

44:24

how do you make sure that

44:27

the people you're operating with I

44:29

in fact the people that they

44:31

say they are and I in

44:34

fact the right people that you're

44:36

supposed to be operating with right

44:38

and so that was also a

44:41

journey like how do you even

44:43

know that how do you make

44:45

tooling for them to identify themselves

44:47

at the latest possible time so

44:50

it's the least amount of sort

44:52

of burden or the least amount

44:54

of friction and make it as

44:57

easy as possible, right? There's a

44:59

bunch of providers out there that

45:01

can help you do that. You

45:03

can also do it yourself. It's

45:06

not super complicated, but you are

45:08

now dealing with people's private information,

45:10

because now you maybe have a

45:13

copy of their passport. How do

45:15

you deal with a copy of

45:17

a passport? You have to sort

45:19

of be like, okay, where do

45:22

I store this? How do I

45:24

make sure that none of the

45:26

developers can access this, right? Because

45:29

you don't want developers to just.

45:31

S.H. onto the box and just

45:33

be like, oh, let me just

45:35

download all the attachments. So you

45:38

need to be, you need to

45:40

make reasons, you know, sort of

45:42

need to think about how do

45:45

you then protect this data from

45:47

yourself in some way, right? Yeah,

45:49

so that it goes deep and

45:51

it goes far, right? You can

45:54

talk about this for a long

45:56

time and about all the reasonings

45:58

you have to make, but at

46:01

some point, you also have to

46:03

protect your systems from other developers

46:05

from Other, also high level people

46:07

in the organization, needs to be

46:10

kept on. because the higher up

46:12

you are the most the spear

46:14

fishing you are all wailing you

46:17

are effectively the subject of and

46:19

the greater the risk right so

46:21

you want people to not have

46:23

access maybe you even want the

46:26

CTO to not have access like

46:28

there's a bunch of considerations like

46:30

this in in the banking one

46:33

I was a senior developer, I

46:35

had access, then we had the,

46:37

one of the compliance officers, she

46:39

had access to the swift network,

46:42

and then, but the CTO and

46:44

the head of, sort of, the,

46:46

the, the, COO type person didn't

46:49

write because that that would, it

46:51

posed too much of a risk.

46:53

So there's also like these human

46:55

factors you have to think about

46:58

when you reason about this the

47:00

security of a system that that

47:02

actually impacts and it has something

47:05

to do for real world people.

47:07

That was a very long spiel.

47:09

Sorry. Yeah. It's fascinating when there's

47:11

so much on the line like

47:14

most of the apps I've worked

47:16

on like if it went down

47:18

it's like yeah fine. Okay. It's

47:21

not ideal but it's not the

47:23

end of the end of the

47:25

world. I kind of want to

47:27

pick up on something you mentioned

47:30

quite a while ago actually about

47:32

type checking and sort of like

47:34

that. I'm very much a fan

47:37

of the dynamic typing. I do

47:39

have a background in static programming

47:41

like because I started as a

47:43

mobile developer so I spend a

47:46

lot of time with objectives C

47:48

with Java and with Swift. So

47:50

I do have that background, but

47:53

ever since I kind of switched

47:55

to Ruby, I just love that

47:57

dynamic style and I just find

47:59

it easier to work with, but

48:02

I also get that when it's

48:04

critical infrastructure, the type checking. is

48:06

just almost essential. So I'm curious,

48:09

but why you went with Ruby

48:11

and Rails when the infrastructure is

48:13

so critical and type checking is

48:15

clearly something that's important to you?

48:18

And it's kind of bolted onto

48:20

the language. So what motivated you

48:22

to go with Ruby and Rails

48:25

instead of something that has it

48:27

natively? Yeah. So it is. to

48:29

high degree about the speed and

48:31

the very well-built testing frameworks that

48:34

is around it, right? So even

48:36

if it's not statically typed, you

48:38

can test a lot of things

48:41

and you can test it in

48:43

a lot of ways. Typing is

48:45

just one way of ensuring that

48:48

the data is correct. That doesn't

48:50

necessarily guarantee that the actual data

48:52

you are trying to read in.

48:54

is of the correct format or

48:57

whatever. It just means that once

48:59

you read it in, it will

49:01

fail because it's not the right

49:04

type. So it depends a little

49:06

on what you're trying to do.

49:08

You can also, because it's dynamic,

49:10

you can then sort of do

49:13

things like, okay, you gave, you

49:15

told me it was a CSV.

49:17

And it's obviously not a CSV.

49:20

And it obviously doesn't have a

49:22

string where you told me a

49:24

string was supposed to be. But

49:26

I can see how this can

49:29

look like a string. You have

49:31

these options of making things go

49:33

a little bit faster and a

49:36

little bit smoother because you can

49:38

sort of just fiddle a little

49:40

around with it. What tends to

49:42

happen in these systems as they

49:45

grow older and as they mature

49:47

is that parts of the core

49:49

of the system gets replaced with

49:52

something like Java or rust or

49:54

something like that. So that once

49:56

you have sort of you have

49:58

a really solid part, let's say

50:01

the transfer engine, right, that transfers

50:03

from one account to the other,

50:05

that hooks onto the Swift network.

50:08

Maybe you want to move that

50:10

into Java or something that's more

50:12

standing, more slow, but more type

50:14

robust than more, maybe even performance

50:17

optimized for IOA or whatever it

50:19

is that you need, right? But

50:21

then what tends to happen is

50:24

that you still want the speed

50:26

and ease of using Rubian rails

50:28

and having... Only a few developers

50:30

do a lot of features so

50:33

you can figure out what's good

50:35

or bad or what works or

50:37

doesn't or do a lot of

50:40

development around trying out this new

50:42

standard to verify with the engineers

50:44

that it will in fact test

50:46

correctly with this airplane or you

50:49

know sort of having that capability

50:51

to do feature spikes and to

50:53

do tests or like mini projects.

50:56

It seems to me that that

50:58

is to some degree lost when

51:00

you use a more, well, some

51:02

other language, right? But you are

51:05

right, like once you have it

51:07

down, once you have it locked

51:09

in, once you don't have any

51:12

changes there, what tends to happen

51:14

is it gets replaced with something

51:16

that's faster or better suited for

51:18

the purpose? Yeah, I've seen that

51:21

happened. The reasoning is that you

51:23

can go really fast with quite

51:25

few people and you can actually

51:28

get something that's meaningful that will

51:30

affect people's lives, that will better

51:32

somebody's life, you can get it

51:34

done pretty quickly, right? Like you

51:37

can get a design system for

51:39

to basically do, design some, we're

51:41

not talking like 3D sketches of

51:44

airplanes, that's not necessarily how you

51:46

design all of it. That's just

51:48

the building of it, but you

51:50

also need to reason about the

51:53

logic of who does what, what

51:55

are the processes. And you can

51:57

get something like that build. in

52:00

seven, eight months, right? That's, as

52:02

far as I know, that's, and

52:04

what I could see in the

52:06

market, right? And what happened was

52:09

that we basically went a lot

52:11

faster than everybody else, right? With

52:13

the same amount of errors. Like,

52:16

it seemed that there was no

52:18

real drawback to using Ruby in

52:20

that case, right? it was a

52:22

pure benefit to use the language

52:25

and the framework. Nice, you know,

52:27

there's really nothing that can compare

52:29

to the speed and development of

52:32

rails. It's, I think we kind

52:34

of take it for advantage, like

52:36

for granted, as rails developers, it's

52:39

when you go and look at

52:41

the outside world, is when you

52:43

realize that yeah, this is a

52:45

good tool. Yeah, yeah, it is

52:48

quite insane. Like, I had a

52:50

colleague who did a, you know,

52:52

sort of a... an AI-based feature

52:55

spike, you know, like, oh, can

52:57

we just time box this to

52:59

like three days? And in three

53:01

days we had a tool that

53:04

seems to be working, did integrate

53:06

with AI, had UI, had tests,

53:08

were behind a feature flag and

53:11

was effectively shippable, right? It was

53:13

not, you know, it was not

53:15

the best or the most robust

53:17

or whatever, but like in three

53:20

days a single person made a

53:22

full feature spike that could technically

53:24

be deployed and could work, right?

53:27

That's pretty amazing. I'm curious real

53:29

quick. Like, uh, I'm in my

53:31

experience working with like critical systems

53:33

like this, like once it's built,

53:36

there's like, it's hard to change,

53:38

right? Like, and mostly because like,

53:40

too, the requirements probably don't change

53:43

very frequently either. But like, how,

53:45

how do you like approach in

53:47

those cases like that change? Like,

53:49

is it like, like, build something

53:52

new and cut one off and

53:54

switch to the other or like

53:56

what whatever like what kind of

53:59

systematic approach do you take to

54:01

that? I think so for me

54:03

it's certainly about you have to

54:05

reason about the protocol in the

54:08

process somewhere other than the application.

54:10

So you have to diagram it

54:12

or put it into dance or

54:15

whatever you like to do but

54:17

we need to have a different

54:19

place to talk about it than

54:21

encode because we need to reason

54:24

about when somebody has a change

54:26

we need to be able to

54:28

reason about it before we spend

54:31

time in code and we need

54:33

to figure out if the the

54:35

sort of the signature of that

54:37

particular change let's say you want

54:40

to change one hashing algorithm with

54:42

another hashing algorithm right you need

54:44

to be able to reason if

54:47

that will break the system just

54:49

in principle before you start to

54:51

even try and implement it right

54:53

So I find that it really

54:56

benefits to have it in a

54:58

big diagram or have it written

55:00

out in long form in a

55:03

document or like somewhere that you

55:05

can reason with people who aren't

55:07

developers on whether or not it

55:09

will work or not before you

55:12

even try to implement. Because if

55:14

you can reason that it will

55:16

in fact work, it will plug

55:19

in, it will replace. If you

55:21

can reason about that before you

55:23

actually see the code, when you

55:25

come to the developers, it's a

55:28

much smoother experience to say, okay,

55:30

I need this piece replaced with

55:32

that piece. And yes, the hashing

55:35

algorithm is not the same, but

55:37

it is whatever based on the

55:39

same something, something, so it will

55:41

plug in, right? And then we

55:44

can either have both. if they

55:46

plug well we can replace one

55:48

with the other and do and

55:51

you can also then you need

55:53

to trends or migrate the data

55:55

right? But now that you're migrating

55:57

the data, it's really nice to

56:00

also have that conversation with beforehand

56:02

and with others who are not

56:04

developed. Well, we have existing data

56:07

and you want me to plug

56:09

this thing into this place in

56:11

this big diagram. What happens to

56:13

all the old data that went

56:16

through that point beforehand? Like, what

56:18

do we feel we need to

56:20

do about that? Do we want

56:23

to? revision it and say that

56:25

version less than something can never

56:27

be opened again or can never

56:29

be edited again but can only

56:32

be viewed. Like what's our reasoning

56:34

on that right? So having somewhere

56:36

else to talk about it then

56:39

in code really helps to figure

56:41

out if you should replace, plug

56:43

in or you know make it

56:46

as a different service that you

56:48

call sometimes, you know, whatever it

56:50

is. I find that having something

56:52

other than code really helps. I'm

56:55

still sure, man. Yep. And there,

56:57

okay. So it really needs somewhere

56:59

else to have that conversation, right?

57:02

Yeah, you know, it makes me

57:04

think about the old days of

57:06

Yahoo pipes, like where you could

57:08

visualize and like in real time

57:11

update the data flow of any

57:13

particular aggregate. thing you were trying

57:15

to collect. Are there any tools

57:18

like that that you use to

57:20

like maybe automate this process or

57:22

is it just a matter of

57:24

getting documented? That's a, I mean,

57:27

I've tried a bunch of them,

57:29

I haven't found one that I

57:31

really like, I haven't found one

57:34

that really does it for me.

57:36

I tend to try and make

57:38

them diagrams as code because then

57:40

they can at least get checked

57:43

into Git. and we can have

57:45

this version control on top of

57:47

it. But I haven't really found

57:50

anything that really does it for

57:52

me. I've done, I tend to

57:54

either do. whimsical or draw or

57:56

something like that. And then it

57:59

is just a lot of work

58:01

to keep it maintained and that's

58:03

a that sucks a bit but

58:06

you know it's it's hard to

58:08

it's hard to do without right

58:10

and without somewhere else to reason

58:12

and especially when you need to

58:15

talk to because it's not only

58:17

a technical problem right it is

58:19

also a business problem and it

58:22

is a regulatory problem if I'm

58:24

going to change this piece of

58:26

the testing bet for an airplane

58:28

or this piece of code for

58:31

the design software for an airplane.

58:33

I need to be able to

58:35

have a conversation with somebody who

58:38

is not a software engineer about

58:40

the consequences of that, right? Because

58:42

I need to talk to the

58:44

civil engineer, I need to talk

58:47

to the test manager, you know,

58:49

and I need to talk to

58:51

a lot of people about the

58:54

consequence of doing it and the

58:56

way to do it and are

58:58

there any consequences outside of my

59:00

system. that we need to have

59:03

a conversation about. It is just

59:05

sort of like trying to get

59:07

as many people joining that conversation

59:10

as possible. And for that, it

59:12

seems to work better if it's

59:14

not quite code, because then more

59:16

people can participate in that conversation,

59:19

right? Yeah, I think that makes

59:21

a lot of sense. I'm still

59:23

personally trying to find the silver

59:26

bullet. And that also works quite

59:28

well, actually. It's just, it works

59:30

pretty, it works pretty reasonable, and

59:32

it is definitely diagram as text,

59:35

right? So I've also used that

59:37

a ton, and it's decent enough.

59:39

I find that it has some

59:42

problems when you get up to

59:44

really large size stuff, like it's

59:46

hard to get enough in there

59:48

and still have it be. viewable

59:51

and understandable as a human. But

59:53

I mean a lot of like

59:55

building these systems and a lot

59:58

of participating in building them is

1:00:00

surprisingly not about code. It's about

1:00:02

talking to a bunch of people

1:00:04

who have nothing to do with

1:00:07

software development and figuring out if

1:00:09

you're going to break their lives,

1:00:11

right? Like are you going to

1:00:14

break something completely insane that you

1:00:16

had no idea that you ever

1:00:18

were ever going to touch? you

1:00:20

know, in the case of this,

1:00:23

well, I'm going to change this

1:00:25

thing in my design software. And

1:00:27

then suddenly somebody in the factory

1:00:30

somewhere is totally confused about how

1:00:32

to build an airplane because I

1:00:34

did something that, you know, so

1:00:37

it's really not that much of

1:00:39

a software challenge. I mean, it

1:00:41

is, but it is to high

1:00:43

degree a communication challenge and sort

1:00:46

of like, how do we even

1:00:48

communicate what this software does? to

1:00:50

people so that they can use

1:00:53

it and so we can reason

1:00:55

about the safety of it together,

1:00:57

right? Yeah, it makes sense in

1:00:59

the, I mean, I've worked on

1:01:02

things at this level of complexity

1:01:04

that you have to get right.

1:01:06

So I worked at Morgan Stanley

1:01:09

and I mean, we weren't doing

1:01:11

like banking level stuff, but we

1:01:13

were doing like investment level and

1:01:15

business information stuff, right? Yeah, the

1:01:18

world didn't end if we got

1:01:20

it wrong, but we kind of

1:01:22

needed it to get right. And

1:01:25

a lot of it was just

1:01:27

a matter of, like you said,

1:01:29

making sure that all the people

1:01:31

who understand all of the concerns

1:01:34

and all the things that it

1:01:36

touched are able to weigh in

1:01:38

and be part of the conversation.

1:01:41

And that way, yeah, you don't

1:01:43

do things without understanding the implications

1:01:45

of how it's going to ripple.

1:01:47

I'm working a contract now and...

1:01:50

You know, I'm still trying to

1:01:52

figure out the ins and outs

1:01:54

of the system and they're they're

1:01:57

managing funds and stuff like that

1:01:59

right and so Yeah, I'm definitely

1:02:01

feeling it here where I don't

1:02:03

want to make any changes that

1:02:06

ripple through the system and Right

1:02:08

and so this is where you

1:02:10

when you're talking about like testing

1:02:13

and documentation and things like that

1:02:15

where the documentation really isn't around

1:02:17

and there are a lot of

1:02:19

other things I wind up having

1:02:22

to ask a lot of questions

1:02:24

and I'm still not sure that

1:02:26

all my assumptions are correct. So

1:02:29

Yeah, a lot of this really

1:02:31

helps in the sense of oh,

1:02:33

okay If we're going to nail

1:02:35

down robust, you know, reliable things,

1:02:38

then yeah, you know, all of

1:02:40

these things are important. And I

1:02:42

think part of my issue with

1:02:45

some of it is just that

1:02:47

I like to just get in

1:02:49

and solve problems, right? I'm, my

1:02:51

mentality, I was talking to some

1:02:54

other friends the other day, and

1:02:56

my mentality is go, go, go,

1:02:58

go, go, go, go, go, go,

1:03:01

go, go. And so, yeah, having

1:03:03

to slow down, and you know,

1:03:05

dot all my, I joke and

1:03:07

say I dot all my T's

1:03:10

across all my eyes. It just,

1:03:12

it's, you know, it's, it's not

1:03:14

my natural state. And I think

1:03:17

a lot of developers, yeah, they

1:03:19

just, they just want to write

1:03:21

great code that solves problems. And

1:03:23

so the meetings are tedious, the

1:03:26

conversations are boring, you know, and,

1:03:28

you know, why can't I just

1:03:30

go in and just. make it

1:03:33

work and the reality is is,

1:03:35

you know, yeah, what we're talking

1:03:37

about here. And so I think,

1:03:39

I think it's not just we

1:03:42

have these specific concerns, whether the

1:03:44

regulatory or something else, I think

1:03:46

it's also that there's enough complexity

1:03:49

to it to where you really

1:03:51

do have to get in and

1:03:53

understand the nuance of what you're

1:03:55

doing. Yeah, and I think also

1:03:58

the breadth of what you're doing,

1:04:00

right, like I know this for

1:04:02

myself, right when I was younger

1:04:05

and, It started developing code radio

1:04:07

as well. like well there's only

1:04:09

one truth right like either it's

1:04:11

one plus one is two or

1:04:14

it's wrong right but that's just

1:04:16

not the case when you have

1:04:18

these really big connected systems right

1:04:21

where like well what happens if

1:04:23

I change this protocol well now

1:04:25

it's right because it's a different

1:04:27

protocol but now it's wrong because

1:04:30

it's a different protocol so it

1:04:32

can be both at the same

1:04:34

time right because it's because now

1:04:37

you know all the other people

1:04:39

who used it for one protocol

1:04:41

can't use the other and like

1:04:44

it just gets really messy. I

1:04:46

think at some point I realized

1:04:48

that I liked doing documentation and

1:04:50

that really helped to sort of

1:04:53

make me be confident that this

1:04:55

could be somewhere you can do

1:04:57

a career like you can do

1:05:00

a career and something that's not

1:05:02

obviously developer-ish territory right like because

1:05:04

I actually enjoyed doing like architecture

1:05:06

diagrams and reasoning outside of the

1:05:09

code and all of these things

1:05:11

I found was pretty interesting and

1:05:13

that makes it easier for to

1:05:16

be me right like it's more

1:05:18

fun to have that conversation with

1:05:20

everybody to figure out well if

1:05:22

we do this thing over there

1:05:25

in wherever we are operating in

1:05:27

Australia that's fine but now we've

1:05:29

done this change so what happens?

1:05:32

to our operations in Austria. Like,

1:05:34

is that the same tax system?

1:05:36

Can we do both? Like, it

1:05:38

can become really complicated when you

1:05:41

have, when you're operating under multiple

1:05:43

jurisdictions and multiple governance, right? Then

1:05:45

that can become complicated as well.

1:05:48

And, you know, you're doing currency

1:05:50

conversions or you're doing unit conversions

1:05:52

or you're doing all of these

1:05:54

things. Like, it's so hard that.

1:05:57

I know that even the space

1:05:59

agencies are getting it wrong and

1:06:01

sometimes there's stuff just won't work

1:06:04

when you get it into space,

1:06:06

right? Because somebody misconverted inches to

1:06:08

centimeters, right? And so it is

1:06:10

just, and that should like, if

1:06:13

you go to a, a freight

1:06:15

out of college developer and says

1:06:17

to him that I need a

1:06:20

unit conversion system, a unit conversion

1:06:22

method that can go from inches

1:06:24

to centimeters. That's pretty straightforward. That's

1:06:29

a pretty straightforward ask, right? And

1:06:31

you can do that method pretty

1:06:33

quickly. It's not really super hard.

1:06:35

What is really super hard is

1:06:38

getting people to use it, right?

1:06:40

So you need to build a

1:06:42

unit conversion method that is easy

1:06:44

to use, fun to use, at

1:06:46

hand when you need to use

1:06:49

it. so that you will in

1:06:51

fact use it because otherwise you're

1:06:53

going to do it in your

1:06:55

head and then it doesn't really

1:06:57

matter that you build a piece

1:07:00

of software right so like it

1:07:02

there's a lot of other components

1:07:04

to to this than just the

1:07:06

software like there's a lot of

1:07:08

things like you know there's a

1:07:11

lot of backup a lot of

1:07:13

everything but it is also about

1:07:15

making sure that the people who

1:07:17

use it use it use it

1:07:19

correctly and the way to do

1:07:22

that like we talked about before

1:07:24

like with the TSB and everything

1:07:26

it's not to blame the person

1:07:28

for not using the thing. It's

1:07:30

to blame the thing for not

1:07:33

being available when it was needed,

1:07:35

right? So you need to be

1:07:37

like, if I have a unit

1:07:39

conversion thing and it's hidden behind,

1:07:41

you know, a multiple three dot

1:07:44

options that you need to figure

1:07:46

out five levels in, that's the

1:07:48

wrong place to have it then,

1:07:50

right? You don't blame the person

1:07:52

for not using it, you blame

1:07:55

the system for not putting it

1:07:57

in his face when he needed

1:07:59

to convert the measurement. I like

1:08:01

I like that. Just from the

1:08:03

standpoint of. I mean. I guess

1:08:06

I guess. where my brain goes

1:08:08

is, is everybody has the responsibility

1:08:10

to understand the system and how

1:08:12

it works, right? And so everybody

1:08:14

has the responsibility then to, you

1:08:16

know, to be aware that this

1:08:19

method exists, but at the same

1:08:21

time, if I create it, then

1:08:23

it's also my responsibility to make

1:08:25

sure everybody knows it's there and

1:08:27

knows how to use it. And...

1:08:30

I also agree though that if

1:08:32

you make it easy or natural

1:08:34

to do the right thing, then

1:08:36

people will generally do the right

1:08:38

thing. Yeah. And so yeah, I

1:08:41

think I agree with you, but

1:08:43

I don't want to absolve anybody

1:08:45

of the responsibility of learning to

1:08:47

do the right thing either. No,

1:08:49

no. I mean, that's not what

1:08:52

I mean. You can you can

1:08:54

absolutely end up being blamed for

1:08:56

crashing a plane. Like it's not.

1:08:58

entirely out of the realms of

1:09:00

like the pilot can be blamed,

1:09:03

right? But it is also about

1:09:05

looking at did we actually provide

1:09:07

the correct tooling at the correct

1:09:09

time with the correct intensity and

1:09:11

all of this, right? And it's

1:09:14

the same here like, well, the

1:09:16

system didn't work. Did we provide

1:09:18

enough? Did we scale enough? Did

1:09:20

we have enough compute resources? Did

1:09:22

we have enough database storage? Was

1:09:25

it? just so slow that people

1:09:27

couldn't use it and it crashed

1:09:29

and somebody couldn't get their vote

1:09:31

in because if somebody couldn't get

1:09:33

their vote in then you know

1:09:36

we sort of we get into

1:09:38

the territory of oh somebody prevented

1:09:40

me from voting the situation right

1:09:42

so it like yeah they could

1:09:44

have done it again like they

1:09:47

could have just waited five minutes

1:09:49

till the peak was down and

1:09:51

voted again but that's like it's

1:09:53

also not really their fault right

1:09:55

so It's there's a lot of

1:09:58

there's a lot of sort of

1:10:00

like ancillary non-developer stuff to talk

1:10:02

about when when designing I'm pretty

1:10:04

sure there is on all systems

1:10:06

right? But the fun thing here

1:10:09

is just that this happens to

1:10:11

include other engineers, which is very

1:10:13

fun. And it happens to include

1:10:15

things like cryptographers and people who

1:10:17

actually like politicians or whatever it

1:10:20

is. It's just I like the

1:10:22

types of people that I get

1:10:24

to talk and interact with in

1:10:26

this rather than I get to

1:10:28

talk. less with marketing and social

1:10:31

media and more with like people

1:10:33

who build spaceships and airplanes and

1:10:35

I find that that that's basically

1:10:37

what drew me here right? Is

1:10:39

this idea that I get to

1:10:42

talk to other people who also

1:10:44

have this engineering spirit and this

1:10:46

idea to build something in the

1:10:48

same mindset that I do? Awesome.

1:10:50

All right well I think we're

1:10:53

going to go to PICS because

1:10:55

we've... We've been talking for an

1:10:57

hour and 15 minutes. This is

1:10:59

cool though. If people want to

1:11:01

connect with you or if they

1:11:04

have questions about what you're doing,

1:11:06

you know, maybe you want to

1:11:08

pick your brain about some of

1:11:10

this stuff. How do they find

1:11:12

you on the internet? I think

1:11:14

go to LinkedIn. Let's, I've more

1:11:17

or less tried to absolve myself

1:11:19

of all social media. So LinkedIn

1:11:21

is probably your best bet. It's

1:11:23

my name. It's right there on

1:11:25

the screeny thing. There it is.

1:11:28

And then also go go on

1:11:30

Discord. You can ping me there,

1:11:32

PM me, like you did. I'm

1:11:34

both on the Kamal, the Rails,

1:11:36

and the Ruby servers. So you

1:11:39

can just go find me there.

1:11:41

It's E-K-A-M-P-P, such as my initial

1:11:43

letter and my last name. Nice.

1:11:45

I didn't know that there were

1:11:47

Ruby and Rails. I'll have to

1:11:50

go find those. I

1:11:52

can I can send you invite links

1:11:54

that that would be perfect cool all

1:11:57

right there is one for like rails

1:11:59

develop that's the rails one and then

1:12:01

there is one for Ruby which is

1:12:03

more like application support and like oh

1:12:05

I don't understand what this method does

1:12:08

or I need to change this whereas

1:12:10

the rails one is more for like

1:12:12

I need approvals or reviews of PRs

1:12:14

for the actual core right so that's

1:12:17

more about supporting of that so it's

1:12:19

less interesting if you're trying to solve

1:12:21

a business problem but it is kind

1:12:23

of cool if you want to just

1:12:26

peek at what the others are doing.

1:12:29

Nice. Okay. Well, let's go

1:12:31

ahead and do some picks.

1:12:33

Valentino. Do you want to

1:12:35

start us with picks? Sure.

1:12:38

I've got nothing but AI

1:12:40

picks today. There's been a

1:12:42

lot of activity in the

1:12:44

Ruby world. Andrew Kane has

1:12:47

released yet another AI gem.

1:12:49

Bless his heart. It's called

1:12:51

Informers. And it basically lets

1:12:53

you run inference in Ruby.

1:12:56

on onyx models. So lots

1:12:58

of hugging face models are

1:13:00

onyx supported and you can

1:13:02

now just run inference with

1:13:05

those. And he also has

1:13:07

Transformers RB if you are

1:13:09

interested in running inference on

1:13:11

non-onics models. So now we

1:13:14

have like a complete picture.

1:13:16

Hopefully there are some... Some

1:13:19

missing pieces still for larger

1:13:21

models, but it has a

1:13:23

ton of pipelines already built

1:13:25

in. So I would suggest

1:13:27

checking that out. The next

1:13:29

pick, somebody built this awesome

1:13:31

chat app where they've aggregated

1:13:33

all of the rails and

1:13:35

Ruby like articles and blogs

1:13:37

and guides and everything like

1:13:39

that. So you can basically

1:13:41

rag the entire rails community

1:13:43

ecosystem. in a chat gPT

1:13:45

style interface and it's it's

1:13:47

remarkable and it does like

1:13:49

citations and everything like that

1:13:51

so you can see the

1:13:53

original article that referenced whatever

1:13:55

it was you're interested in.

1:13:57

It's really awesome. It's called

1:13:59

Ship on Rail's and it's

1:14:01

built with this really cool

1:14:03

tool called Nasea which provides

1:14:05

basically like a rails app

1:14:07

ready to go so that

1:14:10

you can ingest your own

1:14:12

documents to rag against and

1:14:14

do a very similar thing.

1:14:16

It's really cool so I'd

1:14:18

recommend checking all those out.

1:14:20

Nice. How about you Ayush?

1:14:22

Not sure what to take

1:14:24

for PICS this this week.

1:14:26

I haven't really thought of

1:14:28

anything. It's a cheap one,

1:14:30

but I'm going to go

1:14:32

with Blue Sky because I'm

1:14:34

quite enjoying Blue Sky in

1:14:36

the last week because I've

1:14:38

finally signed up for it

1:14:40

and a lot of Ruby

1:14:42

folks have signed up recently.

1:14:44

It's quite a lot of

1:14:46

activity on there. I'm quite

1:14:48

quite enjoying it on the

1:14:50

social network. Hopefully it can

1:14:52

stay. The way it is,

1:14:54

I'm active on both Blue

1:14:56

Sky and Masterdown for now,

1:14:58

but yeah, we'll see what

1:15:00

happens because Blue Sky is

1:15:02

still a VC-funded, privately held

1:15:04

company, so we'll have to

1:15:06

see how long things remain

1:15:08

good, but for now I'm

1:15:10

quite, quite happy with it.

1:15:12

What else can I pick?

1:15:14

I haven't really watched anything

1:15:16

or anything new recently, because

1:15:18

I think I had picked

1:15:20

a TV show shrinking shrinking,

1:15:22

which I did. the last

1:15:24

time so I don't want

1:15:26

to pick that again. I'll

1:15:28

go with a music pick

1:15:30

because I always go with

1:15:32

a music pick when I'm

1:15:34

struggling. What's in front of

1:15:36

me? The new Tias for

1:15:39

Fears album. Check this one

1:15:41

out. It's really good. It's

1:15:43

a live album with a

1:15:45

few new songs from 80s

1:15:47

pop band Tias for Fears.

1:15:49

So yeah, I'll think I'll

1:15:51

go with those. Anyway.

1:15:54

Let's see. I'm going to throw

1:15:57

in some picks. So I played.

1:15:59

I played a new game. I

1:16:01

actually played a couple of new

1:16:04

games this week. Because the game

1:16:06

convention that I usually teach games

1:16:09

at is going to be on

1:16:11

Saturday. And so I need to

1:16:13

be able to teach these games.

1:16:16

So I'm going to pick one

1:16:18

of those. It's called MLEEM. MELEM.

1:16:21

MELEM. And essentially what it is,

1:16:23

is it's, it's cat astronauts. And

1:16:25

the way that it works, it's

1:16:28

a relatively simple game. It was

1:16:30

almost too simple for me to

1:16:33

be honest. But if you're kind

1:16:35

of a casual board gamer, right,

1:16:37

it's definitely approachable. Let me pull

1:16:40

it up on board game geek

1:16:42

But yeah, so what the way

1:16:44

that it works is you have

1:16:47

Astronaut cats that are Going going

1:16:49

into space and they're basically occupying

1:16:52

planets and moons and so you

1:16:54

pick one of your Your cats

1:16:56

it on the rocket and somebody's

1:16:59

the captain and somebody's the captain

1:17:01

and somebody's the captain and they

1:17:04

roll the captain and somebody's the

1:17:06

captain and they roll the captain

1:17:08

and they roll the captain and

1:17:11

they roll the captain and they

1:17:13

roll the captain and they roll

1:17:16

the captain and they roll the

1:17:18

captain and they roll the captain

1:17:20

and they roll the captain and

1:17:23

they roll the captain and then

1:17:25

And if the dice match what's

1:17:28

on the space on the board

1:17:30

that you're on, then you can

1:17:32

choose which dice to use in

1:17:35

order to move up the board,

1:17:37

right? And so if you have

1:17:40

boosters, boosters move you up for

1:17:42

free. The other ones, you have

1:17:44

to give up the dice in

1:17:47

order to move. And so if

1:17:49

you ever get to the point

1:17:52

where you roll the dice and

1:17:54

you... You can't use any of

1:17:56

the numbers, then you can't use

1:17:59

the ship. And at

1:18:01

any point, people can get

1:18:03

off the ships onto moons

1:18:05

or planets. And you get points

1:18:08

for having the most cats

1:18:10

on planets. You get points

1:18:12

for every moon you occupy.

1:18:14

If you go away to

1:18:16

deep space, then you get

1:18:18

bonuses for that. And

1:18:21

then the different cats have

1:18:23

different abilities, right?

1:18:25

One of the cats lets you start

1:18:28

further up the board. One of the

1:18:30

cats lets you, you know, lets you

1:18:32

get off the ship after it crashes,

1:18:34

right? So you can go to the

1:18:36

planet, it's next to, or whatever, when

1:18:39

it crashes. One of them gives

1:18:41

you a bonus, doubles your points

1:18:43

for the planet, it's on, one

1:18:45

of them doubles the points for

1:18:47

the moon, it's gone, it's on.

1:18:49

Anyway, you get the idea. One

1:18:51

of them doubles the points if

1:18:54

you're in deep space. We got

1:18:56

close a couple times. But then I

1:18:58

was talking to some other people who had

1:19:00

played it a couple of other times and

1:19:02

one of the times they played they made

1:19:04

it to you space like three or four

1:19:06

times. So anyway, so if you're the

1:19:09

captain you're rolling and then you just

1:19:11

rotate who the captain is. If the

1:19:13

captain gets off the ship then the next

1:19:16

person then line just finishes out

1:19:18

that round. Anyway, that's basically the

1:19:20

game. Board Game Geek has it as a

1:19:22

one point 68 weight. It says ages

1:19:25

eight plus. And yeah, I have

1:19:27

an eight year old. She

1:19:29

could definitely play it. It

1:19:31

says 30 to 60 minutes.

1:19:33

That's probably about accurate place

1:19:36

two to five players. I

1:19:38

played it with four players

1:19:41

and that felt pretty good.

1:19:43

So it's MLEM, L-E-M space

1:19:46

agency. And yeah, anyway, check

1:19:48

it out. And then I'll just

1:19:50

put a link in the

1:19:52

comments here. And

1:19:59

then Let's see. I'm not sure

1:20:01

if I really have any other picks.

1:20:04

I know I've kind of been

1:20:06

doing other things and getting

1:20:08

involved in other things, but

1:20:10

I guess the big thing that

1:20:13

I went through this lately is

1:20:15

I went up to a retreat

1:20:17

up in Sundance, which is actually

1:20:20

like 45 minutes from here.

1:20:22

You heard of the Sundance

1:20:24

film festival, they do

1:20:26

actually do that in

1:20:28

Park City. not in

1:20:30

Sunnets, but from here it's

1:20:32

about two-thirds of the way to

1:20:35

Park City. And anyway, it's

1:20:37

up Provo Canyon and these

1:20:39

guys were running essentially

1:20:42

a mastermind for three

1:20:44

days for Christian

1:20:46

entrepreneurs. And so we did

1:20:48

a lot of faith-based stuff, we

1:20:51

did a lot of

1:20:53

business-based stuff. And it was

1:20:55

amazing because they just kind

1:20:57

of... Help me get clarity on

1:21:00

what I want to do and who

1:21:02

I want to be and what kind

1:21:04

of difference I want to make

1:21:06

So Just keep an eye out because

1:21:09

I have stuff in the works But

1:21:11

it was terrific and I

1:21:13

really want to just put forward

1:21:15

I guess that just connecting

1:21:17

with other people who are doing

1:21:20

what you're doing or who are

1:21:22

learning what you're learning or who

1:21:24

are? maybe a little ahead of

1:21:26

you on on the path you

1:21:28

want to go down. So helpful,

1:21:31

so, so helpful. You know, kind

1:21:33

of like we were talking

1:21:35

about with like the discord

1:21:37

servers, right? So much help,

1:21:39

helpful stuff there. So

1:21:42

anyway, those are my picks. Emil,

1:21:44

what are your picks? And so

1:21:46

recently, I'm going to pick a

1:21:48

book. I recently read a book

1:21:51

called how big things gets done.

1:21:53

And it's by a, by a Danish

1:21:55

guy called Pet Flubia. So what he

1:21:57

did was that he went, I don't

1:21:59

know. I don't know if you

1:22:01

guys know it, but he went

1:22:04

through statistical data on overruns on

1:22:06

big projects, like how far behind

1:22:08

is an IT project in general?

1:22:10

How much of an overrun on

1:22:13

cost do you get? How much

1:22:15

of an overrun on time do

1:22:17

you get? And he goes through

1:22:20

sort of like these different industries

1:22:22

and different factors that play into

1:22:24

why big things fail and why

1:22:26

some big things get done? What

1:22:29

are the ways to make sure

1:22:31

that big things get stuck? And

1:22:33

what are the pitfalls and everything?

1:22:35

And he goes through everything from

1:22:38

the Sydney House, Sydney Opera House

1:22:40

to like big government IT projects

1:22:42

that fail. It's just super cool

1:22:44

because it's various sort of data

1:22:47

driven and he has spent his

1:22:49

career collecting data on why big

1:22:51

projects fail, why all kinds of

1:22:53

projects fail. So it's a really

1:22:56

interesting sort of. window into do

1:22:58

this if you really want to

1:23:00

mess it up. So by inversion,

1:23:03

if you don't want to mess

1:23:05

it up, don't do all of

1:23:07

this. Do the other thing, right?

1:23:09

That's kind of an interesting statistics

1:23:12

to have. And so yeah, how

1:23:14

big things gets done. I found

1:23:16

that was really cool. Awesome. All

1:23:18

right, well, thanks for coming Emil.

1:23:21

We're going to go ahead and

1:23:23

wrap it here. Thank you for

1:23:25

having me. It was a pleasure.

1:23:27

And until next time, Max out.