IIRC, if there are multiple equally specific best matches you'll get a compiler error, and will have to disambiguate by making the call as you would with a normal static method. There are potentially issues if you recompile your code and the libraries you use have since added better-matching but functionaly incompatible extension methods, but I don't think there's any real solution to this, and it's unlikely to be a problem with well-designed libraries.

You're certainly correct that extension methods should be defined very carefully and sparingly. The ever-valuable Framework Design Guidelines has a number of recommendations, the first of which is to avoid "frivolously" defining extension methods.

A good IDE such as Visual Studio can tell you that Select is an extension method, which does help to some extent. Also, I suspect the vast majority of uses of extension mathods are through implementations of the LINQ patterns, in which case it's pretty clear from the usage.

Although extension methods can be used to extend existing sealed classes or as cute helpers, or for adding "instance" methods to interfaces, their primary use is for LINQ. It's fascinating how several C# 3.0 & 2.0 features that are individually quite interesting - extension methods, lambdas, type inferencing, iterators, generics, object initializers - combine with the LINQ-to-objects library to form something that's greater than the sum of the parts.

And that's not even getting into fascinating things like expression trees, the AsParallel() extension method, LINQ-to-SQL, the Rx framework...

> 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.

7-zip uses a mix of C, C++ and assembly. Unless you have experience with any of these languages, I would highly recommend starting with something much simpler.

I would say if you're trying to learn programming, you need to strip away all the extra 'stuff' that gets packaged up to make a production system. Don't worry about the GUI, and put WPF and C# to the side (for the time being). Start with something simple that will allow you to learn variables, functions, types, control flow, etc. A lot of people recommend Python, and that's a fine place to start. Any language where you can open a new file, write a few lines of code, and see a result would be ideal (Lua, Ruby, Javascript, etc).

More to the point of your question, GUI design is hard. There are all kinds of issues that have to be taken into account: event callbacks from the 'worker' code to let the interface know something changed, threading issues (does the interface lock up while the backend is working?), does the 7z file format even lend itself to parsing just a directory listing without decompressing the entire file?... There is a lot there, and it's not a good starting point. It's something that you can move toward as you learn the basics, though. And I always like looking through other codebases looking for good ideas.

If you're really serious about specifically working with 7-zip, the code is available at their website. You'll need to download the source code from 7-zip.org, then you'll need C Primer Plus and C++ Primer Plus. These are the best 'intro to...' books that I've found for C and C++. You're looking at a few months of reading and experimenting, and a lot of frustration. You're not only going to learn the languages, but also the Windows API that will allow you to interact with the folder views. These are somewhat stubbed out in the 7-zip source, but the specific view you're talking about would need to be written from scratch.

Regardless, it sounds like a fun project and if you put in the time I'm sure you'll get some benefit from it. Just be aware that this is trying to paddle against the current, and it is easier to take a step by step approach (in my opinion).

which books exactly, please guide me.

these ones?

Effective C++: 55 Specific Ways to Improve Your Programs and Designs (3rd Edition)

Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14 1st Edition

More Effective C++: 35 New Ways to Improve Your Programs and Designs 1st Edition

What is the difference between them? It seems effective cpp 3 is from 2005 and more effective cpp is from 1996. Is there a point in reading more effective cpp after reading the third edition of effective cpp?

Also, what do you think about C++ How to Program?

Well, I wrote a book full of suggestions for improving developer skill: http://www.amazon.com/dp/0996193308 , in case you're interested in that kind of thing.

Fred Brooks (author of Mythical Man Month), wrote "The key thrust of recent years was delegating power down, It was like magic! Improved quality, productivity, morale." Jim McCarthy from Microsoft said, "I can't emphasize enough the importance of empowerment, of the team being accountable to itself for its success." Having too much process removes empowerment, and it feels very stifling. The best teams are able to self-manage, and the best process-systems are aimed at improving the skills of the developers so they can self-manage (like Jim Shore does).

When I started getting interested in compilers, the first thing I did was skim issues and PRs in the GitHub repositories of compilers, and read every thread about compiler construction that I came across on reddit and Hacker News. In my opinion, reading the discussions of experienced people is a nice way to get a feel of the subject.

As for 'normal' resources, I've personally found these helpful:

• This list of talks about compilers in general.
  
• The LLVM Kaleidoscope tutorial, which walks you through the creation of a compiler for a simple language, written in C++.
  
• The Super Tiny Compiler. A really, really simple compiler, written in Go. It helps with understanding how a compilation pipeline can be structured and what it roughly looks like.
  
• Anders Hejlsberg's talk on Modern Compiler Construction. Helps you understand the difference between the traditional approach to compilation and new approaches, with regards to incremental recompilation, analysis of incomplete code, etc. It's a bit more advanced, but very interesting nevertheless.
  
  In addition, just reading through the source code of open-source compilers such as Go's or Rust's helped immensely. You don't have to worry about understanding everything - just read, understand what you can, and try to recognize patterns.
  
  For example, here's Rust's parser. And here's Go's parser. These are for different languages, written in different languages. But they are both hand-written recursive descent parsers - basically, this means that you start at the 'top' (a source file) and go 'down', making decisions as to what to parse next as you scan through the tokens that make up the source text.
  
  I've started reading the 'Dragon Book', but so far, I can't say it has been immensely helpful. Your mileage may vary.
  
  You may also find the talk 'Growing a language' interesting, even though it's not exactly about compiler construction.
  
  EDIT: grammar

readscheme is a good place to start, it hasa a bunch of good links to papers on issues related to macros: http://library.readscheme.org/page3.html

(It also has lots of other material, but you asked about macros specifically, so that's the link I've posted.)



If you can buy one book, buy Lisp In Small Pieces. It's generally excellent, and has good coverage of macro implementation strategies.

http://www.amazon.com/Lisp-Small-Pieces-Christian-Queinnec/dp/0521545668/ref=pd_bbs_sr_1?ie=UTF8&s=books&qid=1196347235&sr=8-1

Another good resource is the discussion of an implementation of syntax-case that's in "Beautiful Code": http://www.amazon.com/Beautiful-Code-Leading-Programmers-Practice/dp/0596510047/ref=pd_bbs_sr_1?ie=UTF8&s=books&qid=1196346388&sr=8-1

It may be a big of a tough slog, but Sipser's Introduction to the Theory of Computation is great. The stuff on computability theory might be right up your alley, and even if you only make it through the chapter on deterministic finite automata you likely will be better at crafting a regular expression than many of my CS student peers.

Surprisingly enough, the book should be able to help you make sense out of that last sentence within 100 pages requiring only a bit of understanding of proofs. I think if you've got predicate logic under your belt you pretty much have all you need.

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

This is in my opinion by far the best book on introductory computability and one of the best books on any kind of computing that I have ever read. It ranks right up there with Knuth for me.

It is clear and elegant and explains what's going on in a really well thought out fashion. Highly recommended.

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

Before teaching myself C++, I was terrified of the language too. Everyone said it's such a big language with many dark corners, and for the most part they're right. Then I /had/ to learn it for some coursework. I found the book C++ Primer to be very good. I abused all sorts of features of the language at the start, wrote tens of thousands of lines of code, and now I actually enjoy using the language for some tasks.

By analogy, cars and driving are scary too, but a healthy respect for the rules and best practices will usually get you to your destination safely.

Assuming you are interested in using JavaScript in the browser, DOM Scripting by Jeremy Keith. It's the best intro to client side JavaScript I have seen, and the stresses the basics with good style.

Once you are comfortable with the basics, more advanced JavaScript books would be Secrets of the Javascript Ninja (only available in electronic pre-release form, but worth it), Javascript: The Good Parts, or Javascript: The Definitive Guide.

If you want something along the more practical side for designers, jQuery in Action (1st edition hardcopy or 2nd in digital pre-release) or the jQuery online documentation is a good place to turn after learning the basics.

I believe there is always another best code waiting for you. But till yet I find the Jon Bentley's version of Quicksort in Beautiful Code pretty awesome. He describes it as "The most beautiful code I never wrote"

That's a good question, acutally. I picked it up in bits and pieces over years. I probably started to pick up when I tried to implement an object-oriented programming system in C. The dragon book was also a great help in figuring this sort of stuff out.

Another great way to learn is to write simple test programs in C or C++, and see what they compile down to with GCC. Using '-O' I find gives me the most readable "direct" assembly.

http://asm.sourceforge.net/howto/Assembly-HOWTO.html

Also, if you have any specific questions, possibly a tutorial or two... well, it's time that I started putting together a website.

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.")

>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.

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.

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.

Actually a more up to date book is C++ Template Metaprogramming by David Abrahams of Boost fame and Aleksey Gurtovoy. It uses the MPL extensively which implements quit a bit of the article if not all. It also describes FC++, Blitz++ and a few others. It implements a basic expression template system and even has an appendix on the Boost Preprocessor library.

I don't recommend starting out with that one though.

Also a good book, is C++ Templates . It's a little bit easier to start off with.

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.

Huh. After reading this thread, I'm pretty happy that Stack Overflow did not exist when I started programming in the early 2000s. All I found were sketchy pay-for-answers sites, which I did not trust (I was also a broke 13 year old), so I was forced to go buy a giant book on C++ and read it all the way through. this one

That gave me a great base of patterns to work with and I was able to not pay any attention in college because I already learned most of the material.

I do love Stack Overflow for shit like "How do I fix this obscure OpenGL error?" though, it has become an irreplaceable tool in my toolset.

Some great responses here everyone, thank you. The book Write Great Code: Volume 1: Understanding the Machine helped me understand.

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

C++ Primer is excellent.

(NOT C++ PRIMER PLUS OH DEAR GOD STAY AWAY)

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
  
  

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.

he lost me when he said this about GEB
> If you only read one book on this list, it should be this one.

seriously? it's not that i don't appreciate the sentiment, but things douglas hofstadter thinks are neat is no substitute for any single book on the rest of the list unless you

• have no other way to explain at cocktail parties what you studied at school
  
• try to sound smart at cocktail parties by talking about things in GEB without actually referencing the book.
  
  for my part, i'd add sipser's computation book and why not throw in some ken thompson in there as an amuse bouche?

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

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/

> This seems like a pretty arbitrary declaration...

I highly recommend you read "Framework Design Guidelines" and start using FXCop before you start making claims about what's arbitrary.

http://msdn.microsoft.com/en-us/library/ms229042.aspx

http://www.amazon.com/Framework-Design-Guidelines-Conventions-Libraries/dp/0321545613/ref=dp_ob_title_bk

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

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.

As mentioned by this paper, “Beautiful Concurrency (PDF)”, Simon Peyton Jones' chapter in Beautiful Code is well worth the read.

I thought it was one of the best chapters in the book.

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.

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.

Framework Design Guidelines is an excellent book for those that author APIs. I would recommend it to any developer or architect, not just .Net people. Various MS .Net and related team members share their thoughts and opinions on what they did right and wrong with .Net as they share their own, internal design guidelines.

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

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.

For anyone who wants to learn more about compilers and loves reading books, the so called dragon book is highly recommended lecture on this topic: https://www.amazon.com/Compilers-Principles-Techniques-Tools-2nd/dp/0321486811

Yep, Prata's C++ Primer Plus [5th ed.] and Lippman's C++ Primer [4th ed] are very very good. The 2 books are completely unrelated, by the way, in spite of the similarities in version numbers and names.

I've never been a huge fan of Stroustrup's tome, sure it's complete, but it's slow going. The 2 books above are good for someone jumping in, esp. if you've got a C background (not required however.)

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.

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 always thought the best algorithms book I ever read was AIMA.

As usual beautiful code is late.
More Power to Cut-And-Paste!


http://www.amazon.com/Beautiful-Code-Leading-Programmers-Explain/dp/0596510047

C Programming: A Modern Approach by K N King is a great book and is recommended in the C FAQ.

Awesome design patterns book Head First Design Patterns

[Edit] The patterns are expressed in Java

When I first started programming, I started with C++. C++ Primer Plus was my primary learning tool, and worked out great. I'm not a full time developer (mentioned as proof that it worked and I didn't wash out of programming)

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.

I don't know what he'd recommend, but I found the Dragon Book and Modern Compiler Design to be decent treatments of the subject. There are lots of interesting texts out there though.

Sorry for the cheeky reply.

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

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 mean "C Interfaces and Implementations: Techniques for Creating Reusable Software by David R. Hanson"?

Or perhaps "C Programming: A Modern Approach, 2nd Edition by K. N. King"?

Artificial Intelligence: A Modern Approach by Norvig and Russell

http://aima.cs.berkeley.edu/

On Amazon

Edit: Good point from nacarlson about the 2nd edition. I've changed the link to reflect that.

Effective C++ and More Effective C++?

>We are talking about a high-level language compiler, remember?

I still consider C a high level language. Some people don't for various reasons..

>You were complaining that it compiles to C rather than emit instructions.

You simply read/took my post wrong. Nowhere am I complaining. Merely making an observation. It is not an unusual feat for a compiler to generate assembly instructions or machine code. Nor would I call it super difficult to write a compiler, but rather straightforward.

>If you are going to emit instructions, it's up to you to write your own optimizer.

Or buy/obtain a compiler that already is capable of doing this step.

I found good reviews for this book. Anyone has opinions on it?

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

But the Dragon Book has cool dragons on it!

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.

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

read this ... a few times.

But make sure to get the 2nd edition of the Compiler book. It has been enhanced quite a bit.

> And which coder uses physical books any more?

I do for things beyond actual language references; e.g. maybe everything in The Dragon Book has a good description somewhere, but grabbing that off my desk and having a decent chance of it having what I want (it has some problems and omissions, but it's reasonably good) will save wading through a bunch of crap online until I find something complete and accurate enough.

I'd add C++ Templates: The Complete Guide to the list of essential reading for advanced C++.

There is probably a better way, but one way is to look towards the upper right of the page on Amazon.com where it has a link labeled 'Share'. Clicking this brings up a page with a Permalink label. Copy and paste this value. You don't need to actually send the email (click click close on the upper right). The Permalink for Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries (2nd Edition) seems to be http://amzn.com/0321545613.

The post you are replying to has been deleted so I don't know if this would address their objection or not.

I am surprised this book has not been mentioned yet:

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

K.N. King's C programming
covers upto C99, I don't know if there's anything significant in C11.

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

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

Compilers: Principles, Techniques, and Tools,
by Aho, Sethi and Ullman

first ed: http://www.amazon.com/Compilers-Principles-Techniques-Alfred-Aho/dp/0201100886

second ed: http://www.amazon.com/Compilers-Principles-Techniques-Tools-2nd/dp/0321486811

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

Ah...Sipser.

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

https://www.amazon.com/Beautiful-Code-Leading-Programmers-Practice/dp/0596510047/ref=sr_1_1

• Beautiful Code
  
• Design Patterns
  
• The Pragmatic Programmer
  
• Refactoring
  
• The Mythical Man Month
  
• Why Programs Fail
  
• Professional Software Development
  
• Coders At Work
  
• Contextual Design

There's Beautiful Code

http://www.amazon.com/Beautiful-Code-Leading-Programmers-Practice/dp/0596510047/

http://norvig.com/sudoku.html

http://www-cs-staff.stanford.edu/~uno/programs.html

This reminds of the chapter on quicksort in Beautiful Code.

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.

> Those are interpreted (JIT - just in time compiled)

You are contradicting yourself.

Plus there are also native compilers for Java and .NET languages.

Just a few examples:

• OS/400 compiles to native code at installation time
  
  
• Android ART compiles to native code at installation time
  
  
• Websphere Real Time JVM has an AOT compiler
  
  
• Aonix JVM has an AOT compiler
  
  
• Mono -aot, NGEN and .NET Native are all compilers generating native code
  
  Given that C and C++:
  
  
• have the CINT interpreter
  
  
• on OS/400 they compile to bytecode
  
  
• on Windows CE they could be compiled to bytecode
  
  
• were compiled to bytecode with the TenDRA compilers
  
  Does that make C and C++ interpreted?
  
  Of course not, because as any compiler design student knows, language != implementation.
  
  Bytecodes are just a form of architecture independent machine instructions, by no means do they require interpretation vs further compilation to native code.
  
  Since the Summer is still not over, here is some reading:
  
  Compilers: Principles, Techniques, and Tools (2nd Edition)

Have you ever seen the Dragon Book?

http://www.amazon.com/Compilers-Principles-Techniques-Tools-2nd/dp/0321486811/ref=sr_1_1?ie=UTF8&qid=1292732652&sr=8-1

No THAT'S an ugly cover.