#begin

Back on December 8 (and 9) of 2022 it was time for one of my favorite conferences, DevTernity! This has always been that one conference of the year that really focuses on programming, software architecture, leadership and most importantly: Craftsmanship!

I’ve been following DevTernity for a long time now. There are many really awesome talks you can find on YouTube from previous editions. The ones from this year will be posted spread across 2023 I suppose. However, if you bought a ticket you will get early access to all talks before they are posted on YouTube. Awesome, Right!?

This years lineup was truly amazing. Such big names like: Kent Beck, Uncle Bob, Mary Poppendieck, Venkat Subramaniam, Kevlin Henney, Scott Hanselman, Sandro Mancuso, Jimmy Bogard, David Neal, Scott Wlaschin, Allen Holub and many more. I just named the people I consider more widely known. I mean, if you have been interested in software for a while you have probably encountered these names before.

But – let’s talk about the conference. This year we got virtual tickets again. So we could simply watch the conference from our office (Dephion) in Geleen. I wonder if there are going to be normal tickets again some time in the future as I would love to attend the event myself, in person.

There were 3 tracks each with 7 speakers. This means I could impossibly watch all of them at the same time but, as I mentioned before we do get early access to the recording so I can watch them any time I want.

In this blog I will discuss the talks that I watched live on December 8th. I might supplement this blog with the talks that I missed in the future, or simply write new blogs related to this one. Also, I’m writing this blog a bit late, so it’s not all fresh in my mind, but still! Let’s start with the first talk.

 

Code, Kevlin Henney

I have found Kevlin Henney an interesting individual ever since I saw one of his talks at GoTo. I don’t even remember what this specific talk was about but a quick search on YouTube results in many, many video’s of him talking. He’s a pretty good and interesting speaker who’s able to boil down difficult or complex subjects to really simple examples and analogies. This makes him really easy to listen to.

So his talk this year at DevTernity was called “Code”, and although I cannot find a video of this talk on YouTube I’m pretty sure I saw this presentation before. This talk is a bit philosophical in the sense that he talks about what code is. For example; he took the definition of code from a dictionary that read something like this:

a system of symbols (such as letters or numbers) used to represent assigned and often secret meanings.

And this is totally true, rigth!? However this relates more to the early applications of code than computer code. But in some sense it’s still correct. If you show LISP to programmer who has ever only used imperative languages, the LISP code will look like a set of symbols used to represent assigned and often secret meanings 😀

This was a great talk and I cannot wait to watch it again because there are lots of deep meanings hidden in here. I really need to listen to this talk (on repeat) in the background to fully grasp everything he’s saying. (If you think you already did, you are probably wrong.)

 

Clean code: Eternal Principles, Jakub Pilimon

I did not know this speaker before but I have to say I’m pretty impressed by the sheer amount of ground this guy covered in just shy of 1 hour or time. He talks really quickly yet understandably and shows a shit ton of code in the process.

This talk was about Clean Code and how to actually use it in practice. In this talk he shows how to write a sharing service for e-scooters (mopeds). Before he starts he says he’s going to implement it naively by just implementing the different requirements that are given. He also shows off some intense skills with IntelliJ’s macro system to inject pre-written code (haha). At first I was thinking; WTF is going on! But it were just a lot of macro’s to inject the code he wrote before. Which makes total sense because how wouldn’t be able to finish within like 50 minutes.

But in this talk Jakub writes some code to implement this sharing service for e-scooters. He first implements a requirement to determine if a scooter is available or taken / rented. Next he adds another requirement to implement a feature to mark a scooter in maintenance mode. And the last requirement needs to make sure an e-scooter is bound to a specific region / geo-location.

These requirements were all implemented “naively” as he calls it. You can maybe imagine all the different if-statements in the code to implement the different states of the e-scooters.

He then rethinks the problem and raises the abstraction level to refactor this intricate if-else hell into a different model. He states the problem in a different way and implements the e-scooter availability into a new AvailabilityService that simply marks an e-scooter available, or unavailable. This allows Jakub to remove all these nested and duplicate if-else clauses from the code since the problem is just more abstract now.

And to me, this makes total sense but doesn’t seem really groundbreaking. I mean it’s a really nice presentation about how not to implement such requirements and think about a problem twice to raise the abstraction level. But, I think most developers would have ended up with a similar abstraction in the end. He clearly shows of the evolution of such a system in a nice way, but also in a realistic way. I think many devs will implement this e-scrooter service exactly in the way he demonstrated and then naturally evolve into this new AvailabilityService organically. I think devs will recognize that the problem becomes too complex to manage and will make a move towards generalization.

In the end, I think this talk was a really good one 🙂

 

Minimum Viable Professional, Sandro Mancuso

This talk wasn’t all this interesting because, well… Sandro didn’t show up (on time) (hope he’s alright)! It’s a bummer though because I would really have liked to see his talk. Sandro is a well known name in the software craftsmanship community. He’s on stage with multiple talks about software principles, practices or agile. And of course he wrote the “The Software Craftsman” book. Which is a phenomenal read btw!

We waited for about 10 minutes I think and then the organizers closed the (virtual) track and we moved on to another talk on track 1.

 

Reasons and Ways to Improve Code Quality, Venkat Subramaniam.

This is another guy that will always show up an any software conference! And that’s a good thing because he’s a treasure trove of information. I’ve watched many of his talks and he still speaks with a word count of 300 a minute or so, awesome!

One funny attribute of his talks is that he doesn’t really use slides, and the talk he did today at DevTernity was nothing different. He often has some things written down in bullet points and then talks about these and maybe add some more. And he uses VIM (with a fancy background), of all tools, to do it. I mean, if that doesn’t predict: EPIC, what does!?

In this talk he explains some of the practices related to clean code, maintenance and testing. The key principle he starts with is the following:

“Lowering quality lengthens development time” – First Law of Programming.

Venkat talks about Cohesion & coupling, intention revealing code, avoiding clever code, (what and why) to comment(s), meaningful names and tactical code reviews. Another interesting topic in his talk is what he calls ‘avoiding primitive obsession’. He says you should prefer higher level abstractions over low level abstractions. Which sounds like a no-brainier to be honest but he also means the logic used to do things. The example he gives in the talk is to do some calculations. You could write it using classic for loops checking for certain conditions inside them and then returning some result. The other way of doing it is to use higher level abstractions to do the calculations since you can then rely more on built-in functions; like the Java Stream API (Linq in .Net).

I swear I have seen this talk before at GoTo 2021. It’s very similar to this one:

Only all the slides are replaced with interactive VIM typing sessions 😛 (You can see the fancy VIM mods somewhat in the middle of the video btw)

 

The 7 pillar Developer: A Holistic Approach to Building an Exceptional Career, Cory House

From this point in the conference I really did not know which talk I should attend. All three tracks sounded just as interesting. On track 1, there was this one from Cory House which I will dive deeper into soon. But on track two there was a talk by Jimmy Bogard, which is also a recognizable name within the craftsmanship community. He’s the dude that coined the term “vertical slice” development; meaning you take a feature and implement it front-to-end and separate the dependencies that way instead of horizontally (in layers). The talk on track three was also a nice one by David Neal. He talked about how you as a developer can become a good leader or manager. In the specific talk he gave he explains how he got promoted to manager, hated it and really wanted to go back to development again, so he needed to leave his job. But he turned it around and became the leader he was always supposed to be :p.

So… I’ve seen multiple talks by Jimmy and the specific talk David was doing, is one I already checked out in the past. Thus, I gravitated towards Cory’s talk in this round since I didn’t know him before this conference.

Cory’s talk was about career development as a developer; and most importantly how to be not just successful, but also fulfilled. He started his talk by explaining how he started doing a bit of consulting (in the JS & React ecosystem) as a side hassle. It quickly grew into something unmanageable as a mere side hassle as he also started doing conferences and training video’s etc. So he had the success, yet it was far too much to handle. In the end he quit his day job and became a full-time (self-employed) consultant.

The rest of his talk as about how everyone can do the same. He talks about what he calls the 7 pillars of success. It’s about maximizing ones potential, specialization, leadership and mindset. It’s a cool talk and I encourage you to check it out. An earlier copy of this talk is already online:

 

Clean Architecture – A Craftsman’s Guide to Software Structure, Robert “Uncle Bob” Martin

And again, the speakers at all three tracks are true legends. On track one we have Uncle Bob, who needs no introduction (especially on this blog). On track two we have Scott Wlaschin which is the author of the amazing book called “Domain Modeling Made Functional”. I’ve read that book in 2022 and it’s just such an amazing read. That reminds me I still need to write a review for it 😛 noted… And on track three we have Mary Poppendieck which is a well known name in the software process world.

Although I have already seen the Uncle Bob talk many, many times I still, attended the Clean Architecture talk. It’s the classic talk where Uncle Bob explains the problem of modern (web) apps. Generally, these apps have an architecture that focuses mostly on the frameworks and the fact that’s a web-app. But this is a fundamental mistake, because frameworks are mere tools and the web is simply a delivery mechanism. We should decouple our code as much as we can from any external influences and create a pure business core aka domain. This way we can not just reason about the code more easily but also maintainability, testability, simplicity and adaptability increases.

It’s a true classic and I strongly encourage you to watch it. Copies of this particular talk can be found all over the web. Here’s one:

but this one is way more fun: 

 

Unlocking the Awesome Power of Refactoring, by J.B. Rainsberger

I did not know this guy before DevTernity 2022. But apparently he’s a true keybind legend. His talk was all about learning refactoring tooling in your favorite IDE’s to drastically speed up your development. He talks about how you should start out small and really get that muscle memory trained. He also rightly mentions that, in order to get good at refactoring, you need to practice it a lot. Which means you need to write a loooot of code to actually do it.

And I agree; I use JetBrains’ products for a reason. Their refactoring capabilities are just amazing and I wouldn’t want to live without them. So much so, that I don’t even try to use different IDE’s which is also a bummer I guess. I really want to try the legendary emacs setup(s) for Clojure development one of these days. But loosing my navigation and keybinds is just a bummer :p Maybe I should give it a try soon.

This was a really interesting talk. If you’re not already using your IDE’s refactoring tooling on plugins you should really watch this talk. People often say that the 10x developer does not exist, well I think they’re wrong and picking up some good old refactoring habits will get you there! An earlier version of this talk can be found here: 

 

Extreme Programming – 25 years later, by Kent Beck

Again… 3 tracks… three legends… ouch… that sounds like some dirty video tbh. XD But on track 1 we get the legendary Kent Beck who’s the inventor of Test Driven Development, eXtreme Programming and an original signer of the Agile Manifesto. True legend! On track two we get Scott Hanselman, who’s a Partner Program Manager at the .Net team at MicroSoft. Without him, the current OS state and intense popularity of .Net might not have been there! And on track three, the last speaker of the day is Allen Holub. He’s a well known author who wrote about C, C++ Java and OO development practices and strategies.

This iteration I attended the talk by Kent Beck just because eXtreme Programming simply resonates very well with my personal taste of a development methodology. It’s the true core of agile and all the other things are mere spin-offs, like SCRUM, SAFE and others. I wont go into detail here but you can use the search bar in this blog and search for “scrum” to find all my rants about agile practices that don’t focus on the technical aspects.

In this talk he takes us with him on a tour about how eXtreme programming got started, what all happened and where it’s going. I encourage you to check this talk out as soon as it’s released online since I cannot find a similar talk to this one. I guess he wanted to create a unique talk for DevTernity 2022, which is a big plus!

I’ll put a link in here as soon as I can get one!

 

Conclusion

In the end, this was an amazing conference. Again! I saw some new speakers I didn’t know about and I got to see some of the legends once again. That’s a win-win I guess. Next time, I’ll definitely get a ticket again since DevTernity just never seems to disappoint. Till next year!

 

#end

01010010 01110101 01100010 01100101 01101110