7 Tech Talks That Actually Made A Difference
Tags: devjournal, resources, development, strategy
Published: 2021-03-17 20:53:25

When I just started learning to code I was **very obsessed** and spent _far too much time_ watching software development videos.

I was determined to become the Best Python Developer In The World (don't do this) and I would spend the wee hours of the morning watching programming video after programming video searching for more grains of insight (don't do this either). 

I wanted to learn the **Best Way** to write code; the most powerful, idiomatic, robust, resilient, _elegant_ solutions.

_That was, in retrospect, not a bad ideal. But the way I went about it may have been a bit silly._

Real working software design is about tradeoffs, and providing solutions, even when those solutions are not as elegant as we would like. And no amount of videos can replace trying your hand at solving a problem. Fortunately I learned this before it was too late.

But I wouldn't call my time spent watching my contemporaries fruitless. Good developers _learn from other developers_. Whether through videos, articles, courses, pair programming, or just perusing github repos, it's always good to weave direct learning between time in the text editor.

My career is not very long nor is it very storied, but I have come across a few tech talks in my time that make a special impact on me; talks that **changed** the way I wrote and thought about code, and my relationship with my profession. These talked accelerated my competency, not with niche tricks for compiler optimizations, but with sensible and down to earth explanations of goals and paradigms that resonated with me. These are not **all** the talks I love; they're just the ones I've been thinking of the most recently. In each case, I cherish the person who gave them, for taking the time to try and teach me something beyond just syntax and IDEs.

I've also tried as best as I can to choose talks that I believe to be _widely applicable_, _approachable_, and _actionable_.

_So the best thing I can think to do to pay back these people who have shared so much with me, is to share them with you._

With each talk I've added a little blurb to provide context, because if I'm going to ask you to consider another piece of content in a time _bursting_ with content, the least I can do is tell you why it was special to _me_, and maybe those feelings might resonate with you as well.

So without further ado, here are

## 7 Technical Talks I Love (and Why!)


### 1. [The Clean Architecture](https://www.youtube.com/watch?v=DJtef410XaM&list=PLIYs5xFeCcq5mKWNeQfz3-9Bc6iFM_gtj&index=9)
- Presenter: Brandon Rhoades
- Length: 50 minutes
- Key Themes: Code architecture, Software design, Enterprise design

In fifty minutes, Brandon Rhoades did for me what dozens of other examples and articles failed to achieve.

He provides a sensible approach (with examples) for structuring Full Applications, with methods and reasonings that work across the board, but _especially_ for folks attempting to write modern, mature code in languages like python, ruby, and javascript.

Brandon is also one of the best orators I've heard period, and it's an amazing feeling to receive a software architecture lecture but feel like you're being told a story.

Highly recommend for newer developers struggling to understand how to put together larger pieces of code in greater context that one or two files or modules.

### 2. [Thirteen ways of looking at a Turtle](https://www.youtube.com/watch?v=AG3KuqDbmhM)
- Presenter: Scott Wlaschin
- Length: 1 hour and 5 minutes
- Key Themes: Software Design, API design, OOP design, Functional design

I've made in no secret that I love [Functional Programming](https://en.wikipedia.org/wiki/Functional_programming) and [F#](https://fsharp.org/) in particular.

It feels almost impossible to talk about learning F# without talking about Scott Wlaschin, who's website, fsharpforfunandprofit.com has help inumerable developers, from new F# users, to other functional programmers, to anyone interested in learning how to _solve problems with software._

In this talk, Scott takes you through 13 software designs all aimed at solving a single problem, highlighting apporoaches object oriented, functional, procedural, modular, and enterprise, and it's quiet the journey to travel, but I can assure that he's an excellent guide.

### 3. [GOTO 2016 • Pure Functional Programming in Excel](https://www.youtube.com/watch?v=0yKf8TrLUOw)
- Presenter: Felienne Hermans
- Length: 43 minutes
- Key Themes: Spreadsheets are code, Prototyping, Inspiration

Oh no, another functional programming talk!

But wait, Excel? Is that even programming?

Yes it is. That's kind of the point. In about 40 minutes Felinne Hermans delivers a delightful deep dive in doing deep work in Excel. Her passion is infectious, and engaging, and if nothing else, it's wonderful to see someone who seems to genuinely _care_ and _love_ the work they are doing.

But there's much more to this talk, and this may be giving it all away, but this talk is a great reminder for me that _programming_ is all about using software to deliver solutions. Too often developers get caught up in their own hype and Felinne reminds us that there is expertise to be had in all places, and it's worth learning those tools that power the world around us.

### 4. [The Naming of Ducks: Where Dynamic Types Meet Smart Conventions](https://www.youtube.com/watch?v=YklKUuDpX5c&list=PLIYs5xFeCcq5mKWNeQfz3-9Bc6iFM_gtj&index=4)
- Presenter: Brandon Rhoades
- Length: 30 minutes
- Key Themes: Naming conventions, semantic design, code as documentation, Variable naming

Brandon's back! It may seem odd to have the same person twice on a list of seven but what you have to understand is I love _all_ of Brandon's talks and half of the time working on this was trying to narrow them down.

If I could call "The Clean Architecture" a talk about high level software strategy, "The Naming of Ducks" is a talk about _tactics_; battle testing strategies to maintain a sense of control in a growing codebase, _especially_ in languages where you can't rely on explicit types, like python and javascript.

This talk is another I highly recommend for newer developers who plan on writing code that is **read by other people** (including yourselves in the future).

### 5. [Making Impossible States Impossible](https://www.youtube.com/watch?v=IcgmSRJHu_8&t=1s)
- Presenter: Richard Feldman
- Length: 25 minutes
- Key Themes: Refactoring, Reducing Errors, Functional Design, Static Typing

If I had to suggest **just one** video from this list for anyone to watch, it would be this one.

Making Impossible States Impossible is a talk that aligns with my very core values of good software design.

The presenter, Richard Feldman, is one of the chief evangelists of the [Elm programming language](elm-lang.org/) which remains my favourite way to write front-end code. In the talk, Richard suggests how to make code more resilient by using the power of our software _domains_; the types and values we construct our applications around, to create code robustness that goes beyond even the need for powerful tests. Because Richard argues that with the right design, you won't even need the tests at all. A very tactical talk.

### 6. [Building Resilient Frontend Architecture](https://www.youtube.com/watch?v=TqfbAXCCVwE)
- Presenter: Monica Lent
- Length: 35 minutes
- Key Themes: FrontEnd Architecture, Resiliency, Legacy Code

Keeping up with the theme of power in the front-end, we head back into the realm of strategy, context, and understanding. 

Monica Lent delivers a powerful and engaging narrative about how we design front end applications, and why we write the code that we write. In just 30 minutes she manages to weave the concepts of technical debt, architectural patterns, API design, and effective communication and it just comes together leaving you feeling almost _refreshed_ at the thought of using the context she provides to deliver higher-quality, less stressful applications.

Great for all but especially front-end folks out there.

### 7. [The Art of Code](https://www.youtube.com/watch?v=6avJHaC3C2U&t=26s)
- Presenter: Dylan Beattie
- Length: 1 hour
- Key Themes: Whimsy and Delight, Inspiration, Language Design, Code Philosophy, Pop culture

And last but not least, we have the art of code.

I honestly am not going to say too much about this one because I don't want to spoil the surprise, but I will say that for many of you, this talk will remind you _why you got into code._ For others it might be great insight into _why do other people get into code._ But for everyone it should be an amazing, illuminating, magical ride.

Don't try and multitask this one. Take the hour, have some fun.

## In Conclusion

I hope these provide some value to you. I hope they give you ideas. I hope they give you inspiration. If they do, let me know, I'm dying to talk about these with someone. If you hate them, let me know too. There's probably more I need to learn.

Until then,
Kirk