What computer science concepts should devs without a CS background prioritize learning?
For further actions, you may consider blocking this person and/or reporting abuse
For further actions, you may consider blocking this person and/or reporting abuse
Harutyun Mardirossian -
Jess Lee -
Scofield Idehen -
Valeria -
Top comments (64)
My favorite non-CS computer science algorithms book is: Grokking Algorithms: An illustrated guide for programmers and other curious people.
It stays at a pretty high level, touches the major algorithms, and explains big O very well!
Grokking Algorithms
Most self taught colleagues I've worked with, and others as well, are missing skills in writing good clean code. If you write good code everything else will be much easier to fix later e.g. performance issues, bugs.
So I'd suggest reading "Clean Code" by Robert Bob Martin, he's not only fun to read and watch holding talks, but is good at explaining things so that they make sense.
Depending on what kind of dev you are focused on, I really appreciated some courses on computer architecture - circuit design, machine language. Helped give a better conception of how computers actually work, and iron out misconceptions. Also OS design. Maybe not a first priority tough.
Computer architecture is great because it's fundamental but also not too abstract
Some developers come from a Computer Science background. Others, like me, never studied Computer Science in an academic environment.
In my opinion, the three main things for developers without a Computer Science background to study are Data Structures, Algorithms, and Lambda Calculus. Why these three?
Data Structures. These are the building blocks of data inside of a program. There are many different types of data structures, both simple and complex, and all of them have advantages and disadvantages (in terms of reading, writing, and space complexities). When a dev has to model a problem domain, he or she will first reach for the a data structure. It's good to know the pros and cons of different types of data structures and what they can offer in order to make the best choice for the problem domain. Understanding data structures will help a developer to solve problems quickly and efficiently using the right tools; in some cases, it will also give a better understanding of how data is mapped to computer memory.
Algorithms. Computers are fast - very fast - but solving problems still takes time. Devs should understand algorithmic complexity, know the advantages and disadvantages of specific approaches, and cultivate the foresight to make algorithmic choices based on input and time. More importantly, devs should be able to identify problems which can be solved (trivially or non-trivially) versus problems that cannot be solved at all within a reasonable time period. Algorithms, in conjunction with Data Structures, are the meat and potatoes of our programs.
Lambda Calculus. Modern languages have many design patterns - OOP, functional, declarative, and so on - but Lambda Calculus is a basic, simple model of computing that lends itself very well to any developer who wants to improve the way that they read, write, and understand code. Gaining an understanding of Lambda Calculus can allow a developer to think in terms of inputs and outputs, which lead to further inputs and further outputs. Understanding the compositional, functional style of Lambda Calc can make many problems much more accessible. With Data Structures and Algorithms, Lambda Calculus can elevate a developer to the next level.
Non-CS-major here. Got any suggested readings on algorithms or lambda calc?
This one is very good coursera.org/learn/algorithms-part1 although a bit hard.
I really liked the introduction to Lambda Calculus in Haskell: Programming from First Principles: haskellbook.com/
Besides data structures and algorithms, there is some math stuff that is surprising helpful. Calculus is fundamental to model a lot of real problems and to think in terms of velocity and aggregation. Linear algebra is pure computing: once you get to think in terms of matrices, a lot of very, very complex stuff becomes way simpler. Number Theory is fundamental for a lot of disciplines. But the most important math subject IMHO is Probability and Statistics: it permeates everything.
Besides that, the basic of networking and cryptography are very useful as well.
+1. The one thing I do regret most not paying attention to in my CS degree (which might be a good way to think about the question above) was probability and statistics. With ML this is becoming ever more important. Personally, I still don't feel 100% confident about my maths.
Regarding data structures and algorithms: I find most lists out there not really useful as they tend to cover data structures either not really in use anymore (e.g. linked lists) or so frequently used that a CS degree doesn't add detail (e.g. hash tables). The biggest advantage of a university course is that it should teach you concepts and ideas you might one day find useful (e.g. bloom filters) - instead of tools that make you productive right now. As such, I believe graph algorithms, binary search, finite state machines, lambda calculus and yes, complexity analysis, are the most useful ones (all mentioned below) - alongside various Patters which are also mentioned below.
Big O notation, an understanding of what algorithms are "expensive," and an understanding of what happens with "expensive" algorithms at large scales.
I second Big O notation and this whole idea. I didn't do an entire computer science degree, but I did some, and these concepts are what have stuck with me as considerations that come up a lot.
Time to write my Big O practical applications essay. Still need to fully understand it though. I read a great book about CS concepts written by someone who didn't have a CS degree. Not an ad but a good book.
bigmachine.io/products/the-imposte...
Ah, someone beat me to it I see :)
I couldn't agree more about this recommendation.
For some reason at my CS degree we hardly touched on Big O. Does anyone have some great resources for gaining a better understanding?
I know it is expensive and massive but I really think every developer should have a copy of CLRS. It is well organized, well written, and extremely thorough. In fact I was just paging through it today to review a few graph algorithms.
How to structure systems to support concurrency.
We are entering a major shift in industry where concurrency is going to become mandatory. Programming with shared data and interwoven state is going to cause massive loss of time and energy in the future.
The sooner we begin the shift toward a more stateless asynchronous programming methodology the better we will all be.
If you are a web developer: Databases. I took an intro to databases course in college and even at that pretty beginner level, I still use what I learned in that class every day. Technology stacks may change, but data isn't going anywhere.
Yes I strongly agree. I had worked with new self-taught web developers and database skills was the most glaring thing they needed to learn. Knowing how to design a database to write SQL queries that has good enough read and write performance, knowing ACID concepts, knowing when transactions are needed, knowing the differences between SQL and no-SQL databases and to pick the best one to use rather than the easiest to use. Database is one of the most important things a web developer should know.
Easily the most fundamental skill to have besides algorithms and data structures.
There are a lot of things to learn, But the most important IMHO should be Data Structures and algorithms.
With some basic knowledge about both, Writing code becomes less about "Let's get this to run / work." and more about "how efficient is this? / could i do this is a more efficient way?"
Naturally the search for efficient ways to do stuff will lead to some other important concepts like concurrency, caching etc
I'll toss a do-not in here: Sorting.
Sorting can be fun, and can produce some interesting visualizations, but the best for most situations is already built into your language, probably, and it likely goes by the name
sort().