Cookies   I display ads to cover the expenses. See the privacy policy for more information. You can keep or reject the ads.

Video thumbnail
I'll start by saying you're not exactly my target audience for this talk.
But I'm counting on you to spread the word.
It's based on my experience working with junior developers on my team
and working with interns and students over the years.
I'm hoping to get the message across, and maybe this recording will go viral.
I'll start with things that junior or beginner C++ developers don't get.
They don't get that math is important. I'll give you an example here.
You should start by reading this book.
It's still available at the book store outside, on the hallway.
This book is about the story, and it follows the invention of the algorithm,
from about 2000 BC to the current day.
I think it's a very inspirational book, and every young C++ developer should read it.
Another thing junior developers don't get is generic programming.
They think it's all about templates.
It's not just about templates, it's about algorithms
and how they're associated with a set of common properties,
and finding the most general representation of algorithms and abstractions.
The fact that there is a generic algorithm behind every 'while' or 'for' loop,
and the fact that finding the generic setting of an algorithm
is the natural extension of 4000 years of mathematics.
I encourage you to watch an older talk by Alexander Stepanov on STL and its design principles.
Another thing junior developers don't get is that books are still a thing.
They're not obsolete, not even older books like these two I have here for example.
Because these books teach the core concepts and the fundamentals of programming,
and those don't change over the years.
Frameworks do. Languages do.
Junior programmers don't get the difference between efficiency and performance,
and why we care about this.
Because "software is getting slower much more rapidly than hardware becomes faster."
Another quote from Niklaus Wirth from the previous book.
Efficiency is about the amount of work you need to do, and it's governed by your algorithms.
Performance is how fast you can do that work, and it's governed by your chosen data structures.
Another thing that junior developers don't get is that smart pointers are not the answer for everything.
I would like to see much less shared_ptr.
Another thing junior developers don't get is single responsibility principles.
I think everyone of us has seen a class that looks like this with too much stuff in it.
Another thing junior developers don't get is exception safety.
They think its all about throwing and catching exceptions.
I say no, it's about basic exception guarantees,
about strong exception guarantees, about RAII and noexcept.
Another thing junior developers don't get is that documentation matters.
You have to write documentation with the same vigor that you write your code,
and express your intent and design clearly, in plain, good English.
This includes your comments.
I think everybody should watch Walter Brown's talk that happened today over lunch.
Catch that recording; it was very entertaining.
Finally, another thing junior developers don't get is computer architecture
and the fact that we actually program silicon.
We have to be aware of memory, CPU architecture, and caches.
Attending conferences is not just about the sessions.
It's about meeting people and having ad hoc discussions,
and getting energized, and going back home and telling the story. Thank you.