I am a self taught dev. Been at it for almost a decade now. By far the biggest challenge you will face is imposter syndrome. You are entering a field full of incredibly smart people who are crazy opinionated and at times competitive. Your lack of formal background will mean that you wont know when someone is wrong or simply dealing in a concept with which you have no experience. You will probably cling to your first real job for way longer than you should because you will consider yourself lucky to have been hired at all. And to that last point, you will probably not make as much money as other developers with equal skill sets for the first bit of your career. You will feel like you are a fraud about to be exposed at any moment.

Your question is about the downsides of being self taught but I just want to say that you have many many advantages as well. For one, you will be an outside the box thinker and more open to learning new things. A lot of guys that come from formal backgrounds get stuck in a rut and never advance beyond that. You, always thinking that you need to catch up, will likely be hitting the books constantly and without even realizing it, surpass your peers. Try never to lose that. Its a blessing and a curse but ultimately more of the former. Good luck!

I'd probably classify myself as a "semi-professionally trained autodidact" in that I did not pursue a career in what I majored in: designing microchips. Part of that curriculum was CS courses but only a few up in the 3xx/4xx level. Also I don't develop in my day job, I administer networking equipment. So for my hobbyist open-source work, I have to learn on my own. I was taught programming, but not things like lambda calculus, advanced OO, or design patterns; was taught probability, logic and discrete math but nothing about portability, version control systems, or modern communications protocols. I was taught some level of algorithms, but nothing advanced in the area of complexity analysis.

I think Muhan hit the nail on the head when it comes to where lack of formal training can hurt: you can paint yourself into corners which you should really have known were there, and this is especially true about complexity analysis and scaling. Jan also points out that if you never got your elbows dirty, you won't know how your low libraries actually work, so instead of improving low level code and protocols when you should you'll make sloppy workarounds on the wrong side of an abstraction layer. Jos is part right in that it is always frustrating to spend a lot of time learning how "old school" things worked and then find most of those things are relatively obsolete when you get out into the workplace, but you eventually realize that ideas get recycled all the time. Often that sparkly new language or framework is just an independent re-discovering of old principles the culture has "forgotten" over time (even the very idea that old ideas so often get picked up, recycled, and presented as new is in a decades-old and RFC, though I've lost the link :-)

Also if your education is in a setting that promotes teamwork, formal training helps hugely in learning to cooperate under stress -- a lot of people learn how to cooperate at play through sports or team-oriented gaming, but not at work trudging through difficult, nebulous problems and taking responsibility.

Self taught developers are more passionate and they don't want to depend on someone else for learning things. The way software industry is moving forward these days, i don't think you can keep up with it if you don't have the ability of learning things by yourself.

Shortcomings

I don't think there are any shortcomings in self taught developers as long as they work hard and are ready to learn new things.

Try to learn basics first, go deep, try to learn how things work !

I've been given jobs over stronger candidates simply because of my engineering degree even though I didn't specialise in computer science nor electronics, but rather applied maths which is not that useful for most software enterprise setups.

In terms of my experience, several self-taught people I've worked with simply did not have solid theoretical backgrounds - explaining how a DB uses Btrees to store data got me blank stares, order complexity and algorithms were clearly not strong points with them, binary math they struggled with, anything low level was greek, but they were hard working and willing to learn.

Most of these things can be self-taught in any case, so if these things are a requirement for getting the work done, then that should be tested in the interview rather than to discriminate based on degree or no degree.

As a self-taught developer who has also been recently interviewing devs from both self-taught and academic backgrounds, there are a couple major pros and cons that I see repeatedly.

Pros - Motivated to learn new things - Confidence to know that unknown tech can be approached and tamed - First-hand knowledge of what makes a system/language/framework accessible (or not) to beginners - Passion

Cons - Lack of theoretical background can start to catch up as you move into more senior roles (although this can be abated with continued hard work and independent study). - Lack of understanding of underlying principles can lead to unscalable and inappropriately hacky code. - Lack of understanding of algorithms can be lead to same problems as above.

These are very general of course, and definitely don't apply to everybody. I think the best quality that self-taught devs have is a real passion for programming and desire to improve on personal time (although plenty of academic programmers have that as well). The cons can also be overcome with hard work and determination.

Not having a diploma is all I know. As an autodidact myself I have come across situations where people simple stop job-negotiations if you don't have the papers. I could consider it a problem but on the other hand I am thankful I will not end up in companies where status matters that much. Other than the job opportunities there are a few things which might be a little tougher:

1. learning what you don't know compared to when you're being offered something new. Especially if you want to learn something valuable in the business while you don't know the business yet. In this case a curriculum is beneficial.
2. You might not get into the naming of stuff. There are plenty of things out there, especially principles that are referenced which are harder to grasp/remember when you haven't seen them as much as an ordinary student has. This limitation can be overcome by repetition and keeping up your knowledge. Something everyone needs to. But still, it might take more time and effort.
3. A different way of thinking. I think a lot more autodidacts are focused on finding a solution whereas a proper education will force you into analytical thinking. On the other hand, anyone who has enough passion for IT to learn developing code must in some sense have analytical thinking capabilities otherwise you wouldn't do/want to be in IT. But for some people it will make a difference.

Looking at What are your best career advice for student developers? i see mostly non tech arguments. Many of which aren't in the curriculum. The are more or less personality traits. I think those are more important then the education you receive.

Great question, like @martinczerwi I am eager to read what others have to say.

Hard to answer! I removed my first quick drafts and realized that there's more to it, than just self-taught vs formal training (I'll focus on university, and leave out apprenticeship).

Being self-taught most of the time you're in the position to get stuff done. You have a more practical mindset than devs with formal training (university in particular) I think.

Devs with formal training on the other hand have a huge theoretical background, which helps to put things in context in this huge programming world. That has given me lots of headaches. Especially when some hot new tool/component/lib comes along.

Also what's beneficial in formal training is, you can take your time to understand things entirely. When you're on projects with deadlines, this is difficult.

I'm also a self taught developer, working primarily with PHP, MySQL, and some front end stuff (Angular in particular). I always felt the underlying techniques were a mystery to me (memory layout, types, compilers/interpreters), and that a formal training would have cleared the picture.

But you can learn so much by yourself in the end. And university depends on your self-motivation as well, but provides a roadmap for you (e.g. topics, languages).

Anyways I look forward to reading other answers. Nice Question!