Self-taught engineers often outperform (2024)

As a self taught developer who has spent most of their career in the big corporate world surrounded by computer science graduates my experience is this:

The self taught developer will eventually figure it out, if they are intelligent enough to approach the given problem.

The computer science graduate will generally not even try to figure out a problem in completely unfamiliar territory. Of course this varies by personality, so this is probably only true for about 85% of the computer science graduates. They cannot proceed in the face of high uncertainty.

What that ultimately means is that the computer science graduate is way more compatible in the big corporate world where they are an interchangeable cog that can be replaced at any moment. They operate in a world on known patterns just like their peers. The self taught developer, however, is constantly innovating and doing things in somewhat original ways because they have learned to not waste their personal time on unnecessary repetition, and that cavalier lone gunman attitude scares the shit out of people. Yet, those self-taught people tend to deliver vastly superior results.

Most developers don’t seem to care about superior code. They care about retaining employment and lowering anxiety in the manner that emphasizes least disruption.

The reactive ingredient is passion, not the learning modality. Low motivation is really limiting, no matter how you like to learn. Of course, this topic is hard to discuss in a quantitative way because the number of engineers you come across in your career is a minuscule fraction of the total. Hard to draw broad conclusions like this, but here are a few:

- Formal education is great for foundational concepts (math, hardware, operating systems, compilers, graphics, etc.). Self-taught approaches tend to be goal oriented (I'm learning X because I want to do Y), which can overlook fundamentals that are important. When you don't know what you don't know, having someone to efficiently guide you can save a ton of time, and for some topics, that mentor is a great textbook or teacher.

- Most engineers I know would consider themselves a mixture of formal and informal/self-taught. Again, if you have passion for engineering then you probably like to learn and build, which means you're complementing any formal training with your own tinkering.

I've met and worked closely with amazing engineers and have never found their education style a distinguishing factor. Their passion however, was obvious.

Also, the examples given in the post (Linus, Margaret) were incredibly academic :-)

University classes are great. They force you out of your comfort zones. When I was self taught I would never have pushed through learning the socket API in C, doing so many projects in bash, studying the academic side of distributed systems, data structures, common algorithms. Stuff like that.

I interview a lot of self taught people, or boot camp graduates, and their issues is often that they pigeonholes themsleves into a comfort zone, or they fall apart when you ask them about academic topics that are relevant for the job.

On the other hand, people who never taught themselves anything code related often suck at coding, or they've forgotten a lot of what they learned in college. Hell, for some of them, even while still in college they've forgotten a lot of what they were taught the years prior.

It's best to have done some code by yourself before university, so that you have faced the problems that arise naturally, and when the courses present you with clever solutions to them, you retain them. You don't just dismiss them as fancy theoretical stuff you need to know for the exam, then promptly forget. You've footgunned yourself with memory management enough times that it speaks to you when you get explained RAII.

The amount of effort that people go to cope with the fact they lack education.

There are brilliant self-taughts and educated morons, that's obvious. Personally, I am mechanical engineer that got interested in simulations, then in writing simulation code, then in gritty details of implementing numerical methods on a real computers, and ended up writing a compiler and simulation runtime. But I am not trying to convince myself that having CS degree in addition to my ME degree would not help me in any way. Not only because CS in the end is not about coding.

This is a similar situation to car mechanics taking pride in often outperforming mechanical engineers in fixing oil leakages or punctured tires. That's probably true, but we don't teach mechanical engineers so they can fix our cars (though my first job was supervising some huge water chillers and compressors in a manufacturing plant, where I often did a dirty work because our technicians didn't know how, but it is a matter of personal traits and interests. I like to get dirty).

They likely outperform for the same reason they are self-thought— i.e. it's most likely a confounder. If you have enough curiosity/pull, motivation, discipline to do it, you'll outperform in general, self-thought or not.

There's also a survivor bias at play, in the sense that the self-teaching attempts results that you see in professional environments are those that made it. So, the true question is, for those that tried this path and failed, would have they been better off with proper teachers. Sometimes it may just be a matter of time - taking longer to learn because of various reasons, that wouldn't be the case in normal educational environment.

With this said, I went through CS and math school and enjoyed it, but I don’t think I’m compatible with the format and prefer self learning.

As a professional software developer who also teaches CS at a university, my experience with successful engineers all comes down to interest and passion. Self-taught engineers are obviously interested in the subject, but among engineers with a degree, you have a mixed bag. Some of them have no interest whatsoever in the field other than a diploma, but they are familiar with the terms of the art, which makes it difficult to separate the good ones from the bad.

Think of knowledge as a circle on a board. https://matt.might.net/articles/phd-school-in-pictures/ is a great example.

Everyone that goes through university learns within a pretty similar circle initially. That circle is surprisingly narrow in the broader field. Who has time to teach the dmc algorithm (used in all highest ratio data compression software) for example. Instead everyone's taught a pretty common curricula in all comp sci courses despite the field being much much larger than that.

Now some who go through university will go well beyond that circle of knowledge. These are the most amazing programmers you'll ever meet. They'll know algorithms that are mentioned in white papers, not taught in courses and they'll kick ass. Those who've been in the industry a while have met a few like this.

Likewise self-taught engineers. They may have humbling gaps in knowledge of that big circle of knowledge that everyone that went through a comp sci course was taught. This may be a constant source of imposter syndrome but also humbling motivation for them. What they'll also know is a whole lot of stuff outside any standard curricula. After all they have the same motivation that the super engineers who went through university and continued to self-teach had. Their circle of knowledge was organically created through passion and that passion is actually one of the best signals for performance in not just engineering but anything in life.

Two people are cited as example.

Linus Torvalds has a master degree in computer science

Margaret Hamilton studied mathematics than proceeded to work at MIT, computer science wasn't really a thing back then, but she had a close enough education.

Most of the big names in computing have some formal education in addition to being tinkerers. Purely self-taught yet outstanding engineers are the exception rather than the rule.

College teaches you things you probably won't see elsewhere, theoretical foundations, lesser known systems, etc... You won't see that elsewhere because it is hard work and you won't get immediate results. It is not particularly fun and employers won't pay you for this. But if opens up your skills and complements tinkering well, for example by recognizing that the problem you are trying to solve is a classic problem that many people have studied before you and there is a whole lot of information on it that you can miss if you don't have the right keywords.

> Linus Torvalds built Linux by rewriting MINIX to scratch an itch. Margaret Hamilton debugged Apollo guidance code on-the-fly, inventing modern software reliability.

Their very first examples are Engineers with formal training. Formal training gives you the mathematical and engineering maturity TO tinker.

Recently, I've been trying to teach myself some numerical thing I don't have prior experience on (building a sparse LU solver, if you're curious). What I've found is that the single most useful resource I've found is not trying to build one myself (because where do you begin?) or by ripping apart the internals of existing solvers to see how they work. No, it's stumbling across the lecture notes of a course that covered that material, in no small part because by stepping up a level and looking at the other lectures, I can discover the other relevant things I didn't know were relevant. And this property has held true in my experience for other topics I've had to research on my own: the highest quality materials are invariably university lecture material.

If your main thesis is that university instruction isn't worth it, why is all the best material university instruction? Sure, there's an argument that learning how to build something is best done by actually building it... which is why university courses invariably have "build what we're teaching you to build" as a course project that is a significant portion of the grade.

As a self-taught engineer who made it pretty far as a career, getting to work at CSIRO (Australia's Science and Technology Research Centre), I can say I definitely did not outperform my peers there. However, engineers at CSIRO felt I outperformed the average engineer.

I was occasionally brought in to interview new potential hires, and I don't think there was a significant difference between the self-taught or the classically trained (either software engineering or computer science).

I think the difference was first of all, did they just love building, and secondly, did they ask the right questions as they went through the development process.

I think I struggled in the 2nd half of that, and I could run off on some far-flung direction not because I didn't know what needed to be done, or the "right-way", but sometimes because I wanted to try to prove that I was as capable as my peers. But the plain fact is, I just wasn't, and I'm ok with that. It's kinda how I ended up as a CEO, I can understand and direct the product/technology from a high level, and particularly now that we're in neurotech, I'm not the right person to be writing C.

So if you want to be self-taught, you can go far. But when you get to the top, you're probably going to want a great mentor who won't necessarily be teaching details about coding, but more about the approaches to engineering.

I've not met anyone in the industry who wasn't self-taught. Nobody gets by in this line of work on just what they learned in computer science classes.

You simply will not sit next to someone who was lectured by someone else in detail on every aspect of the whole tech stack you are using.

To get through those CS classes themselves takes a lot of self-teaching. The lecturers are often terrible, and you have to rely on your own research to "get" the stuff enough to do the assignments and pass tests.

I think one needs to be careful with statements like this. Is it the case that those who outperform tend to be self taught? Or that those who are self taught tend to outperform?

I can easily see why the former is true. The latter seems a lot less likely.

Everyone is self taught. School can lead you to water, but it can't make you drink. Every piece of understanding in your head came from your own learning efforts, whether that be trial and error, reading a book, listening to a lecture, spending too much time on stack overflow, or typically all of the above. School provides structure which helps with discipline, which is a serious obstacle for many people's learning efforts, especially when they are young, as well as exposure to concepts that one may not find easily without both curiosity and good research skills. But ultimately school is never more than a foundation to build off of in one's lifelong pursuit of learning. The difference between high and low performance engineers is often entirely based on how much effort they put into continuing to grow.

I wonder how much this is personal bias. I'm self-taught but I have absolutely no idea how I perform on the bell-curve against formally trained software developers.

From personal experience I've had to spend time learning concepts that I "ran into" that others already knew about. I probably spent a lot of time thinking I was good and clever enough to solve challenging problems... but then realize that I had used inappropriate data structures and made things more complicated than they needed to be because... I hacked my way through the problem rather than think through it from solid principles.

While I personally think experimentation is great... I've come to the conclusion that a mix of the theoretical and the practical is best. Being able to go back and forth between the two extremes has been valuable to me.

Exceptionally smart people are more likely to effectively "self-teach", though exceptionally smart people often still use the same sorts of resources that classroom learners do (books, manuals, spec, consulting mentors, deliberate practice.

People who aren't smart and hardworking just don't effectively self-teach.

There's no real proof in this article that anyone out proforms anyone else. The author lists a few notable cases with a few notable people, but I have to ask.

Didn't those people get an education? Didn't they go through school?

I did a quick search and linus has a masters in computer science.

What is a self taught engineer then?

I would expect that an article with this kind of claim in the title, would have some data about code quality, qualitative reivews from coworkers and managers, with different cohorts of devs, over some time frame.

This piece right now, just seems like an opinion without substance.

Additionally for what it's worth, I personally think of myself as a self taught engineer, so I'm biased to actually agree with the author. However I feel like this claim lacks substance.

Phrased differently: "people who have already displayed an aptitude for independently determining what is worth learning and learning it excel at tasks that require determining what is worth learning and learning it."

Self-taught is a double edged sword.

It generally can't occur without some level of passion for the material. But you also tend to miss the boring details.

All software engineers are essentially self-taught. Building non-trivial complex software requires the acquisition of enormous amounts of knowledge you didn’t learn at school. If you can’t teach yourself, you aren’t going to go very far.

I’ve never noticed much difference between the people with CS degrees and the ones that don’t. It is always people with relentless curiosity and stamina that have the elite skills. The only thing I might attribute to people without CS degrees is they seem more likely, in my experience, to come up with interesting ideas that actually work by taking unorthodox approaches to classic CS problems.

This is such a weird article, the two examples it gives, Linus Torvalds and Margaret Hamilton did in fact study at University. Linus created Linux while studying for a Masters in CS and Margaret had a graduate degree in Mathematics, probably as close as you could come to CS in the 60s. So it seems if anything those two are counter examples?

i really quite like the quality of vba code you can find in excel sheets in non-tech corporate environments, well, at least, the range of quality you find in there. there can be some incredible ones. code quality of matlab scripts and scientific code written by mathematicians and engineers can also be pretty eye opening.

when the only goal is a product that works, you get a lot of innovation and a lot of speed. when you don't have to worry about review, testing, and deployment, you strip out 80% of the overhead.

i heard the hedge fund renaissance technologies does not target hiring people with finance backgrounds. i wonder if you can build a tech company out of people who are just going to figure out javascript for the first time on their first day of work. when the performance hurdle is "learn something new on your own with minimal guidance", you immediately filter for a group of innovative people with initiative and drive.

But why is this surprising at all? Self-taught engineers most likely than not have the intrinsic motivation that CS graduates lack, who got into the field because of peer pressure or money.

And the raw talent too, that someone can master multiple disciplines is a sign of intellectual dexterity. Not too say CS graduates are not talented but self taught ones master more cognitive fields, which aid in their programming tasks because programming is a cognitively demanding job.

I'm going to go against the grain here and say that in my experience, self-taught engineers typically deliver worse products, and I say that as someone who is mostly self-taught, albeit lucky enough to have benefited from good mentoring. The best programmers I ever met all did software engineering or computer science, or were themselves mentored by others with a lot more experience.

I think the difference comes down to how you view programming. The self-taught programmers I've met typically see programming as a means to an end, and take "it runs on my machine" as the measure of success. Someone with more discipline will understand that that's the lowest bar and mostly a given for someone whose job is to write code. The real measure is can you come back to it in 6 months and know what you did? Can you easily expand on it to add new functionality? There's a craft there that isn't obvious unless you've done enough coding for long enough to run into the problems that software engineering is designed to solve. And if you're built like that, mentoring helps bridge that gap, because you understand why certain techniques exist. They're not just arbitrary patterns.

So I don't think it's being self-taught that makes the difference, but rather, being the kind of person who writes code that gets revisited. Even if you make a hash of it, it'll give you context so that when someone better than you comes along and points out a better strategy, you understand why it's an improvement. And I think that's true regardless of whether you're self taught, or you have a degree, it's just that having a degree in software gives you those strategies from the get-go, even if you don't necessarily have the context.

Not to belittle folks with a comp sci degree, but is it not obvious that self taught folks would be worthy of more serious consideration instead of making them do leetcode puzzle that have no real-world value? Bc I am self taught, and having the discipline just get competent at writing code takes a ton of discipline and genuine interest.

Think of all the open source projects that have been created and/or maintained by self taught programmers - ruby on rails, vuejs, nextjs, nuxt django, laravel, nodejs, express, etc.

My experience lately has been the opposite. Now that the job market is tight, I get a cold reception when hiring managers find out I am self taught. Could just be my anecdotal experience, but I would not be surprised if a person with a comp sci degree would look down on person who does not have one, especially if they are making a hiring decision.

I came from a Chemical Engineering and Math degree, but ended up teaching myself programming while I was in university. I saw my freshman year roommate getting offered more for an internship than chemical engineers were making after they graduated and put 2 and 2 together.

I think there is a huge benefit to having had some sort of extremely rigorous quantitative background. When I talk with people who are self taught who haven't come from a hard (where that is an extremely hand wavey concept) can get started in engineering and often can be productive, but really struggle when things break or get difficult. There's a sharpening of the mind that comes with extreme analytic rigour, and I think that's more important than whether you get it in a real analysis class or in a CS class.

As someone who was self-taught and then changed my degree to CS, I think one thing that shows that someone learned by themselves is that they thrive without formal deadlines.

I see some fresh grads struggling when going to a professional environment where no professor is saying "I want <product> done by <deadline date>".

I think this is why some undergrads also struggled a lot when our role became remote. Suddenly, no one went to their desks for check-ins to see how their work was doing. The code was rushed at the end of the sprint to make it to the "professor's deadline."

At the same time, self-taught people generally succeeded because they are more oriented towards a "delivering when possible" and "pushing myself to learn" mentality.

After 3 years of experience, I think this equals out, unless you talk about lower-level CS concepts like mutexes, big O, or something they generally don't need to know for their daily job.

I kind of wonder if these kinds of arguments are really:

"I didn't go to college, and I turned out fine".

I personally think:

#1 college pushes you to learn theory in a sort of "code coverage" for your brain. The tech doesn't really matter (outdated or soon so)

#2 industry is practice, practice, practice.

many sufficiently motivated folks can start off with #2 and fill in the #1 stuff, but I don't know if they bother.

Also, people who do #1 require #2 or face becoming almost worthlessly outdated.

"self-taught" from the start or not, lifelong learning is required by everyone to be decent.

All of the best engineers I know but one did not graduate in software engineering nor computer science. None.

They are all people that were coding in their teens and had a massive interest for computers, technology and programming since very young.

Conversely some of the worst engineers I know were graduates who only went into SE or CS because of job opportunities.

I am not saying ST good, graduate bad, I have also examples of terrific developers with a proper formal education.

I think all in all what really matters is whether you really care or not, whether you want to learn and expand your knowledge or not. Other than that sky is the limit. I would still suggest people to graduate if they are young and it won't cost them too much, it's good to meet fellow students, do networking, study stuff you wouldn't otherwise etc.

An interesting confounding variable might be that self taught programmers are likely to be influenced by a background in some other field. For instance, my degree is in physics, so I'm likely to "think like a physicist," if that's a thing. And I've chosen my battles well. My job is in an industry where understanding the workings of a product often starts with physics.

Another variable may be that the training process and the people who go through it are perceptive of what matters to their careers. When I'm tempted to think that engineers "like" to do certain things, and not other things, it could be due to personal ability and preference, but it could also be an economic preference not to waste their time on things that I happen to "like."

I have a CS undergrad and a MSc in Computing, did either really prepare me for industry? Not really. But I made a lot of friends, drank a million beers, and overall had a good time. They look good on a resume too.

Even when I was in school I knew that CS as a field wasn't one where you could just get a degree and get a job (well outside of 2021 maybe). After one internship I realized there was a great divide between school and work, and this was at a work place with pretty low code quality.

'Self-taught' engineers is a bit of a funny term for me because while I technically have a CS degree, everything applicable I had to learn myself. Especially for a DE job where outside of some basic SQL and the general idea of a relational database a post-secondary degree doesn't exactly prepare you for such a role.

The article is specific to software engineers, and perhaps it's accurate within that discipline. The field is incredibly broad—ranging from writing small support scripts to engineering massive distributed systems—so it's plausible that a self-taught engineer could excel in certain areas. However, I don't believe this holds true, or is even feasible, for other engineering disciplines. In those fields, earning an engineering degree is typically a prerequisite. After that, you're free to self-teach and explore further, but without that formal foundation, it's difficult to progress meaningfully.

Side note: I think the term self-taught is often misused. Very few people are truly self-taught in the sense of starting from a blank slate and independently mastering a subject without any guidance. What the article refers to as self-taught is really just informal education—learning through blogs, tutorials, bootcamps, or YouTube University.

If I think of self-taught engineers who are my peers, they look great. But that’s selection bias.

If I think of every self-taught engineer that I’ve ever crossed paths with, there are some that engaged in unscientific magical thinking.

Also (solely) self-teaching seems to achieve good results in software more frequently than in other fields of engineering.

I've found that there's greater range among CS graduate software engineers. Of course there are some truly excellent thinkers who know how to bring their training to bear on all kinds of problems. But some of them, well, you wonder how they even graduated college.

Among the self-taught, there's less variation. If they've managed to land a first job, they're usually at a pretty decent level of knowing how to learn new skills and apply them to solving problems. They were born in the "real world" instead of in the classroom, and it usually shows up in their sensibilities.

Just what I've observed from my own experience. (I'm self-taught myself.)

Linus Torvalds given as an example of self-taught engineers yet he has a masters degree in CS.

Higher education isn’t just about what you learn, it’s about learning how to study and learn.

I used to call myself self-taught because I never finished my CS degree, but the truth is I learned a lot of formal methods and techniques in college, and I wouldn't have been able to succeed without it.

Formal education is the beginning, not the end, but if you have the opportunity, why not take it?

Anecdote: I grew up in a poor family, that was single parent for my teenage years. I dropped out of high school when my son was born and I was 17. I never went to college. I was, however, a lifelong nerd and by mid-20s was able to get a foot-in-the-door job in IT. I'm 40 now and have been doing my dream job for almost 8 years. My current position was for a job that required a degree on paper. During my interview (all of them actually) I was honest about education, but also work experience and personal interest in the field, and got the position. That was 2.5 years ago and I hope to retire here.

I'm sure there was some luck involved, but just having a singular focus on computer adjacent fuckery, I managed to build a pretty successful career being 100% self taught.

I started hacking web projects and messing with Slackware in the mid90s as a self taught dev. Before that I was always building things on my computer it felt more like creative exploration or entreatment than academic discipline which is why I never pursued a CS degree.

Whats fascinating is how differently CS trained and self taught developers approach problems CS grads often bring systematic thinking and solid theoretical foundations they'll architect elegant solutions and consider edge cases upfront Self taught folks myself included tend to be more experimental willing to hack together quick prototypes and iterate rapidly Ive found the magic happens in small teams that blend both approaches The CS trained developers provide structure while the self taught crowd brings creative problem-solving and isn't afraid to break conventional rules... sometimes there are no rules. Has anyone else noticed this dynamic Im curious if others see different complementary strengths between these backgrounds or if this varies by company culture domain

Well, "Case Studies of Tinker-Born Mastery" is a pretty LLM-sounding heading if ever I've encountered one, and that bulleted list of examples...

It's interesting to think through which of the LLM-produced texts that I've read recently have delivered value and which haven't. This one doesn't impress me, but there was one about social skills I thought was good – yet the comments there pointed to maybe that being because it was synthesizing some high-level points from a book. Getting the model to go fishing for ideas rarely seems to work out to anything that feels worth my time.

Hmm - i'd like to see the proportion of self-taught engineers that quit before they became self-taught engineers. This feels like a classic WW2 bomber problem. More computer science grads end up graduating while despising computer science ( I knew many) because it's just a potential career track.

I think there's a bit of a survival bias within this, you aren't going to get data from self-taught people who now work in accounting because they tried to be self-taught but didn't really find passion.

If the basic capabilities are present the thing that matters is motivation.

Self-taught naturally correlates with motivation (as well as a few other mixed traits).

It's neither a cause or guarantee of performance, but it can be very useful information to know about candidates when recruiting.

(as someone who is largely self-taught and done a bit of the recruiting and management thing)

Being self-taught self-selects for those who enjoy it and those who enjoy it are way more likely to keep expanding their skill set.

As for the tinkering advice in TFA: While I wholeheartedly agree, as I grow older I find it progressively harder to force myself to start a new (and novel) project just because.

I still have personal projects, but they are very purpose driven and thus I mostly use what I know rather than exploring new tech.

Slightly misleading headline. This article is about programmers not licensed engineers.

Yea, true of many things. Anyone who has the drive and motivation to teach themself anything, usually do a good job.

Doesn't mean you'll always get everything right or that you'll be good at first or even as good as someone taught to do the thing, at first. But practice makes perfect and over time you can be as good or better than someone with training. There's absolutely no reason you can't train yourself on just about anything.

The issue here is not one of self-taught vs formal education.

Nor is it one of motivation/passion, although that plays a bigger part.

It's rather a matter of gifting. Some people "get it" when it comes to programming in ways that make them profoundly more competent than others. This is regardless of education.

The other big factor is whether or not they enjoy the frustration and successes of programming.

The best developers are those who are gifted and enjoy the fundamental challenges involved in programming. Formal education is at best tangential.

I think what my computer science degree taught me more than anything is historical context and good taste.

Of course you can develop those on the job. But it was a good shortcut I think.

This is a strange dichotomy. N years post CS undergraduate the majority of what you know will be self-taught, but how you've put it together in your head will be different with a theoretical background than without.

A theoretical background is valuable. It distills hundreds of years of other people's learnings. Ceteris paribus, if you do not have it, you are at a disadvantage.

Yes, but it's a problem in hiring.

A degree is still a good proxy for good worker, because it guarantees that:

  1. The employee was able to work on the boring matter he was assigned, and often disliked
  2. The employee internalized some social norms, unlikely to be a weirdo
  3. The employee knows what he doesn't know, and what things exist in the industry

* technikum in post-soviet countries is 1-2 year vocational education, lower kind of degree than college or university.

Learning to learn efficiently is an incredibly useful skill that is required for survival in the self-taught path. Deciding what to learn next while making progress in your project in order to strategically unlock better decision-making at the right time before investing in the wrong path will compound over time and lead to increasingly improving skills like technical design, architecture, and project planning. The only major downside to this path in my experience is the increased probability of impostor syndrome which can be detrimental specially during the early years of your career and when you are trying to grow into the next level.

The analysis is wrong. The problem is most software development tasks are to software engineering as building a driveway is to building a bridge.

As in the civil engineering example, both involve concrete, labour, levels, project management, but the jobs are just too simple to require or reveal the knowledge held by the graduate civil engineer.

I'm probably easy to mistake me for being self-taught, considering I was programming as a kid, and never finished university, but I didn't really learn to program until I went to university. I wanted to, as a kid, but unlike my brother, I could never figure it out, until I got my hands on something better than Basic, and some good guidance and teaching.

I. Recent years I've only been getting more and more passionate about it, but that's probably mostly because I'm finally getting the opportunity to tackle some really hard and interesting problems.

The main reason for this is because self-taught programmers FOCUS ON ONE LANGUAGE. I realized that I went through all the courses I needed to learn from university in different programming languages for some strange reason, and that just left me all over the place as a developer.

It is an easy fix, teach only one language for the 6 core areas of programming, namely:

1) Intro to programming (variables, loops, conditions etc. up to functions) 2) Complexity management, usually OOP 3) Building a GUI (it is not trivial and needs to be a course on its own) 4) Connecting to a database (also not trivial) 5) Data Structures and Algorithms 6) Compilers and programming languages (basically popping the hood of programming)

In school, after learning OOP in Java we switched to web dev and learned javascript and php. We completely abandoned learning GUI and DB for java.

Algorithms was taught by a visiting lecturer in C++ and after mid-sem we switched to Data Structures in java??

The universities are doing a fine job, but please just stick to one programming language for these core areas and everything will be great.

I came to this conclusion before AI took over. It will be interesting to see how AI changes the Computer Science curriculum in the years to come.

How do you define self taught?

Linus Torvalds was a CS student when he released the first version of linux...

I'd rather say you need both "breaking your teeth" on your own projects and some formal training on top of that.

This is really obvious but good to see it validated. If you don't have firsthand experience discovering and playing with fundamentals, you are at a disadvantage.

While true, we often have a harder time getting in the door. So take that as you will. Orgs want paper degrees.

The article did in fact not make an attempt to demonstrate the claim in its title.

Where is this non-self-taught engineer you speak of :)

Sure you can do Java 101 at uni and more Java on a course. But 90%+ knowledge is hard won. Even before you get a job.

There might be a flying analogy. The best pilots are the ones who have flown a real aeroplane!

As a mostly self-taught engineer, the reason is simple: after 5 or so years, the language, tools or architecture is going to be dramatically different and you have to learn on the fly. Heck, even how to learn has changed dramatically. When I started, I learned languages from printed books. Then docs and Google, then added StackOverflow, now AI.

In my experience it’s a huge “it depends on the person”.

Younger self taught engineers with a huge ego can be a real PITA. Some have tendency to question everything that has already been written, wasting time.

I was actually talking about this with a dev this morning.I might reframe this away from self-taught and more towards on the job experience.

Obviously, I think it depends on the domain you're working in, but most comp sci majors really learn math and algorithms.

Math is great, of course, but the vast majority of app and web developers never use any of it. So at the end of the day, even with a proper technical background, everyone is really self-taught when it comes to Python or React programming when they get a real job.

This is a broad brush, but then you get data scientists with academic background who maybe learn R or Python for analysis, which again is great, but they don't necessarily learn OOP principles or exception handling and so their code quality is bad. Yet, they are often tasked with creating apps or doubling as a dev and so they too end up becoming self-taught to a degree.

Just two cents

Nah, you need both. A formal foundation in core concepts is the bedrock upon which to do self-study. The smartest engineers are the academics. They're the ones who design new algorithms for the rest of us to use and their achievements are built on deep knowledge-sets, which are mostly formal.

Probably the actual difference is what you are able to retain in your memory.

I know that the parts of computer science I learned on my own or while on the job, are far more sticky than anything I studied in university, even back then

Also there's a different in what you think you understand and what you actually understand

As a self taught engineer who hasn't read the article or done any research I can confirm.

I'm self=taught, and I think this is nonsense.

1. There's heavy survivorship bias. Many, many self-taught folks are ineffective. The only ones you see in the wild are also talented--talented enough for management to ignore their lack of a credentials which is a little more talented than most.

2. There's even more selection bias: people who self-teach may have more self-confidence and drive. I will say, however, that today salaries seem to be a larger motivating factor. Do you really think the finance bros who switch careers care about the craft?

3. Self-taught != experience. Having "the intuition needed when the recipe breaks at 3 a.m. on prod", is not imparted until you actually deploy something to prod. 99% of self-taught folks haven't deployed anything to give them that exposure.

4. Self-taught does not often give exposure to "hard problems." Most self-taught folks can't do fundamental work on databases, operating systems, file systems, machine learning, or compilers: you know the hard math and CS they teach in schools. Most get trapped doing easy things, and in turn, most get trapped in full-stack roles.

5. Is self-taught really even self-taught anymore? Does Coursera count?

Self taught or otherwise, Life is lived in the Arena

Makes me think of this classic from Derek Sivers - There is no speed limit - https://sive.rs/kimo

Oops, Margaret Hamilton is a terrible example and immediately makes me lose respect for the rest of the article. She was famously mostly a manager who received the credit for the work of others. Read the book by Don Eyles and read between the lines.

(uh oh here come the downvotes)

Having been on both sides of the fence I can definitely speak to autodidacticism as having yielded some of the most durable and rewarding lessons of my lifetime spent programming, if only because I was really internally motivated to try my hand at game modding, or writing fun toy websites or mobile apps, or even learning Haskell. There are indeed some practical realities you will learn how to overcome that simply are not (and should not) be covered in a usual computer science curriculum (e.g. git, vim, basic shell fluency, etc.).

At the same time I feel that the self-taught dev or bootcamper from the 2010s is really a far cry from the geek culture of yesteryear. As opposed to misfits obsessed with computers, we now have grifters appropriating geek culture to make a buck off the industry. These people lack internal motivation; they are driven only by the external motivation of monetary reward. Consequently it's unlikely that they would delve into more of the esoterica of computing that, while interesting and fascinating to learn about, doesn't yield immediate monetary benefit.

In concrete terms what this amounts to is people "self-identifying" as "senior software engineers" who have never heard of the term `xor` in their life, and don't even understand what a truth table is when it's drawn out for them.

Even still, those who are highly internally motivated are still likely to have blindspots in their knowledge or not know that a field of study useful to them even exists, which is why having a more systematic and thorough review of the field's basics is useful.

Is knowledge of basic boolean logic, "advanced and impractical theoretical computer science," or merely, "table stakes?"

When anybody can identify as anything you eliminate the possibility of drawing meaningful distinctions and assessing qualifications.

Self taught then got the paper degree from the daycare. Best combo. Ok to be fair the college did teach me a lot I didn’t get while self taught.

There's just something about learning through pain

I have been programming since I was 8 years old. In 1978 I touched my first computer, a Commodore Pet which had been added to the office of a friend of my family, who had no idea what to do with it.

I was immediately drawn into this world and that moment changed my life definitively.

I've since been around the world twice, have written software in a diverse array of markets, including realtime/embedded/safety-critical, professional audio, and scientific instrumentation fields.

I'm a highschool dropout, became a competent POSIX developer in the 80's, a competent cross-platform developer in the 90's, an embedded and safety critical developer in the 2000's, and for the past decade have been shipping products in the professional audio realm. I've also been involved in multiple startups - some huge and impactful, but most small and irrelevant.

I dropped out of high school in 1987.

Throughout this era I've been constantly challenged by academic-trained developers who say things are impossible/can't be done/etc., only to have my work demonstrate otherwise.

The key to this is, I am full of self-doubt, and double-check myself, repeatedly, in order to not wreck myself. Whereas, academically-oriented devs have had to eat humble pie, time and again. This is not to toot my own horn - just an observation that over-confidence (or indeed, radical under-confidence) is often the product of a huge investment in ones' education, especially if there are large debts involved (I have no student debt, but I do have 40 years of computer history sitting in my living room, having kept every single platform for which I've done some form of development ...)

For many years, I saw computer programmers graduate who could not program their way out of a sealed/wrapped box, and many, many times have had to teach them, myself, to get things done.

That said, I've also been humbled by the brilliance of the DSP and machine learning engineers I've worked with, who could not have established their competencies without having had the time to study.

I've done software dev projects in Japan, the USA, Australia, Germany, Serbia, Kosovo, Italy, the Netherlands .. with many of my projects still in use on a global scale.

I think with software development there is a self-study discipline which must be maintained in order to stay relevant - I was lucky to learn that skill at an early age and to use that discipline to gain more skills. I don't think this discipline is taught well enough in the various markets in which I've worked:

It's not what you know. Its that you know you don't know and know how to know.

Project workflow, debugging techniques, separation of concerns, and most important of all: proper analysis (identifying similarities/identities/differences in ontology). All generations of software developers have issues with this, and all of us can improve.

As a self-taught software developer, yeah, it's kinda true. I've encountered developers that are older than me, have more experience as me, has multiple degrees, yet they're dumb as bricks when it comes to anything remotely related to problem solving (or not using genai to do all the work for them, which I think is absolutely disgusting).

I learnt everything I know about programming from buggering around, and just making cool stuff. Then you'll get annoyed how past-you wrote it, and then you'll rewrite it and you'll learn how to make better code & better projects. Most engineers/devs I know that was taught at a university or college can't really do that, and most I know take ages to make anything that can be used (or even shown off as a demo to your boss). Some of this could also just be that there's usually a higher chance for self-taught engineers/devs to be neurodivergent of some sort (adhd/autism), because I am myself and I know that my different perspective does give people a breath of fresh air when working on projects.

meh. There's a lot of really good self-taught engineers but this seems like a weird thing to bring up.

I worked with someone that was self-taught, them vs 2 of use with more formal education, we had a difference of opinion on how something should be be handled so our boss at the time basically posed a contest that whoever could get it done first would be what was implemented. Of course they outperformed and got it out faster.

1. That's a horrible way of deciding what gets pushed, pitting developers against each other. 2. The resulting code was awful to read and very procedural. Written by the same developer that made a god awful hero function.

That's an artificial division.

Many of us computer science graduates were selft-taught developers before we went to university :)

Isn’t that cherry picking? Do self-taught outperform others or are outperformers often self taught?

Seems the same logic like looking at Bill Gates or Zuckerberg and claiming college dropouts get rich.

I think there’s an element of fear in the self-taught engineer? I am self taught and even after over a decade of experience impostor syndrome is still going strong!

At the same time I’ve been surprised by graduates when they come across something and say “I didn’t see that in school”, like, what!? I thought the job was mostly learning on the go!

...and self-taught statisticians often know about Berkson's paradox

If you pair a self taught engineer with a classically trained engineer, the self taught will dramatically reap benefits from the collaboration but the reverse isn’t true.

A true 4 year CS curriculum is so theoretical you basically have to self teach to do anything practical once you leave the university. But due to the intuition you gain in university, your teaching process happens much faster and can hone in on specific correct paths, which contrasts with the pure self taught engineer who maybe stumble around longer or get trapped in local minimums.

Some self taught engineers may never truly grasp certain high theoretical concepts because they never occur often enough in the wild, but the CS degree holder will at least know these concepts exist and where they might apply. This is what can make the difference in a business’s competitive edge.

Nowadays though, I’m growing cynical of a lot of people trying to enter the industry as self taught, as many are simply chasing the high salary and easy lifestyle of the typical software engineer. You need to figure out quickly if you’re dealing with a true enthusiast or just someone chasing a good job. It’s safer to just go with the CS degree, but even there you have the same problem, the people entering the industry just aren’t built like they used to be.

Sorry if this is a little rambly, it’s late.

Thanks for rare ego boost hn haha

I think the most interesting and cutting edge work in the corporate world is reserved for school graduates

There are alot of specialties that just feel out of reach for me. becasue I don't have credentials or a way in.

Clearly selection plays an enormous part here. The average engineering graduate is average, obviously. He did what was expected of him and he had enough drive and curiosity to carry himself through university.

To self teach an entire field takes enormous drive and curiosity. It takes struggling against adversity and ingenuity.

The idea that the latter path is generally superior is delusional. In all likelihood it involved far more effort, frustration and time. Comparing a self taught engineer and a graduate of the same skill level it will be clear that the graduate had a much easier time. He had the opportunity to build upon a solid theoretical foundation, when being forced to engage with practical problems, which every engineering program does.

Engineering is also a profession, not a competition. Average engineers aren't a problem, they are absolutely necessary and represent success,not failure.

Because we have to. It's obviously survivorship bias. I don't have a single chance at interviewing against someone with a degree unless I can undeniably prove that I am head and shoulders above the pack. And so you grind and grind and grind in a way that someone with that piece of paper to rely on doesn't feel the need to, because the bar is that much higher.

It wasn't always this way; making it without a degree used to be a badge of pride in this industry. But the glut of CS grads these days has made it something of a handicap to be brushed around at this point.

[dead]

[flagged]