I am actually going to try to be helpful, in stark contrast to the rest of the comments. You actually want to learn two things C++ and the C++ STL, because the STL is the way to actually get work done with C++ these days.

The vast majority of my college classes were in C++, so I have read several computer science textbooks aimed at C++. The least bad of all the ones I have personally used was Understanding Program Design and Data Structures with C++ by Lambert and Naps. It is the textbook that My Introduction to Computer Science I class used back in the day. It is a serviceable into to computer science book; if you new to computer science it isn't too bad, if you are familiar with comp sci then the book should all be trivial but a good way to learn the language. It is kind of old but the basics of computer science haven't really changed since the 1970's anyway so it doesn't matter [Amazon link]. Lambert and Naps seems to have a newer C++ book out, I don't know anything about it; if it is a newer edition or a different approach or what [Amazon link]. The nice thing about the older one is I can vouch that it is okay, and you can get it really cheap used through Amazon.

Bjarne Stroustroup is the original creator of C++. His book, The C++ Programming Language, is a very good and very thorough overview of the language. Be warned though, it reads like a dense college textbook, mostly because it is a dense college textbook [Amazon link].

The other really essential one is The C++ Standard Template Library by Plauger. Stepanov, et al.; Stepanov is the creator of the STL [Amazon link].

My favorite STL book is actually The C++ Standard Template Library: A Tutorial and Referenceby Josuttis. It is a lot more readable [Amazon link].

Remember, the STL is there to be used, and it hasn't sucked since the late 90's, so don't go around making your own string classes and stack classes, except when you are playing around to learn C++.

Also the Boost libraries are really good now too, but it didn't really exist when I was doing C++, so I don't have any idea what is a good book for that.

Good luck! I just gave you about a year's worth of reading material, but at the end you will be a well-qualified C++ newbie.

You need to show that you know your stuff. Just because you're doing something more applied like Network Security in grad school doesn't mean that you won't have a base level of knowledge you're expected to understand. In that case, you need to learn some basic stuff a CS student at a good school would know. I'm not "dumbing down" anything on my list here, so if it seems hard, don't get discouraged. I'm just trying to cut the bullshit and help you. (:

• Redo your introduction to Computer Science. If you finish this, picking up a new language is cake.
  
  
• Discrete Mathematics, A.K.A. "Math for Computer Scientists" This is the standard text for this, but this is pretty good for a cheap book.
  
  
• Algorithms
  
  
• Compilers
  
  
• Operating Systems
  
  
• Networking
  
  
• For basic CS theory, "Introduction to Theory of Computation by Michael Sipser" is what I used to recommend, but Amazon doesn't seem to have a sanely priced copy. Either buy that used, or get the classic "Cinderella Book". Get an older edition if you can!
  
  Again, don't be discouraged, but you'll need to work hard to catch up. If you were trying for something like mathematics or physics while doing this, I'd call you batshit insane. You may be able to pull it off with CS though (at least for what you want to study). Make no mistake: getting through all these books I posted on your own is hard. Even if you do, it might be the case that still no one will admit you! But if you do it, and you can retain and flaunt your knowledge to a sympathetic professor, you might be surprised.
  
  Best of luck, and post if you need more clarification. As a side note, follow along here as well.
  
  Netsec people feel free to give suggestions as well.

> After all if javascript is a language like PHP and built into the web browser it should be exactly the same everywhere. Shouldn't it?

Python, IronPython, Jython and Stackless Python are all different implementations of the same "Python" language, yet they're all subtly different. g++ and Visual C++ are two different of the same "C++" language, and yet they're both subtly to completely different in the subsets of the language they're able to handle, and the way they implement it.

So no, there is no reason that it should "be exactly the same everywhere" because there is no single Javascript implementation for everyone to use. And yet it does manage to be mostly the same everywhere...

> Standards don't apply

They actually do, "Javascript" itself, as a standard, is mostly well implemented across browsers (the only quirk I could list being the whole Date.getYear fuckup). The area where various implementations start differing is the DOM, which is not Javascript-the-language but Client-side-javascript-platform.

> Mochakit

MochiKit, please.

And it's not really a framework, much more of a javascript library.

> Rest assured Mozilla will soon create its own framework or library and make things "better"

Why the hell would they do that when they can improve the language itself (as far as they're concerned)? See Javascript 1.6, Javascript 1.7, Javascript 2.0

> Hard to find good books and documentation

Only when you don't know where to look.

Beginner? HowToCreate's JS Tutorial (http://www.howtocreate.co.uk/tutorials/javascript/important) is one of the best resource to get up-to-speed with the basics

Beginner or designer? Go for Jeremy Keith's "DOM Scripting" (http://www.amazon.com/DOM-Scripting-Design-JavaScript-Document/dp/1590595335/ref=pd_bxgy_b_img_b/102-8282999-1322522?ie=UTF8), clear book, not too advanced or clean javascript but more than enough to get things done.

Want some more? PPK's "PPK on Javascript" (http://www.amazon.com/ppk-JavaScript-1-Peter-Paul-Koch/dp/0321423305/sr=8-1/qid=1161173272/ref=pd_bbs_sr_1/104-4964908-7079955?ie=UTF8) is reliable AND practical, plus PPK's WebSite, QuirksMode (http://www.quirksmode.org/) is one of the most practical "advanced javascript" resources one can find, especially on the DOM issues. Could've been more advanced, but PPK wanted it to be an intermediate-level book, not a guru-level one.

You want to know everything there is to know about JS, or are a language lawyer? Javascript: The Definitive Guide 5th Edition (http://www.amazon.com/gp/product/0596101996/ref=pd_cp_b_title/102-8282999-1322522?ie=UTF8) is the ultimate Javascript book & reference. Everything you may need from scoping rules to interfaces to SVG and E4X is in there.

> The community is your only hope

Only a subset of the community is really useful, and most of it already has blogs. Most of the community, on the other hand, is completely and utterly clueless.

Above all, what one must realize to work with javascript is that javascript is not a "sub-language", a "toy" or a "scripting language", it's a full-fledged, dynamically weakly typed programming language.

And it's not java.

The problem with ANSI CL is that I could never shake the feeling that Graham wants Lisp in general to maintain some mystique as language only suited for the very clever, and he teaches the language with intent on keeping it that way. I really enjoyed PCL, but I really do think that Paradigms of Artificial Intelligence Programming needs to get more attention. Granted that I haven't yet finished the mammoth volume, Norvig introduces the language in a clear way that makes it seem more natural (perfect example is that he prefers 'first' and 'rest' rather than the more esoteric 'car' 'cdr'), but additionally he has great 'hand holding' examples that show exactly what makes Common Lisp so powerful and how to organize largers programs in language as well as going over a ton of interesting CS related things. Having gone through these 3 books while I was learn I can definitely say that each had a lot to offer, but I think if I was trapped on an island with just one I would definitley take PAIP.

I think posting material like this with no context is silly, but I upvoted this anyway because I recommend these books often. The Introduction is very short and explains better than I could here why the books were written. The quality of the chapters vary, but they are mostly all worth reading. I'm excited for the upcoming The Performance of Open Source Applications, although I haven't heard any news about its progress in a long while.

One of the editors, Greg Wilson, did some research into how we can be effective programmers. Basically, continuing the research that books like Code Complete were based on. He wrote an excellent book Making Software: What Really Works, and Why We Believe It. He is also involved with the community blog It Will Never Work in Theory, which is tag-lined as software development research that is relevant in practice.

I don't have any experience with Clay and have a vested interest in D, so take the following with a grain of salt.

Here are my impressions on Clay vs D2 after having read the brief docs on the wiki:

• Clay seems to have no take on concurrency whatsoever. In fact even googling for Clay concurrency is quite difficult. D2 tackles concurrency issues directly with a no-default-sharing model.
  
• I like Clay's syntax desugaring (what I call "lowering"), but it assigned a name for each operator, which I believe is adverse to generic programming. D2 lowers operators by passing the operator as a compile-time string into the function, which enables further generic processing.
  
• Clay's iterators and coordinates seem to be similar to D's ranges. I'm unclear from the documentation provided about the pervasiveness of related entities and idioms in Clay. D2's ranges turned out to be wildly successful. Both use compile-time introspection to assess membership of a type to a concept. For example, in Clay you assess the presence of a member "size" like this:
  
  [S] SizedSequence?(static S) = Sequence?(S) and CallDefined?(size, S);
  
  whereas you do the same thing in D like this:
  
  template hasLength(R) {
  enum hasLength = isInputRange!R && is(typeof(R.init.length) == size_t);
  }
  
  I don't know how to enforce in Clay that the type of "size" is size_t; I'm sure there must be a way. And indeed the Clay version is shorter.
  
  
• Clay mentions multiple dispatch as a major feature. Based on extensive experience in the topic I believe that that's a waste of time. Modern C++ Design has an extensive chapter on multiple dispatch, and I can vouch next to nobody uses it in the real world. Sure, it's nice to have, but its actual applicability is limited to shape collision testing and a few toy examples.
  
• The docs offer very little on Clay's module system (which is rock solid in D2). The use of an antipattern in Clay's docs worries me though:
  
  import myownlib.test.*;
  
  
• Both languages seem to pay attention to linking with C and assembling applications out of separate modules.
  
• D2 is aggressively geared towards allowing its users to write correct code. Clay seems to have nothing else to say beyond a run-of-the-mill exception model.
  
• Clay lacks object-oriented programming support, although it does offer a number of palliatives (discriminated unions, for which D2 has powerful library offerings). This design choice seems odd to me because I believe straight OOP is much more important than supporting the obscure multiple dispatch.
  
  Overall Clay's current offering (judging only by the docs) is very scarce compared to D2's. I found nothing in Clay that's sorely missing in D2, and conversely there's plenty in D2 that I'd sorely miss in Clay.
  
  Clay looks a lot like the toy language I was working on before deciding to build on D: long on hope, short on bread and butter. In hindsight, I am happy with the decision to start with a language (D1) in which I could take for granted a lot of stuff.

To date, the best programming book that I've read is C Programming Language by K&R. It's a pretty complete text on the C language. It is more than sufficient to enable the reader to be a good C programmer, yet it is still entirely digestable by new programmers. It is 274 pages. There are some recent gems, like Programming Clojure (304 pages). However, these days the norm seems to be more like Applying Domain-Driven Design and Patterns: With Examples in C# and .NET (576 pages), Real World Haskell (710 pages), and The C++ Programming Language (1030 pages). These books are all good. They just are hard to carry around and hard to hold while reading for long periods. I'm looking for good programming books that are short; an upper limit of roughly 325 pages. Post links to your favorites!

Are you confusing dynamic typing with weak typing?

> That being the case, I find defining the available types explicitly

You do that with dynamic typing. Dynamic typing is not the absence of type... it's late binding.

> But you refer to this as imposing unnecessary clutter, which seems odd to me.

It's the explicit formalizations that are required by static typing that imposes clutter, not the typing itself.

> I hardly ever use reflection.

I use reflection all the time and it helps be reduce the amount of code by at least a factor of 2. In many cases, this factor is larger (3x to 5x) (Note: these factors apply to sections of code and not the whole application).

Here's an example from about 12 years ago. I was head developer on an application written in java (the first ever java application deployed according to Sun and IBM). We had to use AWT (which has it's own problems) and I became increasingly frustrated with their use of the observer pattern (listeners). The problem was too much formalism. I had to define listeners which could only respond to one message (actionPerformed). Then, I had to map this message to the real message... the one relevant to the problem. (For example, when an "ok" button is pressed, the action relevant to the application logic is "ok" and not "action performed". When you start building complex interfaces, the need to map between the conceptual space that is implemented by the model and the interface can add considerable needless complexity).

My solution was to use reflection. Even an implementation of reflection as poor as that in java was enough to remove huge swaths of code from the application. I created gui components that allowed the registration of listeners, but the registration component included not only the reference to the listener but also the name of the method that should be invoked against the listener. This method was invoked reflectively. Our application was about 125,000 lines of code and this change removed about 15,000 lines. (BTW... this design was not mine. I had previously worked with NeXTSTEP and Objective-C. I simply emulated the design I had seen employed there).

The change was significant. Not only did it remove a lot of code, but it significantly reduced the complexity of building GUIs. The complexity imposed by the static typing added no benefit to the application... its use served only to increase the complexity of the solution which made the application harder to code, longer to code and more difficult to change and fix.

> Perhaps our mindsets are different here, and you prefer to work more intuitively for longer, hence preferring a tool that better supports that approach?

In the example I gave above, the use of reflection significantly reduced the amount of code that was required. To me, this is a win regardless of one's analytic preferences. I see this effect whenever I employ the use of dynamic typing to a project.

The one thing to remember is that dynamic typing is a tool. It can be used well or badly, just as static typing can be used well or badly. It's necessary to take a disciplined approach when it is applied.

If you're interested, I highly recommend The Art of the Metaobject Protocol

from the same author

This is an incomplete list of arguments in favor of immutability:

[...]
their usage is side-effect free (no defensive copies)
[...]

and

How can an immutable object represent a mutable entity? Look at an immutable class, File, and its methods, for example length() and delete().

well yeah, an immutable object can represent a mutable entity through side effect, great!

He seems to have built a whole framework of thinking through idiosyncrasies and he gets to conflate in ugly ways the benefits of immutability on values and referential transparency on functions (well methods because java model of oop).

For instance he claims that

truly immutable objects are always thread-safe

This means that multiple threads can access the same object at the same time, without clashing with another thread.

Which is true if you consider objects as bag of values with side-effect free referentially transparent methods, however he calls these "constant" objects as a subgroup of immutable objects. And no, once you have side-effectful methods in the mix, thread-safety gets the boot.

I have to say that the ill defined concept of OOP is prone to this.

I would recommend him this excellent no-nonsense book:

http://www.amazon.com/Concepts-Techniques-Models-Computer-Programming/dp/0262220695

For iOS devices, you're going to want to start here, this will get you familiarized with the NeXtStep family of jive turkeys, followed up with a more formal introduction to Objective-C. I'll be honest, having some working knowledge of C will never hurt you, so after you're done with that, take a peek at K&R.

If you're aiming for Android, you have a bit of a different education outlook, I'd recommend brushing up with Head First Java. When I started poking around with Android, I read Hello, Android most of it should be still pretty relevant. I'm not entirely sure if it has been updated as of late, I outgrew it rather quickly, and if you do too; pretty much anything and everything by Mark Murphy is relevant. Best of luck!

Well, meta-think about this: a "strong AI" like ourselves might seem mysterious, but consider the fact that our brains are really just nueral nets, which can be mathematically approximated. The process of learning and thinking, in the neurological sense, is really nothing a blind search of your cells for optimal solutions. Using a fairly simple set of rules (See Conway's Game), complicated, intelligent behavior emerges. So I'm not really sure what you mean, but I'm guessing you're implying that intelligence cannot be designed, it must emerge. And don't forget that a method of discovering algorithms, is itself, still "just an algorithm!" Cornell's Eureqa project can do this, to a degree. I think my most important point is this: Intelligence is different between individuals and even animals. Don't judge machine intelligence by it's resemblance to the human mind. Both are machines but they process data in profoundly different ways.

PS http://www.amazon.com/G%C3%B6del-Escher-Bach-Eternal-Golden/dp/0465026567

First of all, for any software development questions you may have, I suggest you post your questions on Stackoverflow because the people there will surely provide you with answers.

Now, for a list of books I recommend:

JavaScript

JavaScript: The Definitive Guide; if you're new to JS, start with this one.

JavaScript: The Good Parts; not a beginner's book, but a must-read if you are going to use JS

If you are going to be using JS, you will most probably be developing using a framework, and for that I seriously recommend mastering jQuery because as they say, you will write less and do more!

CSS

CSS Mastery: Advanced Web Standards Solutions

Web Usability

Don't Make Me Think: A Common Sense Approach to Web Usability; the book that shows the users' perspective when viewing a website

Performance

High Performance Web Sites: Essential Knowledge for Front-End Engineers and Even Faster Web Sites: Performance Best Practices for Web Developers;if you want to get serious about performance for your websites

> Yet, from reading books/tutorials/examples

First, be mindful of the limitations of the various teaching media and how difficult it is to teach something like design, TDD or otherwise, in small snippets. In fact, that's what I got out of the OP: design is a skill, TDD is a tool.

Second, I'm curious - which particular books are you referring to?

The books that most resonated with me are:

1. Growing Object Oriented Software Guided by Tests by Nat Pryce and Steve Freeman.
   
2. Agile Principles, Patterns and Practices by Uncle Bob - which has really little to with Agile, but anyways...
   
3. Domain Driven Design by Eric Evans.
   
   These books devote substantial time putting the practices in context.
   
   The PPP book did a great job discussing design in general, and showed how to apply the design principles using TDD and showed me a way to use UML without hating it.
   
   The GOOS book carefully works a single case study, starting with a basic architecture in mind and showing how to grow the architecture in that direction guided by tests.

There's definitely a steep learning curve to get to the mindset of being productive with it. I really enjoy Norvig's "Case Studies" book. I feel like you're right in some ways though... LISP is supposed to be able to be extended even in a language sense but it is just not that intuitive to do it. I have heard interesting things about Perl 6 in this regard but I haven't had time to play with that yet... maybe when i finally completely finish school :)

You seem to be mixing a lot of stuff here.

In no particular order:

• I'm pretty sure Java is far more used for the server-side of web (or intranet) applications than for desktop apps.
  
  
• IIRC, you can use C# for desktop apps, and for both sides of web apps (client with Silverlight, and server).
  
  
• Assembly is not a language. ARM-assembly and x86-assembly are two different languages, since the two architectures are so different.
  
  
• If you really want to learn C++ (I won't comment on that choice), buy Accelerated C++. There are lots of other resources for beginners, but pretty much all of them are either bad or abysmal.
  Stroustrup's latest book might be good, but I haven't had a look at it, and I'm not very motivated for reading 1272 pages of Stroustrup's prose.
  
  
• "Fairly competent Web programmer": you do understand all the basics of the Javascript language, right? Likewise, you probably know Python well, so if you want to make desktop apps, Qt-Python bindings might be a good start.
  
  
  
  

The other major website on this subject is the Aggregate Magic Algorithms.

You can also find some interesting hacks at the Chess Programming site bitboards.

The magnificent book Hacker's Delight is the Knuth of bits. It's actually better than Knuth on this subject! (At the end of 50 pages of bitwise stuff in Volume 4, DEK basically says "read Hacker's Delight for the real deal.")

Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp by Norvig (PAIP)

I don't want to overhype, but it's been called "The best book on programming ever written".

Oops, maybe I overshot. But anyway, very enlightening even if you're not a Lisp or AI programmer.

One option is to follow the techniques explained in the book Growing Object-Oriented Software, Guided By Tests. They use Test-Driven Development as their design technique, but they don't start from the bottom up and leave integration testing to the end. They start with the "walking skeleton" concept from Crystal Clear: A Human-Powered Methodology for Small Teams, an implementation of the thinnest possible slice of real functionality that you can automatically build, deploy and test end-to-end. They then start a TDD cycle by writing a failing acceptance test for one feature and, in the process of making that acceptance test pass, they will write a failing unit test, make it pass, and refactor and they will repeat this process until the acceptance test for the feature passes. The will then write the acceptance test for the next feature and go through the same process again until all features have been developed.

Besides the book itself, there is a short tutorial I was reading yesterday called Three Steps to a Useful Minimal Feature which describes how to write a "walking skeleton" using a simple "Pay a Bill" scenario.

>So what did you do? Anyone else have a formal CS education and feel like they came out of it with nothing?

I graduated in 2006 and I've been doing web development professionally for almost four years now. Until about two weeks ago, I felt like I could have skipped my entire five years at school because most of the stuff just doesn't apply to web development since it's so far abstracted from the hardware. I was reading my algorithms book on the toilet the other day when I realized that I learned a shitton at school and it gave me an incredible advantage over the guy who learned web development on the fly. It helps to go back and re-read things after you have a context to put it into so you can apply what the theory to what you've learned.

It took me a long time to start getting designs down. You have to make a lot of mistakes before you can learn from them. It's as simple as that. Don't get discouraged. If you haven't read Head First Design Patterns, buy that book right now and read it cover to cover. I had read design pattern catalogs, but none of them conveyed the 'why' as well as HFDP did. They don't have abstract, car has wheels, Ford is a car. They have real code examples and they show you why you should favor composition rather than inheritance. Why you should follow the law of Demeter.

I've entertained the notion of starting over several times. Don't quit, and don't get discouraged. If you ever get to the point where you think you've learned all you need to learn and you're writing code that can't be improved, start over.

It depends exactly what you're looking for, but I'd strongly recommend The Algorithm Design Manual by Skiena ( http://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena/dp/1848000693/ref=sr_1_1?ie=UTF8&s=books&qid=1261657117&sr=1-1-spell ).

It focuses much more on intuitive explanations rather than spending time on proofs, is very readable and has a solid reference section covering over a hundred different algorithms with further references. See Steve Yegge's writeup of the book at http://steve.yegge.googlepages.com/ten-great-books (number 6).

Cormen et al. is good as well, but a bit dry compared to the above book, and with a much heavier focus on the proof side of things.

By chance, I was reading yesterday the introduction of http://www.amazon.com/Accelerated-C-Practical-Programming-Example/dp/020170353X - what I like in that style, is that you see some code, have it in your mind, and get a discussion of concepts based on that example. Writing about programming is very difficult (as I experience myself), but I start liking the idea, that actual code examples early help the reader to get a better feeling what is going on.

First, be prepared to write code that sucks and is unmaintainable for a while. (This could be months or years.)

If you only know Java, then you'll need some C concepts. In particular, you need to become familiar with pointer arithmetic, avoiding buffer overruns, and manual memory management. (C++ has ways (RAII) to make manual memory management less error-prone, but you still need to understand what's going on.)

To learn the basics of the language, read The C++ Programming Language, Special Edition, by Bjarne Stroustrup.

Read a lot of things by Herb Sutter and Andrei Alexandrescu. I particularly recommend Modern C++ Design and Exceptional C++; I'm sure others in this thread can give you some good suggestions.

Finally, start writing code, and get it critically reviewed by someone who really knows C++. (I've known 2 or 3 such people in my career; they exist but are the exception, not the rule. Look for people who can explain all the things I listed, and more.)

(Edited to add The C++ Programming Language.)

Nice. My plan is to buy them all once they're done; they should make a great trophy to have on my bookshelf for life.

I've been reading The Lifebox by Rudy Rucker over break. I'm about a third of the way in and I'm liking it so far. I've already had many of the epiphanies he's trying to install, coming off of reading Hofstadter's GEB over the summer. So far, I consider GEB the superior book, but I appreciate the narrower focus of The Lifebox (Rucker stays strictly on the topic of Computer Science with some very elementary explanations of some advanced physics concepts). The section on molecular biology in the middle of GEB read at a snail's pace for me.

And that is exactly why I recommend reading these books to people. Information online can often be misleading, wrong, old, or all of the above, at least in a book which is praised by so many people, you know that the info which you are getting is top value. I know that learing C++ can be a bit difficult, but remember that you do not need to know all of it at once (heck - nobody knows all of C++, and even Template Metaprogramming was kind of discovered by accident ). I hear that Accelerated C++ is a good book to start from if you already know some programming in another language. C++ Primer Plus is huge, but also good.

I haven't seen this suggested, but it is a good book on exactly that topic.

Clean Code by Robert Martin.

and I have to mention...

Growing Object-Oriented Software, Guided by Tests by Steve Freeman and Yours Truly, which frequently touches on that topic

I would very much recommend http://www.amazon.com/Black-Video-Game-Console-Design/dp/0672328208 ; it goes really far in explaining everything from quantum level up to a working game console. And after that; http://www.amazon.com/Operating-Systems-Design-Implementation-3rd/dp/0131429388/ref=sr_1_1?s=books&ie=UTF8&qid=1405346881&sr=1-1&keywords=minix . Then you'll be set.

Edit; Although the Black art is about game consoles; if you work through it, you can build your own computer in the end, or, what I really like, you can pick up old machines (80s/begin 90s) from Ebay for < $5, open them up , understand them and change them. As they are not 'one chip' with some power supply stuff, but almost everything is held in separate ICs, so you can follow the PCB and see actually what it is doing and how. Great fun. And it scales, as I have no issue making digital things with FGPA's etc because I know it at this level.

I realise this isn't free but Growing Object Oriented Software Guided by Tests is the best book on testing and OOP that I've ever read. I highly, highly recommend it.

1. If you think that C++ isn't harder to learn than C, then you don't really know C++. Read Modern C++ Design, and a few dozen pages of the C++ FAQ, and if your head doesn't explode, tell me again that C++ isn't harder to really learn than C.
   
2. I know the Linus article. I know he's competent. But I still don't agree; I think he's so steeped in his kernel code world that he doesn't see the advantages, at least for application software.
   
3. Anyone who writes code in C++ but who doesn't know pointers, can't concat strings, etc., is someone who also really doesn't know C++.
   
   Someone who doesn't really know C++ can do things in C++ and be productive, but keep them away from writing templates, macros, and/or doing anything with pointers. The right library can protect amateurs from shooting themselves in the foot, at least too often; that's why people talk about using a "subset of the language."
   
   I'm a game developer. It's still the case that most serious game developers demand C++, and for good reason.
   
   For reference: I've interviewed dozens of developers applying for a C++ game development job. Most rate themselves 9 to 10/10 in C++, and yet most also choke when I start asking them even slightly interesting questions about the language. Not even the standard (or any other) libraries -- just about the core language. This is all stuff I know like the back of my hand -- and I know that there are things in C++ that I couldn't just get right the first time (see Modern C++ Design for a few examples).

Taking a lot of care with regard to what needs to be included where can help. In some cases, you can just give a forward declaration of a class rather than including a header for it if you are just shuffling pointers to it around. In other cases, you can migrate a lot of implementation details using a 'PIMPL' style so only the public facing API is in the headers that get included. Make sure one header doesn't need to include a chain of 100 other headers for dependencies. Be careful with template stuff. Avoid putting templates in headers such that they wind up being recompiled in every source file. You can do explicit template instantiation for the specific types that you need, and you'll only have to compile them once. Divide the project into several small dynamic libraries, so you only have to build one lib at a time instead of the whole project.

I've heard good things about this book, but my build times aren't yet slow enough to give me time to read it. :) http://www.amazon.com/Large-Scale-Software-Design-John-Lakos/dp/0201633620

Thank you all for your responses! I have compiled a list of books mentioned by at least three different people below. Since some books have abbreviations (SICP) or colloquial names (Dragon Book), not to mention the occasional omission of a starting "a" or "the" this was done by hand and as a result it may contain errors.

edit: This list is now books mentioned by at least three people (was two) and contains posts up to icepack's.

edit: Updated with links to Amazon.com. These are not affiliate - Amazon was picked because they provide the most uniform way to compare books.

edit: Updated up to redline6561

• 14 The C Programming Language
  
• 11 Structure and Interpretation of Computer Programs
  
• 8 Introduction to Algorithms
  
• 7 Compilers: Principles, Techniques and Tools
  
• 6 Programming Erlang
  
• 5 The Mythical Man-Month
  
• 5 The Pragmatic Programmer
  
• 5 Applied Cryptography
  
• 4 Beautiful Code
  
• 4 The Little Schemer
  
• 4 Programming Perl
  
• 3 Types and Programming Languages
  
• 3 Gödel, Escher, Bach
  
• 3 OpenGL Programming Guide
  
• 3 Code Complete
  
• 3 Artificial Intelligence: A Modern Approach
  
• 3 Programming Pearls
  
• 3 ANSI Common Lisp
  
• 3 A Brief History of Time
  
• 3 Agile Web Development with Rails
  
• 3 Concrete Mathematics: A Foundation for Computer Science
  
• 3 Modern Operating Systems
  
• 3 Paradigms of Artificial Intelligence Programming
  
• 3 Operating System Design and Implementation
  
  

I'd add The Art of the Metaobject Protocol which in a few short pages creates an entire flexible class system and demonstrates how to extend it to do pretty much anything one needs. And it's easy and pleasant to read too.

After you've read it, you'll never again look at problems the same way; it demonstrates that for the sufficiently-clever there's always a way to make the problem solve itself.

Depending on what you're doing and how you're organized, you've got a couple options.

There are, as you've been told in the SO question, a couple commercial solutions. One that wasn't mentioned was ElectricAccelerator, which is also supposed to be a good solution. I believe they have a free/limited trial version these days.

There's also the Team Foundation Server/Build, which is Microsoft's approach to the problem. I've never had cause to use it myself, since it's an all-in on Microsoft tech, which simply isn't tenable for my use-case.

That said, in my experience, a lot of slow builds can be drastically improved simply by organizational changes and good modularity in the code. If your problems are like those I've solved for my current and previous teams, you're likely building your entire stack in a single solution, whether you need to or not. If you can find the pieces that are library-izable and break them out so they're not being built every time, you can get huge gains on the normal day-to-day build times.

I'd highly recommend reading John Lakos's book Large Scale C++ Software Design. It's a little dated, but loaded with still-relevant techniques and information.

I've spent a lot of time fixing builds for myself and others, so feel free to ask questions.

Common Lisp remains a touchstone. I highly recommend installing Clozure Common Lisp and Quicklisp and then working through Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp and Artificial Intelligence: A Modern Approach with them. Although I'm now firmly in the statically-typed functional programming world, this has been part of my journey, and it will change how you think about programming.

Hacker's Delight

http://www.amazon.com/gp/product/0201914654/sr=8-1/qid=1144182215/ref=pd_bbs_1/002-3707800-4554451?%5Fencoding=UTF8

is another great resource

The good news is that MIPS is possibly the most straightforward assembly language to code or read. Compared to x86, it's a dream.

If your class is computer architecture related, you will probably be learning from Hennessy and Patterson, which is an excellent book covering hardware and software.

If you want to learn MIPS from a software perspective, check out the classic See MIPS Run.

If you like this kind of stuff, I highly recommend "Hacker's Delight". It's a fantastic book that goes orders of magnitude beyond anything discussed here.

http://www.amazon.com/Hackers-Delight-Henry-S-Warren/dp/0201914654/

That's good research. :)

The edition I was looking at was this one, which is the only hardcover the UK amazon have in stock. Rip off britain strikes again

EDIT: Out of interest, does anyone know how much the authors get from a book this expensive? I'm guessing it's a very small slice of the pie

Not an opposite view, but IMHO definitely worth quoting on this matter:

> If more than 20-25% of a component has to be revised, it's better to rewrite it from scratch. (Thomas et al, 1997)

It's Greg Wilson, author of "Making Software: What Really Works, and Why We Believe It"

An interesting but brief article. I disagree with the premise that compilation is slow, I find it quick even with hundreds or thousands of source files. When optimizing build speed, look to PCH, forward declarations, better organization, and finally interfaces and pimpl if you're really desperate.

I suggest Large-Scale C++ Software Design by Lakos for more information.

Edit: Of course C++ compilation is a lot slower than some languages, but ~5 minutes to rebuild 1000 files is pretty reasonable.

> What would be cool for Magpie would be a Meta-Object Protocal.

I just finished AMOP so that's definitely on my mind. My current plan is to get a solid object/multimethod system working first. Once that's in a happy place, I'll try to start moving bits of it over to Magpie itself and make them more extensible.

At the very least, I want user-defined patterns. That covers a lot of the MOP space since it would let you define your own method matching logic.

I like Skienna; short intro to the theory at the beginning and then it delves into actual algorithms. CLRS is good if you need more theory (e.g. solving recurrences).

Pick up a copy of Accelerated C++. It starts at the very beginning and takes a more modern approach to teaching C++ than a lot of the other books on the market.

It's part of the "C++ in-depth series" that also has a bunch of other great titles like Sutter's Exceptional C++.

I recommend this book for python (It's big and fat and drills it all into your brain through repetition)

The Django and python websites have great documentation as well

this for Javascript (it's a classic)

www.jquery.com has great documentation as well

this for PHP (Rasmus is great)

this for C++ (they say it's outdated but the concepts still apply)

This looks like a very early draft of this book;

http://www.info.ucl.ac.be/~pvr/book.html
http://www.amazon.com/Concepts-Techniques-Models-Computer-Programming/dp/0262220695

This looks like such a nice book, that I will buy it.

Every algorithms textbook I've read starts with a chapter that involves breaking down algorithm runtime into mathematical terms more specific than Big O (for instance, nested for loops turn into nested sums). Then the mathematical terms are simplified as much as possible and you get something like Runtime(n) = n(n-1)/2. Then you apply the definition of Big O to prove that that's O( n^2 ). The concepts and definitions of Big Omega and Big Theta are also usually brought into the mix as well.

If you want a specific book recommendation, I thought Skiena's Algorithm Design Manual was a good read.

My favorite tome:
Concepts, Techniques, and Models of Computer Programming is 930 pages and worth every page, IMO. A lot of it can be read without the other parts too making it more like 5 books in one.

Article doesn't tell you how, it's more like a handful of thoughts on how to do so, without any real data (as the author admits)

>But I think you should take more away than a handful of application-wide metrics. You should take away a preference for statistical and empirical consideration. Figure out how to quantify trends you observe and form hypotheses about how they impact code quality. Then do your best to measure them in terms of outcomes with the application. We lack a laboratory and we lack non-proprietary data, but that doesn’t stop us from taking the lessons of the scientific method and applying them as best we can.

Someone has already done this. Read chapters 8, 9, and 23 of Oram and Wilson's Making Software

Basic:

C++ Primer

Effective C++

Effective STL





Advanced:

More Effective C++

C++ Coding Standards: 101 Rules

C++ Templates The Complete Guide

Large Scale C++ Design

Just go for the "Head First Design Patterns" (the gang of of four one is good but very arid and I would not recommend it as a first book). The "Head First" series is very user friendly.

Sure :)
EDIT: Added links to Amazon just in case anyone wants to see reviews.


[$1 Or More Tier]
Head First Ruby
Head First C
Head First Object-Oriented Analysis and Design
Head First SQL
Head First Statistics


[$8 Or More Tier]
Head First Javascript Programming
Head First PMP
Head First HMTL and CSS
Head First C#
Head First Agile


[$15 Or More Tier]
Head First Design Patterns
Head First Java
Head First Python
Head First Learn to Code
Head First Android Development

I like Operating Systems: Design and Implementation. It walks through the MINIX3 micro kernel. It is not a tutorial or a step by step guide, but I think it gives a very nice foundation of what it takes to make a functioning kernel.

Do you count SICP in favour of "books" or in favour of the internet?

Also and irrelevantly, "found from" sounds quite jarring to my admittedly non-native ears.

This reads pretty much exactly like Hacker's Delight except that the book focuses on the assembly behind this instead of the C code in front.

If you want to learn about OS, check out MINIX. It's a UNIX-compatible OS specifically written for educational purposes. What makes it really great is that there's a book, Operating Systems: Design and Implementation, which describes the OS in detail and comes with the annotated source.

Actually C++ does this as well, it's just better hidden from the user.

This is the issue with perl5 "OO". It may have the potential to be the same as C++ or Python or whatever, but the packaging is non-existent. You must do everything yourself. Manually. I suppose that's ok if you want to learn how OO actually works (though personally I would recommend going with The Art of the Metaobject Protocol).

Python does expose the fact that the "this" argument is passed to the function which is, as you stated, a mistake. But at least everything else has pretty decent packaging.

There is a book that explores the programming language paradigms pretty well: CTM.

The book, as expected, is a massive tome at 930 pages.

Head First Design Patterns (2004) (homepage | amazon) was comparatively friendly and well regarded.

I'd recommend Minix; in particular, version 2. Not only is the kernel quite small, there's also a book that walks you through its internal workings in detail, and a newsgroup to go to for help or questions.

I found Operating Systems - Design and Implementation (3rd Edition) a surprisingly good read.

Concrete Mathematics by Graham, Knuth and Patashnik is a great start to almost all of those topics.

Awesome design patterns book Head First Design Patterns

[Edit] The patterns are expressed in Java

Javascript: The Definitive Guide
is a great book concerning Javascript FWIW

>Start at the bottom. Some books I liked...
>
>Learn what a computer does: Computer Organization & design - Patterson & Hennessy
>
>Learn C: Programming in C - Stephen Kochan
>
>VERY IMPORTANT learn your data structures: Introduction to Algorithms
>
>You will have learn Java in university, I found this book good: Absolute Java 4th ed.
>
>This is just scratching the surface, a lot more to learn afterword.

Don't worry, FTFH

Really? I see it on Amazon.com for $70.85, which is less than what I payed for it a while back ($75).

Make sure you are looking at this one and not this one

EDIT: I always wondered what the difference between those two was, and this discussion on Amazon answered that question.

Concepts, Techniques, and Models of Computer Programming. If the language doesn't matter you get an overview of most language concepts and more importantly concurrent programming concepts. More or less every design I ever saw were using mutable shared state, loaded with zillions of fain grained locks.

Yes, every header file should include all other headers that it needs otherwise you will have a nightmare keeping track of include order dependencies. In order to speed up compile times you will want to put include guard ifdefs around the #include directive, not just inside.

So:

foo.h:

ifndef _FOO_H

    #define _FOO_H<br />

ifndef _BAR_H

    #include &amp;lt;bar.h&amp;gt;<br />
    #endif<br />

...

endif

bar.h:

ifndef _BAR_H

    #define _BAR_H<br />
    ...<br />
    #endif<br />

IIRC this is as recommended in Lakos' book: http://www.amazon.com/Large-Scale-Software-Design-John-Lakos/dp/0201633620

I really enjoyed Concrete Mathematics by Graham, Knuth, & Patashnik

Since you're fuzzy on the whole "Turing Complete" concept, I wouldn't start at the toy app level. The best place for you is probably The Little Schemer with javascript transformations from http://javascript.crockford.com/little.html applied (Unless you want to get yourself an actual Scheme implementation, which would be fantastic). Also, if you work through both that, and "Structure and Interpretation of Computer Programs," you'll have super-high nerd cred.

Do you have any previous programming experience? Are you just looking to learn the core Objective-C language or do you mean the Mac OS X Cocoa framework too?

If you're coming from C++ check out this PDF.

Learn Objective-C on the Mac assumes you know some C and it doesn't really touch on the Cocoa framework, it sticks to the command line. I have found it useful.

Programming in Objective-C 2.0 seems to covers Objective-C and Cocoa and the reviews look good, but I haven't read it.

I've heard very good things about JavaScript: The Good Parts, but have not used it myself. I have gotten a lot of mileage out of JavaScript: The Definitive Guide... it's quite thorough.

Just learn Objective-C. You'll find much more material and examples and it'll be another language you have under your tool belt. It's also the de facto standard for Cocoa development, even if there are Python bindings.

This book is good: http://www.amazon.com/Programming-Objective-C-2-0-Developers-Library/dp/0321566157/ref=sr_1_1?ie=UTF8&s=books&qid=1250177866&sr=8-1

The Haskell School of Expression

This book teaches Haskell through multimedia, some of which is programming music. I own it. It's good.

The Art of the Metaobject Protocol is one of my favourite programming books of all time - the sudden "click" in my head that marked the transition from "What the hell is a MOP anyway?" to "That's such a simple and awesome idea, why doesn't everyone do that?" was the closest I've gotten yet to the fabled "Lisp enlightenment" :)

Look into computer engineering. If you're interested in hardware meets software, you'll explore computer architecture.

See: Computer Architecture Quantitative Approach

and
Computer Organization and Design

Here's a whole book devoted to the topic of never branching.

Operating Systems, Design and Implementation http://www.amazon.com/Operating-Systems-Implementation-Prentice-Software/dp/0131429388/ref=pd_sim_b_5 the book has full examples, and if you wanted the OS printed, is at the end of the Book, also comes with a CD that has the OS compiled and ready to run.

I'd also recommend https://www.amazon.com/Mathematics-Generic-Programming-Alexander-Stepanov/dp/0321942043

https://www.amazon.com/Concrete-Mathematics-Foundation-Computer-Science/dp/0201558025

In your case I can only recommend Large Scale C++ Software Design since the book focuses more on programming in the large than small.

I think the problem is that there are two mutually incompatible teaching requirements here:

1/ Teach nix and C, including fork() and pals

2/ Teach C++ = modern, idiomatic C++ with STL from the outset*, as is generally considered to be the best way.

These are almost entirely separate areas and should be taught separately.

• I wouldn't call it K&R, the examples are toys, and I didn't learn Haskell through it, but The Haskell School of Expression: Learning Functional Programming through Multimedia is great.
  
• I found Real World Haskell, which is probably the standard recommendation, too dirty (and in many cases outdated and relying on packages that wouldn't compile for my platform) to learn the language from in the first place.
  
• I don't think it's out in dead tree yet, but Learn You A Haskell is absolutely the best tutorial out there.
  
  I personally stumbled (and continue stumbling) into Haskell by picking up bits and pieces in academic papers. I don't recommend this route at all.

then yes, you are writing bad code. Good instincts!

read this ... a few times.

A shorter (and better) version of the talk is online at http://software-carpentry.org/4_0/softeng/ebse/. If you want to keep up with the latest in empirical studies of programming, check out http://www.neverworkintheory.org/ (where we're blogging once or twice a week about recent findings), or have a look at our book "Making Software" (http://www.amazon.com/Making-Software-Really-Works-Believe/dp/0596808321) which collects the most important findings, and the evidence behind them.

Well I replied while I was on my phone so I couldn't link it. I followed my directions and was able to find it. It is the first book when you search for Objective C 2.0. It's called Programming in Objective C 2.0 and it's written by Stephan Kochan. Here's the link

I've been meaning to start with something fun - how would you people say I'd fare with this as an introduction into functional programming, assuming I've got no programming background?

I am surprised this book has not been mentioned yet:

http://www.amazon.com/Gödel-Escher-Bach-Eternal-Golden/dp/0465026567/

Check this thread for a reading list. IMO, The Algorithm Design Manual should have made the top too.

I think you just don't understand the logic behind javascript. Maybe the auto-insert semicolon thing is annoying, but if you want to seriously use any language at the expert level you really should read a book about it. I recommend The Definitive Guide if you actually want to improve your skills. Javascript is more complicated than it seems at first. jQuery greatly helps manipulating the DOM if you are sick of browser compatibility issues.

You might check out some books by Hennessy and Patterson, eg,
http://www.amazon.com/Computer-Organization-Design-Fourth-Architecture/dp/0123744938/ref=pd_bbs_sr_2?ie=UTF8&s=books&qid=1228140896&sr=8-2

So far the best books I have read on computers and operating systems. Talks about the same stuff as this article, but with more detail. They're grad level texts, but I didn't have a problem havnig no CS background.

you want hacker's delight

http://www.amazon.com/C-Programming-Language-Special/dp/0201700735

Start at the front, work to the back.

I'd reccomend Accelerated C++

http://www.amazon.com/Accelerated-Practical-Programming-Example-Depth/dp/020170353X/ref=sr_1_1?ie=UTF8&s=books&qid=1240536555&sr=8-1

Andrei Alexandrescu's "Modern C++ Design". It was so mind-expanding and well-written, not to mention useful, I was reading it for 2-3 hours a day until I finished it.

Also relevant: Hackers Delight, (Amazon link)

The goto theory book by Sipser.
Excellent for C programming.
Programming in general.
My favourite.
You can probably find all of these at a library.

http://www.amazon.com/Concepts-Techniques-Models-Computer-Programming/dp/0262220695/

van Roy, CTM of comp programming

http://www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf

Peter Van Roy co-authored Concepts, Techniques, and Models of Computer Programming

The Art of the Metaobject Protocol

Real-life Lisp programming explained.

If you can wait, go along with rattboi's mention of Hillegass's book (it's great!), and get Programming in Objective-C 2.0 (2nd Edition) (Developer's Library) (Paperback) if you can wait a few months.

this book rocks too:

http://www.amazon.com/Godel-Escher-Bach-Eternal-Golden/dp/0465026567/ref=sr_1_1?ie=UTF8&s=books&qid=1266047347&sr=1-1-spell

Have you ever considered reading the SICP book from MIT? You could also try an algorithms book, and brush up on your design patterns.

The book that he takes about that was about to be published is here:

http://www.amazon.com/Making-Software-Really-Works-Believe/dp/0596808321

I thought so too, until I discovered The Algorithm Design Manual.

So, what about CLR(S) warrants a new edition?

The Algorithm Design Manual by Skiena

Read and do the exercises in this book, or go to a class that teaches this book:
[Structure and Interpretation of Computer Programs](
http://www.amazon.com/dp/0262011530?tag=steveysblogra-20&camp=14573&creative=327641&linkCode=as1&creativeASIN=0262011530&adid=1K8T44EK9YN586JPAZMM&)


You will learn that the language is not important but the algorithms are.

Gödel, Escher, Bach: An Eternal Golden Braid

This book is not exactly a programming book... maybe... kinda. It teaches no practical programming language. It explains no useful design patterns. It does not deal with any practical computer applications. And yet had I never would have really gotten into programming had I not read it long ago. Written in the late 70's, it's still relevant today.

> But I've come to avoid mocking as much as possible as tests based
> on mocks don't prove anything, except that my code works under
> the assumptions i made

This isn't really how mocking is supposed to be done. I would recommend reading Growing Object Oriented Software Guided By Tests, written by the authors of JMock, and the people who originally came up mocking as a test practice.

In short, you don't mock external services or anything you don't own. You should mock an interface you created and that you own, that defines the contract that external dependencies must meet to work with your class on your terms (aka, ports and adapters). This is the essence of dependency inversion. Mocks ideally guide development towards DI.

The adapter is concerned with making sure that the external dependency actually conforms to the contract defined by the interface that is mocked, and adapter code must definitely be integration tested. And the integration test now needs only to verify that the adapter meets the terms of the contract. This separates testing the logic of the system (where TDD fits in) from tests of the integration with the external environment (functional and integration tests). However, the authors of the GOOS book recommend writing the user acceptance tests (functional tests) before you write the unit tests (which they lump into TDD, in a more holistic sense).

can't go wrong with K&R C to learn the low level stuff (pointers) first, then The C++ Programming Language to learn the rest

Add Concrete Mathematics if you're a maths retard like me.

I'd like to make an official request that the book cover please not suck. With AIMA and HSoE, my bookshelf is looking decidedly ugly now...

Also off the beaten path:

The Haskell School of Expression

What's really cool is it appies Haskell to multimedia. This helps because it's not hard to compare what the author presents with how you'd approach the same topics using tools you already use.

It stays away from language wars and just focuses on explaining Haskell.

There's a whole section on this problem in Concrete Mathematics. The first edition was published in 1989, and the problem was old then.

>Classes without template parameters are not in a different type system then those with them.

Many people very strongly metaprogram in C++, using templates to make abstract types that bear no resemblance to traditional C++ classes, doing polymorphism, data hiding and various other cannonical aspects of classes without a class keyword in site. It quite clearly is a different type system, much more esoterically different than the one in ObjC, being compile time. We're not talking "classes with template parameters". It's a second, wholecloth type system. Interfaces (as java would call them) without the interface declaration.

>Also what the hell are "new style" vs "old style" template classes.

An old style template class is a class that works on a datatype or two which is templatized. A new style template class is something out of http://www.amazon.com/Modern-Design-Generic-Programming-Patterns/dp/0201704315 a very popular style in some shops.

>And what the hell are you even talking about with your "weird extra encapsulated ways"?

Class 1 has a private member variable to a second class called a Class1_impl which is a completely different class which implements the internals of Class1. This is an attempt to enforce data hiding from friending.

The reason I listed more than 2 type systems, is because I doubt you can say ALL the listed type systems I have are the same one. If even 2 of them are, C++ has "at least as many" as objective C does (or Java for that matter). If you've NOT encountered these esoterica, I just think you need to work in 2-4 more C++ shops and you definitely will. They're pretty common in my experience.

Instead of learning assembly for it own sake I would learn about computer architectonic (eg. Computer Organization and Design by Patterson and Hennessy) after that you will have no problem picking any normal assembly language up in a couple of hours

I myself had it 2 year on my computer science BS.c.

Well, simply thinking that Knuth could make such a mistake, strikes me as naive. After all he wrote this and this.

Largely because CL has had the benefit of several years and hundreds (thousands?) of users beating on it, while an ignorant reimplementation is likely to make all the same mistakes that Lisp did when that feature was first introduced.

For example - generic functions were first introduced in Flavors, the object system for the Lisp Machine. A bunch of issues cropped up concerning the interaction of multiple dispatch and multiple inheritance, issues that the Python community hasn't even considered. There's a whole book - The Art of the Metaobject Protocol - written about these, along with many pages in the CL HyperSpec. Even with standardization, CL made a mistake: the superclass precedence order should be monotonic. The paper A Monotonic Superclass Linearization for Dylan goes into this in more detail.

>Java and C# are retard proof in that if you screw up, you get a descriptive error message and possibly the line it occurred on. If you screw up in C or C++, you get a magical crash and no information other than 'oh there was an access violation.' And it won't say 'access violation.' It will just give you an error code. Without memory management, you have a lot less to worry about and virtually no chance of your program continuing in an inconsistent state and producing completely incorrect results (which you may not know are incorrect).

How does the fact that C++ gives less descriptive error messages automatically make C++ programmers better? One's ability to debug past vague error messages and confusing language features says nothing about one's ability to write efficient and maintainable code. In fact, it might say exactly the opposite - using a tool that slows you down with vague errors and confusing features when better tools exist means that you'll get beaten to market by someone who doesn't have debug arcane error codes and undetected access errors.

>You won't find anything similar to this in Java or really any other language. If you come across an object you don't know about in Java, what do you do? You search a reference for information on the object. If you come across some syntax you don't understand in C++, what do you do? You can't very well put that line of code into Google and you have no idea what the term for it is.

Well, I'd look it up in the index of The C++ Programming Language, but I take your point. However, I fail to see how this is an advantage that C++ has over Java. Confusing syntax is something to be generally avoided.

Can't speak for the whole subreddit, but my personal hatred towards him comes from Martin being a snake-oil salesman.

Take his 3 "laws of TDD". Advertised as a practice equivalent to doctors washing their hands, results in horrible and unmaintainable test suites (I've seen plenty of tests whose idiocy couldn't be explained other way than those rules)

Take his "architecture" lectures. Advocating programming in ruby on rails while abstracting away everything about rails or the web or the database, or anything you didn't define yourself. In principle to enable testing and be able to run the code outside the web. In practice: https://youtu.be/tg5RFeSfBM4?t=299 The lecturer says that the architecture in practice is "horribly complicated" and that Bob had only a single implementation of the architecture, which he couldn't share. That didn't stop him from continuing with his lectures.

Take his blogposts (an example: http://blog.cleancoder.com/uncle-bob/2017/03/03/TDD-Harms-Architecture.html) Awful strawmans (this terrible architecture i drew is what you propose), cringeworthy writing style (lengthy discussions with made up opposition instead of real one). Unfalsifiable theories: "Is is only programmers, not TDD, that can do harm to designs and architectures.". That sentence is always true, either you succeeded and therfore TDD works, or you failed and TDD had nothing to do with it. No data to backup his claims "TDD works." - well there are plenty of publications that disagree (see chapter 12. of https://www.amazon.com/Making-Software-Really-Works-Believe/dp/0596808321)

Take his SOLID principles. While some of them are well defined and can be applied meaningfully (Liskov substitution principle), the Single Responsibility Principle has definition so weak and useless it's ridiculous.