Developers who practise algorithms are better at software development than people who just do development. Is it true?


I am a college student and I recently came across this in an online publication. Is this a fact?

Mark's photo

I do feel recruiters believe that. I've not seen scientific evidence.

The way you're wording it, it seems like a choice between people who just program, and people who program but also study algorithms. In that case, it's easy, the latter will know more.

He'd also be a better programmer if he instead studied design patterns, learned some extra languages or learned about type systems...

There are a lot of things that you can learn that'll make you a better developer, but that you can avoid if you stay at a lot enough level. Advanced algorithms are one of those.

EDIT: there are of course some narrow applications where advanced algorithms are essential. Good algorithms can have a huge impact on performance, where some things are only possible with good algorithms (like FFT). The reason they're not essential to study for everyone is that they're often reusable.

james igoe's photo

My feeling is that algorithms help make one a better programmer, but that is likely true of many coding concepts. I did not have algorithms as an undergraduate, so my knowledge is acquired through reading and practice, but after reading and applying Algorithm's in a Nutshell, I felt the quality of my work improved. That said, my development work increased more after understanding Design Patterns, or after consuming books on database design.

Since many types of knowledge improve developing and architecting abilities, one has to consider how it helps and to what degree. Algorithms are coding-in-the-small, often narrowly focused solutions, but which can have a great impact at scale. For many applications, a focus on algorithms would be overkill as data sets and requirements do not require it. In this context, any middling programmer can optimize a basic loop for performance. Proper database design, either relational or OLAP/OLTP, will make your applications better, from both maintenance and performance perspectives. Object-oriented programming makes some type of designs better, those that add objects, while learning correct functional programming helps in contexts where you are increasing functions on a limited number of objects. Learning enterprise architecture helps in the design of large scale operations.

One could equally argue that learning and practicing self-management, communication skills, and code management all make for better programmers, and they do. Ultimately, learning makes one a better developer.