As the holiday season quickly approaches, I was reflecting on some of the great videos I’ve seen this year. I’ve compiled a list of software engineering must see videos of 2020.
I think we can all agree that 2020 has been an eventful year and I don’t think I’m alone in anxiously waiting for it’s end with high hopes that 2021 is a better. I’ve watched a lot of YouTube this year, and below is a list that I’ve come across as must sees for any software engineer.
To start things off these sets of videos give you some context on the origins of software engineering as well as some glimpses into how software engineering may look like in the future.
YouTube – The Future of Programming – Bob Martin
A fantastic video on some of the history of computer programming and where it’s headed in the future. Memorable points for me were:
- In some respects, programming can be seen as an evolution of what would have been referred to as a scribe in ancient times.
- A modern car has on average around 100 million lines of code running on it.
- Software rules the world, everything is driven by software.
- Uncle Bob estimates that at the time (2017) there were about 100 million programmers in the world and the number of programmers in the world doubles about every 5 years.
- Half the programmers in the world at any one time have less than 5 years experience – this is a direct side effect of my previous point
YouTube – Guido van Rossum: Python
A very insightful podcast interview with Guido van Rossum, if you don’t know who Guido is he created the Python programming language.
This video is a little more abstract, Lex Friedman tries to dive deep into how the mind of Guido works and potentially what were his influences when creating Python.
- Various different views on programming in general. Although its very technical it can be thought of as artistic through the concept of creating something that didn’t exist before
- Some of the influences that Guido had when creating Python
- How some of the politic in open source software influence the direction of a project.
YouTube – The Scribe’s Oath – Bob Martin
I’m quite fond of Bob’s talks, I think this talk is a good follow up to The Future of Programming. He further discusses how deeply integrated software in all parts of our lives. Furthermore he discusses the discipline and professionalism programmers will need going into the future to ensure this field doesn’t become government regulated.
- Programmers have and will probably continue to be prosecuted for code they’ve written, example of the Volkswagen developers that cheated the EPA tests.
- Testing is important, test driven development is the one way developers can ensure quality and facilitate future refactoring.
- Estimation of effort is hard, put bounds around the level of uncertainty when making estimates.
YouTube – Get a Whiff of This – Sandi Metz
This video is a few years old as well, it was recorded at a RailsConf in 2016. To summarize this video in two words “code smells”, that’s right it’s about those tell tail signs in code that something is off.
- Learn what the code smells are and how to identify them.
- Code smells are a way of identifying code that “might” have issues, it’s not a rule.
- Refactoring, it’s essentially addressing code smells.
Some of the code smells that spoke to me
- Comments – If you need a comment to explain some code, that’s probably a sign you could have written the code in way that it was easier to understand.
- Duplicated code – I think this is a pretty common one, I’ve done this myself and I’ve seen a lot of examples.
- Middle Man – If you have a class/object that’s sole purpose is to pass messages between two other classes/objects then you’ve got a middle man smell.
- Large class/Long Method – Trying to do too much in a single class probably means you don’t have a clear view of how your components are interacting. It can probably be broken up into smaller more manageable classes.
- Long Parameter List – If your function/method has a large number of parameters to pass it, you should consider turning those parameters into an object.
5. All the little things – Sandi Metz
YouTube – All the little things – Sandi Metz
Another talk from by Sandi Metz from RailsConf, this one is from 2014. The focus here is refactoring, she works through various examples of taking long complicated code and breaking it into smaller chunks which make it easier to reason about.
- Make smaller things – smaller classes, methods, functions, etc. By doing this you keep things manageable
- Open/Close principal says that you should be able to add new behavior without editing existing code.
- Object orientated design is a style guide for how to organise code.
- An objective of refactoring should be to make thing simpler, which often results in having less code
- Refactor through complexity
YouTube – Simplicity is Complicated – Rob Pike
This main topic of this talk is Golang but there are some interesting concepts that can be applied to other languages. In essence what I got out of this talk is “simple is better”.
- Simplicity is the art of hiding complexity.
- Keeping things simple is hard but the challenge is worth it, for many reasons. Clean code, readability, etc.
The following section will cover videos on computer algorithms, and how you could potentially look at software problems as algorithms.
A really good way to cover the STL algorithms, before watching this I had no idea what they were and even though I don’t do any C++ development it really has taught me to look for algorithms that can solve common problems efficiently.
- Get to know some of the common algorithms and the optimal way these can be solved. In regards to memory and computational complexity (big O).
- Are there equivalent libraries for your favorite programming language, if so get to know them.
YouTube – C++ Seasoning
Although this one is very much C++ and STL library specific it still demonstrates how to spot algorithms with in code and to replace those with well established and battle tested algorithms.
- It’s a rotate!
- Writing efficient code doesn’t need to be complicated, it can be simple, easy to reason about and clean.
As a Pythonista I really enjoy watching this talk, it has shown me various new ways to approach coding in Python by leveraging the strengths of the language.
This talk is very much Python focused, (the title should give it away) but it really encapsulates some of the key ideas that are discussed in other talks.
In order to take the next step to becoming a Python expert you need to know about all the features of the language and more importantly when to use those features appropriately.
- Dunder methods are your friends – these might seem daunting at first but once you become familiar with what they do and why you use them they are very powerful.
- Leverage the strengths of Python, don’t just write code as you would in C/C++
- Almost all things in Python have some runtime hooks that you can tap into.
Well I hope you get some time to enjoy my picks of software engineering must see videos of 2020. All of these videos are on a playlist on YouTube as I’ve watch them all several times.