Code Complete, by Steve McConnell The one single book that will teach you what you really need to know, and more importantly it will teach you how to think like a programmer, which is something one would hopefully get from college, but alas often is not taught.

Another great one is "Writing Solid Code" by Steve Maguire. Teaches you how to write code that will not fail mysteriously and that is easy to debug.

• Books on theory. Scheme, Lambda functions.
• Books on Algorithm Complexity - O(N) O(n^2)
• Books on NP-completeness - Knapsack Problem and Traveling Salesman
• Books on Algorithms and Data Structures - AVL Trees, B-Trees, Red-Black, Graphs, Shortest Path
• Books on C, eventually up to something like Deep C Secrets which I just finished, and loved
• Books on Compilers, so you at least understand the different passes

I'd recommend "Structure and Interpretation of Computer Programs" by Abelson and Sussman. You can also watch class videos from MIT.

See this wikipedia article: http://en.wikipedia.org/wiki/Structure_and_Interpretation_of_Computer_Programs

Gang of Four's Design Patterns: Elements of Reusable Object-Oriented Software ^[1] - best pattern book of our time, BUT also quite hard/dry to read so if you are looking to understand the material in a much easier way I would also recommend Head First Design Patterns ^[2]

Related SO Questions:

• As a programmer without formal cs training or a cs degree what am I missing? ^[1]
• What does a college degree provide that experience doesn't? ^[2]

These might help you cull some imformation together

Fowler's Refactoring: Improving the Design of Existing Code ^[1]

Joel posted a great list a while back : http://www.joelonsoftware.com/navLinks/fog0000000262.html

I guess that posting yet another answer, especially one that shows up below the fold might be futile ... but I'd suggest that your next move should be in two directions:

Firstly, get really really good at one area - specialise in it to an extent, get to know it forwards, backwards and inside out.

Secondly, get wider experience/knowledge across a very broad range of skills - you need to know a little bit about a lot of things.

The Challenge - doing both at once!

For that second bit, here's a partial list of useful skills that I blogged ^[1] in October:

• Abstraction vs Implementation

• Amortisation

• API Design – noun/verb vs Fluent

• Authentication vs Authorisation

• Bandwidth vs Latency

• Caching: Expiry strategies and memory use

• Class Oriented vs Object Oriented

• Class, Instance and Sequence diagrams

• Colour Modelling

• Compiled vs Interpreted code – byte-code, p-code, IL

• Complexity: O(x) notation, linear vs quadratic vs exponential vs factorial complexity

• Connectionless vs Connected

• Database management: Schema design, query optimisation and indexing

• Declarative vs Imperative programming

• Dependency injection

• Duck Typing vs Strict Typing - Type Inference

• Encapsulation

• Encryption vs Obfuscation

• Entity Relationship modelling

• Entropy, Compression, Encoding and Encryption

• Ethernet, TCP/IP and UDP/IP

• Events - Singlecast vs Multicast

• Exceptions vs Error Codes

• Explaining technical issues to non technical people

• Functional vs Procedural programming

• Hash tables and arrays

• Identity

• Indirection

• Inheritance vs Composition

• Instantiation

• Liskov Substitution Principle

• Lists/Stacks/Queues and Trees

• Memory heaps and fragmentation

• Memory management Garbage collection vs malloc/free vs reference counting, stack frames and pointers

• Method Missing

• Mutability vs Immutability

• Mutual Exclusion and Locks

• Object vs Component Orientation

• Pattern Matching and Regular Expressions

• Polymorphism, Abstraction and Interfaces

• Pre-emptive vs Cooperative multitasking

• Proxies and Delegation

• Recursion vs Iteration

• Requirements vs Specifications vs Implementation

• Semaphores, Spin Locks and Monitors

• Single Responsibility Principle

• Source code management - labels, branches and versioning

• State machines - deterministic vs non-deterministic

• Stateless vs Stateful

• Teach a class and Present a seminar

• Technical documentation

• Testing Unit vs Integration vs System vs Performance vs User Acceptance

• Threads vs Fibres vs Processes

• Transactions Commit/Rollback vs Complete/Abort

• Unicode vs ASCII, UTF-8 vs UTF-16

• Write Training materials

Interesting selection of books here so far and many of them are particularly good. I was surprised to see that the following were missing, so I'm going to add them:

• UNIX Network Programming. W. Richard Stevens.
• TCP/IP Illustrated, volumes 1-3. W. Richard Stevens.
• IETF [RFC1034], [RFC1035], [RFC2616]
• Mastering Regular Expressions. Jeffrey Friedl.

I know that these seem a rather strange choice for general purpose programmers but over the years I've found that understanding TCP/IP, DNS, etc. has been one of the single most useful things that I have ever learned. If you are planning on doing any serious distributed network applications and actually supported a deployed product, then a good understanding of how those Internet protocol thingies work is invaluable.

Now for a few esoteric choices that I really enjoyed:

• Linkers & Loaders. John Levine.
• Advanced Programming in the UNIX Environment. W. Richard Stevens, Stephen Rago.
• Large Scale C++ Software Design. John Lakos.
• Compilers: Principles, Techniques, and Tools. Aho, Sethi, Ullman.
• Open Sources: Voices from the Open Source Revolution.
• Programming Language Pragmatics. Michael Scott.

Beyond specific books, I would concentrate on learning solid software engineering practices and then learn how an operating system does what it does. The other thing that I thing helped me the most was really becoming proficient with tools and utilities. Spend some time really learning regular expressions, pick a good editor and learn how to use every feature that it offers, learn how to use GNU Make and Ant at a minimum.

And by learning how an OS works, I mean really digging into it - check out things like the "Design and Implementation of the 4.4 BSD OS" by McKusick and "Windows Internals" by Russinovich. Combine this sort of knowledge with compiler construction and linkers/loaders and you really get a good perspective on why certain programs behave the way that they do not to mention a lot of extra tools when it comes to debugging.

I've been programming professionally for almost 10 years - and I will be graduating this year. The coursework I did was largely useless. Hands on experience and finding one or more great mentors will serve you far better in terms of becoming an excellent engineer.

The good thing about finishing a degree is that a) it is a nice resume bullet that HR types like to look at b) it teaches you some jargon that is useful for communicating ideas to other developers for example: Normalization is word that we throw around in the real world - there's a text book definition that's nice to have in the back of your head, but in practice it typically just means adjusting database tables so that your data meets your needs in terms of performance and scalability. c) helps you to learn to communicate better ... which is a useful skill that will set you apart from a lot of software people.

Things I recommend reading: 1) operating system design 2) data structures and algorithms 3) database theory and....if you are standed on a desert island with nothing but a laptop, unlimited power and a single coding book of your choosing... without a doubt choose:

"Elements of Reusable Object-Oriented Software" -- Gang of Four

The C Programming Language was a great read for me as a non-CS major. Simple things you take for granted, like local variables in functions, are described in such detail. Complex things like pointers and memory management are described in a very readable way. This book really made low level programming seem a lot simpler than they way I had thought about it.

Back when he was still doing podcasts Joel Spolsky answered the similar question, which was partly " Does a good programmer without a CS degree really have a chance to get a job at Fogcreek? ^[1]" (It's near the end of the page.)

He says that for a good self-taught programmer who began with a high-level language, say PHP or Java, who comes at programming from a practical perspective, there are a few important parts of the CS curriculum the person may have missed out on, and goes on to list some books that would help fill in those gaps. That sounds a lot like your question!

Off the top of his head he named these books in about this order:

• Structure and Interpretation of Computer Programs ^[2] ( also free online ^[3])
• C Programming Language ^[4]
• The Unix Programming Environment ^[5]
• Introduction to Algorithms ^[6]

He said that those books covered the aspects of the CS curriculum his company needs in a good programmer, e.g. being able to create algorithms for an uncommon data structure.

Those books all have the added advantage of having exercises, and all being a very pleasant read. SICP is an introduction to many of the big ideas in CS: data structures, streams, recursion, interpretation, compilation, register machines, etc., and their implementation in Scheme (a kind of Lisp). It's a great place to start. The next two focus on implementation details like pointers and memory allocation. They are compact, powerful books. The last, Introduction to Algorithms, seems misleadingly titled, as it is fairly comprehensive and used in both undergraduate and graduate courses. If you work your way through the entire book, chapeau!

I recommend learning Lisp. As a programmer, being able to see a problem from more than one perspective is an important skill. Don't stop at Lisp, though. Keep going with other languages. Constantly ask for language recommendations.

See also:

What books would you recommend for a beginning Software Developer? ^[1]

What is the single most influential book every programmer should read? ^[2]

And in a related matter:

What would be the best book to read in order to really ‘grok’ OOP? ^[3]

I would say that Corman and Rivest's (CLR) algorithms book is a must have. You don't have to master everything, but it's a very good introduction to the CS thinking. It also covers topics like computation and complexity.

I would also suggest reading one of the main textbooks on computer architecture and assembly.

If you do a lot of network work, you may want to read an academic textbook about the underlying theory.

Finally, there are books on programming languages and type systems, but many of them are not very approachable.

Object Oriented Software Construction by Bertrand Meyer (1997)

Study probability and linear algebra, and as you do try and come up with solutions to problems using programming. Throw in some discrete mathematics and really force yourself to learn how to think in terms of proofs and expressing problems and solutions mathematically, it will help you organize your thoughts and make you a better programmer, especially if you ever run into any hard problems. Check out Open Courseware and, even if you don't want to take a course yourself, look at the materials they cover in the different courses and see what catches your interest and really dive into it. Just reading a book won't give you the kind of deeper knowledge of a subject that working on problems and forcing yourself to solve them instead of just flipping to the answer page will.

The core of being a good self-learner is to be able to push yourself even in the absence of marks and diplomas as external motivators.

Sorry, i don't think undergrad CS courses teach anything useful. At least that is my experience.

Furthermore, "a pretty good programmer" doesn't mean anything.. native language programming vs. managed language programming is very different. UI calls for certain patterns that you should be experienced with, in a particular UI framework. Working with a DBMS requires understanding of concurency, transactions, etc.

Probably the best thing is to identify your interests. It's pretty hard (and costly) being a renaissance-man type programmer these days, who dabbles in everythign. That will come with time, but you first must know one area well.

Algorithms are useful, but they also come prepackaged these days in neat little classes. What doesn't come prepackaged is a thorough understanding of what happens to your code when it gets executed. For example, if you were interested in server side programming, I would suggest you start looking into Java or C# internals, performance considerations, best practices, etc.

The Spy Who Came In From The Cold by John Le Carre

I am a self-taught programmer(8+ yrs), too. Till now, I found The Pragmatic Programmer: From Journeyman to Master ^[1] is a very helpful book for me. It will not teach you technical details, it will tell you what to do/learn to become or keep being a good programmer.

You'll be missing the algorithms background. I'd recommend you read Knuth ^[1].

Not a book, but Stanford has an awesome set of videos on Youtube ^[1].

My personal favorite is CS107 - Programming Paradigms ^[2].

As a self-taught programmer you easily end up with big holes in you knowledge, because you typically focus on the task at hand, and learn from that. At least that is my own experience as a self-taught developer! Therefore it is a good idea to learn from material that cover a broad range of abstraction layers or paradigms.

I recommend reading (and solving) The Elements of Computing Systems: Building a Modern Computer from First Principles ^[1]

It gives a great overview of the levels of abstraction from chip to OO-programming. The exercises includes actually designing chips (in a simulator), creating you own assembly language, create a compiler to that, and so on.

When you have mastered that, I recommend SICP ^[2]. It uses scheme, but is really a general introduction to all major programming pradigms.

Both books are hard (but entertaining!), so expect to use a lot of time on it.

I would recommend Clean Code.

http://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_3?ie=UTF8&qid=1292574690&sr=8-3 ^[1]

This is a great book in learning how to write TDD code and correct code.

It is a must read for everyone coding out there.

I think the The New Turing Omnibus ^[1] would be great for start.

I'll be honest, the degree is mostly proof to your employer that you can follow through on a task that takes an extended period of time and energy. Many employers, despite your prior skill, may not look at you without it in this field.

That being said, I recommend "Domain Driven Design" as a book to read. But do consider getting your degree. It will simplify all career-related transactions. =)

I can't believe no one has mentioned the codinghorror.com recommended reading list yet:

http://www.codinghorror.com/blog/2004/02/recommended-reading-for-developers.html

As a self taught programmer with a lot of real world experience now working for one of the top software companies in the world, I agree with that list wholeheartedly. Though many of the other recommendations made here also very good, this list is a great starting place and covers a wide variety of topics which you many not even know are important, such as UI design.

The most important book however is Code Complete. If you only buy one book, buy that one.

Bookless, quick hits:

1) Read the wikipedia entry on the Halting Problem; this explains why you can never have code that figures out what other code does, at least in general. (Code with limited loops can be figured out though). Realizing that this basically was what I was trying to do has kept me from trying something overly ambitious a couple of times.

2) The pumping lemma - you don't need to understand it, just know that there are only a couple classes of computability, Regular and Turing Complete. Know that, and wny, regular expressions can not match an indefinite number of parentheses, for that you need a proper language.

3) And, well, one book, practical, on proper, Turing Complete languages. I really like the recent semi-Antlr book on programming language implementation patterns. Little-to-no theory, bite-sized chunks of info, but gets you writing & using mini-languages. A pleasure to read, but the author is a compilers prof, do not fear it being a mentally shoddy throwaway. And you can apply 95% of it without ANTLR (the profs language tool), it's not an ANTLR howto.

Whatever you are interested in.

If you are really interested in becoming a better programmer, nothing beats reading the source code, and stepping through it with a debugger, of a good open source project. That's a good first step IMHO.

A good second step would be to look at the reported bugs/features in an open source project you like, and then try to implement them and push the fix back for review by the community around the open source project.

A good third step would be to look around and start a new open source project and try to popularize it by creating a community of users.

Books are good (Not all of them, though). Some CS Professors are good (Not all of them). Some university courses are good (Not all of them). It really comes down to what you would like to focus on, learn and have fun with.

Personally i don't think there is a high correlation between CS students and good programmers, as you yourself have noted above. I could be wrong though. I admit i am biased a bit. I attended university at a time when no university (at least, in my country) offered a CS course. I have, over the years, worked with a lot of. programmers. Most of them mentioned how irrelevant their course is to their day to day working environment.

++ I just bought Design Patterns: Elements of Reusable Object-Oriented Software.

AviewAnew's comment might seem a bit exagerated, but it all depends in how deep you want to understand the whole thing.

The lower the better.

I have even played with microcontrollers, made lots of circuits (digital and analog with opamps and several electronic elements), then I played with asm (just a little) for several chips.

But.... I found that I was missing the "magic" of OO, so I bought some OO books.

So..... What can you improve? any weaknesses?

I strongly recommend Applying Domain-Driven Design and Patterns: With Examples in C# and .NET ^[1] even if you aren't a .Net developer. It truly opened my eyes to TDD and Domain-Driven Design.

Basically, try to read books that focus on related topics but not exclusively about programming because programming in and of itself will come with practice (if you understand logic). Try to focus your learning on designs and patterns, testing, networking, and other miscellaneous functions or frameworks (linq/entity framework for instance).

Also, try to expand your knowledge-base of languages. Become comfortable with dynamic and functional languages, SQL, XML, and of course XHTML / CSS. The sheer versatility will significantly help you improve the overall quality of your workmanship.

On a side note, CS degrees generally prepare someone for the next-step in the education cycle. A lot of what you would have learned in an educational environment would prove trivial for a typical business-oriented developer. I have been in the business for awhile and I'm still finishing up my degree (last semester, thank god). Almost all of what I have learned has proven to be applicable has come from self-taught learning.

CS is one of those fields that a degree holds entirely too much weight. I barely squeeze by with a 2.x but run a successful firm and, although this may sound arrogant, can architect and program better than most graduate level students.

http://www.amazon.com/How-Solve-Aspect-Mathematical-Method/dp/0691023565 ^[1]

A college undergraduate computer education can probably be caught up to by reading books and on the job training. Also a lot of it does not apply to a typical programming job because the college emphasizes theory and concepts. E.g. a class on unix will be on the design of the unix operating system, not how to write shell scripts. Most of the concepts related to your job you have probably picked up already.

However the general education from college does teach you things. All the math teaches you to be detail oriented and increases your problem solving skills. The papers will teach you to read stuff and not trust it without analyzing it on your own. Many people have these skills naturally and don't need college. Some people will never pick them up no matter how many years they go to college. Others learn them during college. I would say How to Solve It is good for solving math problems, but the advice also applies to other problems.

If you know C and C++ you probably know the difference between a linked list implementation of things and an array implementation and the complexity. If not, look into some algorithm books (Introduction to Algorithms Second Edition is probably one of the most popular but it is a tough read, there are many other easier ones...look at the reviews to find a good one). Even for a normal business job it doesn't hurt to know which containers are slower to insert/delete and which are slower to search, etc. and the relative differences in costs. Often changing one or two library calls or one class for holding things can speed up the code tremendously.

Honestly it sounds like you've already got the head for thinking through a problem. There are tricks to be gleaned from books, so to answer your question, I learned a lot from MJD's HOP ^[1]. Though, I've found that I learn a lot more from interaction and practice. If there is a local user group start going to there meetings, you can publish something to CPAN. Long story short, get involved, it will help you figure out what you really want to focus on learning.

Don't limit yourself to just books when there is so much free/open source code to study and evaluate. Some of it is good, some of it is horrible, some of it is so darn cryptic that your eyes bleed trying to read it (i..e. grab the source to PHP itself).

I'm self taught .. I started in the earlier days of Linux/GNU development (about 1992) after learning a bit of C through working on hobby BBS systems. The benefit of peer review is priceless ... you not only get input from one or several instructors as you would in a CS course, you get input from some of the most brilliant programmers working today.

I now work mostly with Unix-like operating systems, typically with something surrounding virtualization. I think, now, for me a degree would be painful to sit through.. I have no plans of getting one unless I absolutely must .. but I don't see that time coming in the far or immediate future.

People that I work with who obtained a degree from a quality university still blow me away .. like you, I could not sit down and write a compiler .. but I have dabbled in writing my own simple interpreted languages.

As far as 'really good' programmers? Those are just programmers who love what they do and continue to learn/study far after graduating. Those are the people who I love to learn from. Then you have the type who graduate and think the world owes them a paycheck.

I too was a non-CS programmer and taught myself by reading books. Here is what I found most useful:

I second the nominations of The C Programming Language and Design Patterns. The first will help you understand the machine. The second will help you see the elegance possible with OO programs.

A book on operating systems. I recommend Operating System Concepts by Silberschatz but there are plenty of others. I found this helped me to understand why the compiler did what it did and why the APIs were structured the way they were.

A book on processors and how they work. I found Computer Organization and Design by Patterson & Hennessy to be a great one for this. If you understand how a processor works, you'll understand a lot about how to make programs performant.

Be careful with the algorithms books. Many are very mathematical in nature and will be hard to understand if you've been out of school a long time. Look around for one that is less rigorous.

As you are aware of the technologies (you mentioned that) so I recommend you to read the following topics as a critical topics

Theory of programming languages Compiler construction Code optimization Operating system concepts

And you can select some optional topics like

network programming image processing

In short:
I don't think that reading books can replace getting a degree, so for me, there is no point in suggesting specific books or topics. I would recommend getting a degree, and if you really want to become a better programmer by reading, then don't concentrate on just one topic, be versatile and read what you think fits your current problem or your current mood. Don't read a book when it's a pain to you, you won't learn anything. Reading books should be part of everyday life for any programmer, no matter if he has a degree or not, but it's just one part of the process.

Now the long reason: (since it doesn't fit the question, I would have liked to write that as a comment, but comments are limited to a certain length, so you get it as an answer)

I'm currently almost finished getting a degree, and reading books was a very unimportant part of my studies. There are some books I might recommend, but they are not specific to someone without degree, since most people who have a degree don't know the bookt eiter I didn't read them beacause they were recommended or needed for the curse, I read them because they sounded fun to me. It's the same books that are recommended all over stackoverflow.com, not just here. Most of the times, Books on Algorithm Complexity doesn't sound like a lot of fun, but if some day it does, then you know it's the right time to read them.

Before the degree, I was a bit like you: I knew something like 8 programming languages, had several years of experience (in fact, I started programming BASIC as a 6 year old kid), and considered myself pretty much advanced. Why not just enter the business? (so here's th difference, I had no real working experience then, you have it).

For some reason, I did start to study, and I learned so much that I wouldn't have learned else. For example, I thought I'd have understood what OOP and inheritance are for. Now I know, that I knew about 10% of what I should know about OOP, and I guess now I know 70% - and I assume this is much more than the average programmer knows. I know people who make a living by OOP programming for 10 years now and still are stuck at the 10% level.

Know I think I understand why programmers without degree are paid less - they might be as good or even better as those with a degree, but without further verification, it's reasonable to assume that they are not. Let me tell you that some years ago I really hated this opinion, now I share it. It's not because they were telling us all day long at the university (they never did), it's some kind of snootiness that came to me naturally.

Last note: At universtiy, it wasn't the books, and it wasn't the curses that tought me much. The main source of knowledge was working on projects, sometimes alone, sometimes in groups. Now you might say, you do this all day long at work, so work would be the perfect environment to learn. But commercial work has other dynamics and rules, generally less suited to learn.

htdp.org and scip.org

google for tutorials on Scala or SML to learn structural pattern matching.

I think Code Complete and alike are a bit too high level. What one needs is a good mathematical and algorithmical base, so...

a) Calculus and linear algebra stuff (if you haven't taken classes on that in HS).

b) Knuth, at least some of it.

c) Cormen: Introduction to Algorithms.

d) Structure and Interpretation of Computer Programs

Of course, anyone can go out there and code in Java or even C: it's not as complex as many would like it to be, I bet my grandmother can pick up pointers easily. What they might not be able to do though, is create an algorithm that doesn't suck or think through a complex system and that's why you need to expand your mind by yourself or with a good CS program.

Some intro book on algorithms (with mathematical analyisis concepts).

Science Fiction. :)

And that's not a slam. I don't have a degree either. I just like Science Fiction.

Code Complete, Algorithms by Vazairani ^[1], Also by skiena ^[2]

Lots of good answers...

From the perspective of a self-taught programmer, I would rather have the degree. I am fortunate to work at a company right now that does not consider a degree to be the definition of a capable programmer. We have a very small development team - but I do not currently hold a developer position. However, because I showcased some skills, I was given the opportunity to write a couple of small utilities.

This is a much more difficult trek than it otherwise could be. I have to work harder to prove my abilities day after day. Sometimes, I get frustrated because I don't have the degree to back me up.

There is a point to getting your degree that goes beyond the major. If your intention is to go to a university to attain a CS degree, you will be learning a lot more than just programming: algorithms, calculus, statistics, analysis, management, team development...so many areas. Going to college/university is a lot more than just getting a degree that says you can write code.

In short, your question cannot be completely answered with a short list of a few books. Select some of the recommended titles, but keep expanding your comfort zones. Force yourself to at least take some courses at a community college on subjects other than CS/programming. Read books on management, team development. You will find ways that these books actually help you out quite a bit in your professional career. These things have helped me tremendously in continuing to learn.

Given your current level of programming experience, you will be wasting your time reading any purely academic books unless you are planning to pursue a degree. And if that is the case, I would only focus on the books required for each course.

I don't personally know a single programmer that has once referred to a purely academic book to help solve a real-world problem. Outside of gaining some practical experience with pointers and data structures in C and a general understanding of Big-O notation, my CS education has done very little to advance my career other than allowing me to truthfully promote the degree on my resume. Programming skills are practiced, not researched.

As far as the degree is concerned, I would recommend you pursue one as soon as possible for one reason - money. Unless the two companies you've worked for are philanthropic, I can all but guarantee that you are making less money than your co-workers who have degrees, even though you may be the more skilled programmer. Further, I would strongly suggest that you pursue a degree that has "Engineering" in its name instead of "Science." A Computer Engineering degree, from my experience, carries much more weight and is more flexible (with a heftier salary) than a Computer Science degree.

The recommendations so fair look pretty good to me the only thing I would add is that I found books like Effective Java ^[1]

which offer a lot of advice on the best practices for a given language really useful

General Tales of Ordinary Madness by Charles Bukowski. My favorite by far