The great debate of course is, how important are those skills? Many self-taught programmers I know reject the idea that these CS fundamental knowledge is important. And to their point, many self-taught programmers that I've met/hired/worked with that would be productive on day one because they have real-world knowledge and experience. Case in point, the founding engineer of the company that I work at is a college dropout, he's more than 15 years younger than me, and he's excellent. As well, I'm a self-taught programmer but came from a EE background, so I had two CS courses under my belt before I decided to pursue programming after graduating.
Besides some CS math courses I took while doing an unrelated engineering degree, I'm self-taught. And I've always felt incredibly limited as a consequence. E.g. given the popularity of Rust, I'm really interested in type systems to limit aliasing. But the papers make my eyes glaze over. Self-teaching is difficult, because even the stuff written with an eye towards approachability assumes mastery I don't have of a couple of years worth of discrete math.
Personally I'm thankful for my CS background, but you also need experience using various tools to round out your knowledge. To put it another way: real-world experience teaches you how to solve problems, while academic experience teaches you that hard problems can be solved.
I'd agree 100% with the algorithm point but I'll add data structures to the list. Beyond low level memory - think shift registers - I had no concept of linked lists, pointers, stack vs heap, etc.
My solution was simple. I contacted the CS department from my undergrad (Rose-Hulman - small school, I knew the department head) and asked for the syllabus for the data structures course. The prof was great and went so far as to send me all the homeworks, last year's tests, and recommendations for books. It was above and beyond and reinforced my appreciation.
I'm an engineer at Twitter. Due to the interview process, I have yet to encounter anyone (myself included) who doesn't have a pretty sound understanding of algorithms and data structures. The biggest difference I've noticed between self taught folks and CS majors is comfort level with bit-twiddling. All the high-level stuff I know I've had to learn to do my job. All the algorithm and data structures stuff I've had to learn to pass interviews. Moving bits and bytes around is hard for me because it's so rare for me to encounter it in my day-to-day work.
As for how I learned all this stuff? Read Steve Yegge's Google interview post[1], buy the Algorithms book[2], learn everything Steve suggests you learn.
1: http://steve-yegge.blogspot.ca/2008/03/get-that-job-at-googl... 2: http://www.amazon.com/Introduction-Algorithms-3rd-Thomas-Cor...
Not too long ago I had to bang on some code that was running too slowly to be practical. Thanks to knowing stuff about algorithms and complexity I was able to knock it down from cubic time to just-over-linear time and reduced it from taking about 9.5 seconds of a 10 second response time to 'basically none' of a 0.5 second response time.
It depends on how hard a problem you're trying to solve. If you're writing the MVP of some CRUD app that supports a handful of users, you don't care about efficient algorithms. But if you ever hope to scale up to support massive numbers of users without using up massive amounts of extraneous servers (think of Google's or Facebook's data centers, and what their power and cooling costs), then knowing how to create efficient algorithms is of tremendous practical importance - it could mean the difference between profit and loss.
Another example on a small scale: If you want to write a game that drives a virtual reality display in real time with realistically rendered imagery, knowing how to write efficient algorithms is also going to be very important.
When the time comes that a self-taught engineer is scaling to these massive numbers, there should be money in the budget to hire people with expertise in efficient algorithms.
1. Wouldn't you rather be the developer who built the scalable software that drives your company toward its IPO rather than the developer whose skills suddenly became useless just as the company was getting really profitable? Why should they even keep the first developer around after they hire someone else to clean up their mess?
2. Does your company really want to have to re-write all its critical code just as that code is starting to make money for them? It's OK for an MVP to be lacking features; features can always be added later. But if its fundamental architecture isn't efficient and scalable, you're going to run into a brick wall at the most inconvenient time.
1. While CS students have a broader array of programming knowledge, they have narrower perspective about it. By this I mean they have difficulty distinguishing their own programming experience and knowledge from that of the world as a whole. They assume everyone learned Java in CSE101 so they can't fathom how some one could program Ruby without being able to explain it using Java-esque CSE101 terminology.
2. CS students participate in open source more. Self-taughters usually do so in order to complete a direct objective (i.e. make a site, sell some widgets), they weren't exposed to the culture or peer recognition around programming that comes from years of academia. CS students are often encouraged or required to participate in open source projects. This sometimes leads to the false insular belief among the educated that all "good" programs work on open source projects. This pops up on HN every now and then.
3. CS students like libraries more. My guesses for why this is might be: (1) the academic exercise of writing your own libraries; (2) libraries are a generally more academic approach to programming where you write code "by the book" and work on many what-if possibilities; (3) it's 11:00pm and you need to submit your code in an hour - you don't care about maintainability - so shove a library in there to eek it out as fast as you can. Self-taughters don't have such academic exercises or deadlines in their learning; and they'll usually be maintaining their code for a long time, which discourages libraries in my experience.
These are my observations from the coders I've worked with. Of course, there are exceptions, I know there are many self-taughters who use libraries and work on open source, but just not as many CS students.
I'd disagree on this one. From my admittedly anecdotal experience, all the people I know who are heavily self-taught (myself included) have participated more in open source. Most of these people are driven by a passion for software, rather than a need to sell something.
Also, I find that most CS students miss the "forest for the trees", and focus on the technical - rather than the immediate reality (Big-O < shipping features) at a small company.
Overall, none of those qualities are bad, but both can contribute to the success or failure, of a company.
Morale: caveat emptor. Culture & Diversity is important.
If you pull in a dependency on Xlib because you wanted a matrix math function from a graphics library, then it does.
If you're building on a platform that emphasizes many small libraries, and you pull in a few well-reputed ones, only to find that your dependency graph now includes 15 small buggy libraries hosted on github and abandoned by their developers, then it does.
If you introduce a dependency on a Windows-only library in your game's physics engine, and then want to port the game to Linux, then it does.
It's possible to be sloppy with using libraries, but I don't think academically-grounded programmers are any prone to being sloppy.
Enterprise it management includes trying to coalesce around a well known corporate standards for that reason. It's much easier to maintain upgrade a portfolio of projects if they are all using the same libraries than if each project is using a different 3rd party library. Sometimes these standards mean sucking it up and using core language feature or existing library features to bridge the gap to where you want to be.
Deleted comment
Caveat over, onto the generalization: From having done a few dozen interviews now, the self-taught applicants are more likely to have holes in their knowledge that they don't know about. That is, CS grads have (hopefully) gone through a broad and formal program so they have a more complete mental map of the knowledge space and their own weaknesses. The self-taughts don't know what it is they don't know.
This gap can be overcome, but the pattern I've often seen is the knowledge gap and disadvantage is compounded by the first jobs the self-taught tend to end up in. Rejected from graduate programs in larger firms where they'll be exposed to a wider range of talent, they often end up in smaller shops where they work in a niche where they're not challenged to keep growing (just as often due to the nature of the business. Smaller shops tend to be contract businesses, and contract work doesn't provide much opportunity to go deep on problems in the way that will stretch and grow you). And because they don't know what they don't know, they don't realise the gap between their skillset and their contemporaries who went the formal CS track.
Frequently I've interviewed developers who've done this for 5-10 years and decided they wanted to try working in a larger company. And they're hard interviews. I hate it when an earnest applicant is an obvious 'no' in the first few minutes, and it's because they've specialised into a low-level dead-end, and they didn't realise it.
Having said that, I think we're at a point where it's easier for a self-teaching programmer to overcome this. Even compared to when I went through uni in the mid-2000s, it's ridiculously easy to get the material that would cover an undergrad's CS education. There's no need for a self-taught person to be caught short in an interview on not knowing what a linked list is, or the basics of algorithmic complexity. I could probably put together a list of 10-20 Wikipedia articles and Khan videos that, if you were to read and watch until you understood, would cover you for the vast bulk of CS-related questions you're likely to hit in an interview.
While I agree self-taught developers may lack knowledge in certain areas, they compensate by being able to learn quickly and efficiently for the job at hand. School taught, though not always, will lack that discipline and/or efficiency. At least in my experience, so take what I said with a grain of salt.
We ALL need to be able to learn quickly or we simply don't last. If you've been doing this for a decade or more, you're guaranteed to have that skill in abundance, regardless of your origins.
What the OP was getting at is that you get exposed to a host of different ideas and paradigms in a proper CS program. Assembly, lisp/ada/scheme/etc., C/C++/Java, graphics, computer learning, computer architecture, etc.
I learned how to code when I was ten, but I would have never exposed myself to any of those things if I didn't focus on CS in college. What does that add? Exactly what the OP said. I know what I don't know. And it's a lot.
I totally agree with that statement. In my response, I meant that self-taught devs have a leg up, so to speak, in the beginning. In the end, we all need to learn quickly and adapt regardless of how we started.
> Assembly, lisp/ada/scheme/etc., C/C++/Java, graphics, computer learning, computer architecture, etc.
From my own experience as a self-taught developer, I have learned, though maybe never used professionally, almost all of those topics to some degree because I had a keen interest in understanding software and computing in general. I find that self-taught devs, though not a majority, are like that - they want to know and understand because its passion of theirs. Also, i'm not saying that university trained students lack that passion either. I believe at the end of the day it really doesnt matter whether you are self-taught or not, only the passion you bring into learning and understanding is what matters.
Given your other comment I suspect you're speaking from an observation bias leading you to judgement about the general case that doesn't necessarily stack. You witness those who've made it as devs, but that doesn't tell you anything about those who didn't.
The important question is of those who self-learn, how many of them end up as decent developers, vs those who go through a formal CS ed. Or to re-frame, what's the better course for the majority of people who want to become developers? I don't know of any numbers on this, so can only go off what I've seen, and what I've seen is that for the average person considering dev, a CS education is the best option.
If you read my other comment you also read the part where I said I have been around a lot of terrible developers (worked with, for, under, around, consulted for, etc). These people have "made it" as you said, with long careers in software development, but they are far from competent. Which leads us to your next point:
> how many of them end up as decent developers
I don't honestly think where or how you start can be used as any sort of determination for how "decent" you are. What matters to me is passion (i've said this a few times already in other comments). When I am hiring and interviewing developers to bring on to the team I barely look at their resumes and I definitely don't look at their education history. Whats more important to me is the initial call, and then the face-to-face. I don't even bother asking any real technical questions. What i'm looking for is a spark; something that tells me this person loves to build and learn. Self-taught or university taught makes no difference at the end of the day, and should never be used as basis to judge whether a person is a "decent" developer or not.
This site has a nice summary: http://bigocheatsheet.com/
I'd like to see a list like that!
If you decide you want to, please respond to my comment here!
For me those skills aren't incredibly useful in everyday work (I mostly do web development), but I think having that low level understanding does help from time to time, in a hard to measure way. I feel like it sort of gives you a better intuition on certain things, like evaluating new technologies, why you're having performance issues, etc.
Also watching a teacher code, and listening to other people describe their thought process was interesting. I didn't do a lot of pair programming, but if you go to a university where you do that, it would be useful.
I've also learned about things such as linked structures which I probably wouldn't have bothered to look into if I taught myself, and are actually some crucial things that companies look for when they hire.
Another thing I've noticed personally is just a faster progression. I have a friend who taught himself how to make iOS apps, and it took him 3 years to get to the point that I did after taking one online course on iTunes U for it. Having a structured course really makes a huge impact by providing a logical progression and teaching you all the little things that take a long time to learn on your own.
On the other hand, programmers coming from academia are expected to "just know" a lot of the practical tools that are used these days. I did C++, Java, MATLAB, and machine learning-type stuff in school, but learned Git, Rails, Python, Hadoop, etc etc. after graduating. Recruiters, etc. expected I'd just be ready for that stuff right off the bat.
So difference would be in broad for my case - uni gives you the theoretical foundations that you probably wouldn't learn yourself, teaching yourself programming gives you the hands on stuff you'd never learn in depth at a uni. Two sides of the same coin I suppose, it would be rare to have a self taught person learn the theory that you'd learn at uni, and I don't think you'd ever get that depth without some uni training imho.
The other thing that comes to mind is if you're smart and self taught - why wouldn't you do a degree? The only good answer I can think of is that you're so friggin awesome you're churning out code that everyone says is awesome and google or apple has hired you already, there are perhaps 10 people in the world like this - everyone else do your degree :-)
Within the enterprise it world I've worked in, the self taught programmers tend to be very bimodal- likely to be truly excellent or unspeakable terrible whereas programmers with a CS credential tend to be more normally distributed.
I do think that the credentialed programmers I've met are a bit more technically flexible than self taught programmers. A CS degree requires learning different languages, coding styles, and technologies whereas self taught coders are more likely to have come up through one language/technology stack and may never leave it. That's a massive generalization though and I can think of many counter examples.
Note-I'm was a CS undergrad and mostly deal with very large IT departments rather than startups or consumer application development.
I'm a 30yo self-taught programmer. I've worked with many CS grads over the years.
There are pretty big gaps in my knowledge of what would be considered fundamentals, some of which are more important than others. I think the type of software you write largely determines how important these gaps are, and that being aware of the gaps in my knowledge has been more important than actually having the knowledge itself. If I need to implement something that requires some knowledge I haven't yet picked up, I learn what I need to know as I need it. Sorting algorithms are an example of something that any CS grad would know way more than me about because the need to understand all the alternative ways of sorting is not something that I've needed to know.
An important distinction is the difference between knowing something and knowing the language to describe that thing. I understand the time complexity of algorithms, but I didn't learn Big O notation until recently.
I don't know if this observation is true in general, or more common for the CS programs where I live, but I've noticed that CS students and recent grads are terrible programmers. That is, their ability to produce well-written, maintainable code is horrible. This can probably be said of all new programmers, even if they are self-taught, but I think the difference is that many of the CS students I've worked with have the illusion that their CS knowledge is what is most important when they write software, so they are more ignorant of their ignorance.
Learning all the fundamentals of CS in the classroom is no doubt a huge benefit, but many of the other things that make a good programmer come down to experience in a lot of cases, and the classroom is not going to be a substitute.
The answer to this question is very simple. It's not school vs self-taught. It's PASSION and I fucking love programming :)
Some real life examples:
- The algorithm is tight enough that the choice of programming language doesn't matter. Also phrased at least once as "the constants in big-O notations just don't matter".
- No, you can't install a configuration management tool on the web server; the web server must be completely isolated to protect our network.
- If I'm using a programming language with so much power, why would I ever want my configuration files to have any less power?
- If only there was a programming language where the (type system / memory management / homoiconicity) was more powerful, we could solve every problem automatically.
Of course, on the other side of the fence, there's these pearls of wisdom:
- Of course C++ is memory safe, if you follow these few hundred best practices...
- (Ruby / Python / Perl) is fast enough to solve every problem.
- If I can use Javascript on the server and the browser, why would I want to use anything else?
- Why would I ever care what the Big-O complexity is for this algorithm?
It makes for an interesting comparison and contrast. And since I come from the self-taught angle, a couple of the second group of quotes are my own.
Overall, a good CS degree exposes you to things you don't know you don't know (a big pitfall in self study) I really respect the self taught devs, because they have to work harder for it.
Look for people who can learn the structure of a problem when there's no guidebook (or textbook) available. If they can do this, then they will likely succeed in tackling the unknown.
This 'autodidactic tenacity' can be learned inside or outside of school.
Knowing how to independently learn means you will invest in yourself for the rest of your life. Attending classes and doing homework do not, themselves, teach you how to do that.
CS emphasizes theory and mathematics. Programming and coding is usually discussed in the introductory courses, but from there students are expected to teach themselves to keep up.
Case in point :
1) Linus Torvalds : The Creator of Linux kernel. 2) Richard Stallman : GCC, Emacs and GNU. 3) DHH : Ruby on Rails. 4) Matz : Ruby.
there are several other examples Donald Knuth, Dennis Ritchie, Ken Thompson and many others ...
All of these people have advanced CS degrees.
Knuth has a bachelor's, master's, and PhD in mathematics. No CS degree.
I think you might need to reconsider.
Donald Knuth BS,MS mathematics 1960, PhD mathematics 1963
Dennis Ritchie BS physics 1963, PhD applied mathematics 1967
Ken Thompson BS EE 1965, MS EE 1966
and so on for pretty much everyone else in that generation.
Java
Lisp
Data Structures
Algorithms
Operating Systems
Information Systems (How databases work)
Software Engineering
Assembly Language
Artificial Intelligence
Networking
Embedded Systems
Calculus I & II
Multivariate Calculus
Linear Algebra
Discrete Mathematics
Probability and Statistics
Anyone could self teach all of these things to the same level that I learned them. It would probably take a similar time commitment. Honestly, if someone was dedicated enough to spent 60 - 100 hours learning each of those topics on their own time, they are probably a better computer scientist that I.
Although, I wouldn't say my CS degree made me a "programmer".
What did I didn't learn from College:
How to write maintainable code
How to write testable code
How to deploy code
How to manage servers
How to document code
If you're building web pages there probably isn't any difference between a self taught developer and someone with a CS degree. The person with the CS degree most likely also self taught themselves all their web development skills.
However, if you're building new programming languages or compilers or robots or missile guidance systems or self driving cars or spaceship navigation systems you'll probably start to see some differences. From reading the comments on this thread, I'm not convinced that the self identified self-taughters are aware of all that a CS degree encompasses (heck, no two CS degrees are necessarily after the first three semesters!)
A 22 year old with a CS degree is probably not going to be as good of a web developer as a 22 year old with with 4 years experience working as a web developer instead of a CS degree. But, a 22 year old with a CS degree and 2 years of internships working as a web developer...
I don't think this is just a CS thing either. In any profession, you have those who graduate and learn for their first 6 months to a year out of school and then stop self development. They literally repeat the same experience over and over for the rest of their career. In the end, anyone who is very successful, will be 'self-taught', school only provides a foundation to build on. It's what you do after that matters. If you compared two developers, each with 5 years of experience, one with a CS degree and one without, the one with the CS degree will not always be the better developer.
CS Students learn from NON-developers, but CS professors.
Self-taught learn from developers (ie: in the field or from Internet).
Most people who were self taught and then took a CS degree did so as part of their self teaching.
The rest just couldn't hack accounting or law :)
CS schools naturally teach you to be slow paced, detail oriented and methodical, and it is sometimes good and sometimes bad.