* Effective Java
  * Java Concurrency in Practice
  * Head First Design Patterns

I strongly suggest most junior programmers I work with to read Effective Java and Head First Design Patterns. To me, it's a great combination to help you write code that's easy to understand and maintain.

Also browse some of the core Java source code to see really elegant implementations by him.

1) Head First Design Pattern

2) Effective Java (Joshua Bloch). The principles in this book can be applied to almost any programming language not just Java

Also, the 2nd edition covers up through Java 1.6.

Code Complete 2, The Web Application Hacker's Handbook, Algorithms in a Nutshell, and Code.

Not to mention an Arduino book - but I'll probably get Effective Java and read it first.

Effective Java (2nd Edition) by Joshua Bloch. It's a Java book but it's language-agnostinc in a way. A great book.

1: https://docs.oracle.com/javase/8/docs/api/java/util/package-...
2: https://docs.oracle.com/javase/8/docs/api/java/util/stream/p...

For Spring, Jakarta EE, Micronaut or Quarkus the docs of their respective websites is enough.

Your invocation of Effective Java made me look for Effective Javascript, and it does exist. Amazon users give it five stars: http://www.amazon.com/Effective-JavaScript-Specific-Software...

Can anyone comment on how well this books fulfills the expectations implicit in a book calling itself "Effective X?" Or just how effective the book is with respect to accepted javascript practice?

Release It! => applicable

Continuous Delivery => applicable

Effective Java => absolutely IF you use Java (see other 'effective' series such as Effective C#, Effective C++ [_the_ grandfather], Effective JavaScript)

Patterns of Enterprise Application Architecture => Guess where Rails come from? (hint: DHH name is also mentioned somewhere in the book)

Reference:

  - Effective Java (good for learning the mindset of developing backward-compatible APIs in any language)
  - Enterprise Integration Patterns (I work on an enterprise APIs team)
  - Designing Data-Intensive Applications
  - Camel in Action

  - The Phoenix Project
  - Making Work Visible
  - Effective DevOps
  - The Pragmatic Programmer
  - REST in Practice

I would also like to bring up the importance of reading "good practices" books and articles. Learning not only how to write good code for yourself, but good code for your colleagues to work with is an important skill to have. Writing maintainable code is often not trivial. I recommend reading Effective Java by Joshua Bloch.

I would also mention that the 3rd edition of Effective Java is still a standard for anyone using java7-8-9:
Joshua Bloch
Effective Java (3rd Edition)

Gosling's "The Java Programming Language".

And Josh Bloch's "Effective Java".

After that, Java Concurrency in Practice.

Langr's "Agile Java" is good for just that.

Bloch, Goetz, and Doug Lea have each written excellent books on java concurrency.

That's just about all the java books I would want to recommend. Many j-books are trash.

Effective Java: http://java.sun.com/docs/books/effective/

Java Concurrency in Practice: http://www.javapuzzlers.com/

Everything else is covered by the excellent online documentation, including the language and VM specification books: http://docs.oracle.com/javase/specs/

Java Puzzlers (http://www.javapuzzlers.com/) is a fun read that highlights many corner cases of the language and might be helpful for code reviews and debugging.

Or, like recommending K&R C to beginners (C beginners, but even worse to programming beginners). There are a handful of books out there that, IMHO, are vastly mis-recommended, and I would agree that JS:The Good Parts is one of them.

Very slim, and very good - Javascript: The Good Parts http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockfor...

For a C reference, Harbison & Steele is excellent - http://www.amazon.com/Reference-Manual-Samuel-P-Harbison/dp/...

It's not for beginner Java programmers, but if you have experience in other similar programming languages you may get away with it.

It’s a collection of core libraries for Java that I believe should have a lot of useful patterns/concepts to learn from.

I also highly recommend Effective Java by Joshua Bloch (https://www.amazon.com/Effective-Java-Joshua-Bloch/dp/013468...). An incredible text for any kind of programmer, and even better if you’re specifically interested in Java.

Good luck!

Expert C Programming, Peter van der Linden (a decade later).

Effective Java by Joshua Bloch.

I will say Joshua Bloch's Effective Java is something ever Java dev should have read at some point.

Check the table of contents, it will give you an idea of what to expect from the book.

I only have one cert - the Sun Certified Java Programmer, from back in the day when Sun still existed - and i can say it encouraged me to dive deeper into the quirks of the language. For sure, reading Effective Java gets you more bang for the buck in becoming a great Java developer, and stuff like Clean Code probably helps more with learning how to build maintainable apps, but i still feel like the SCJP was worth my time to do.

The thing i found about doing the SCJP is that it increased my curiosity around programming languages in general. Those contrived "gotcha" questions on visibility, inheritance etc made me think more deeply about how to design code in a readable and safe way - not just in Java but in other languages too.

http://java.sun.com/docs/books/effective/

If you look at Bloch's book Effective Java you'll see he describes functional approaches quite a lot (eg prefer immutability) - these are places you go when you see that they're better.

While you are at it, read "Effective Java" by Josh Bloch--it's full of excellent advice about OOP, and applies way beyond Java itself.

My biggest epiphany about OOP was realizing that just because you can use inheritance, you don't have to use it everywhere. You read a lot of toy examples where you have e.g. a shape, then you have children like square, rectangle, etc. and try to do everything this way in your projects. But it's actually often a really bad idea to overdo it, and Effective Java has some good explanations on the tradeoffs.

So what's some really great, clean, elegant object oriented code that I could read to better understand what makes up good OO design? What are the books one should read to develop a deeper understanding of OO's qualities? It doesn't matter what language or platform they focus on, since I think the fundamentals ought to be independent, and I'm willing to work hard. Rails internals, Django internals? Some Java framework? Or is there some awesome piece of Smalltalk code out there that demonstrates the roots of OO? Is the Gang of Four book still relevant? Where do you go for getting the bigger design picture?

For context, I've done a lot of Java (Android) but I don't think I've been exposed to good large scale design in Java (I've read Effective Java and Java Concurrency in Practice, but both of those deal with the nuts and bolts of programming in the small) Most of my functional programming experience is with Clojure, which is very opinionated and takes a radical approach to OO, and I think the bar has been set kind of high by Rich Hickey.

Please don't tell me to go get a job at Google or your company where the code is beautiful all the time; that's just not fair.

I'd highly recommend Josh Bloch's writings. Josh is perhaps best known for the book Effective Java and the Java Collections library. Here is a paper he wrote about good API design (https://dl.acm.org/doi/abs/10.1145/1176617.1176622) and a short interview with him about API design (https://www.infoq.com/articles/API-Design-Joshua-Bloch/).

Brad Myers at CMU also has done research on API usability. See here for more details: http://www.cs.cmu.edu/~NatProg/apiusability.html

Lastly, if you're doing anything remotely related to security, I'd also recommend Matthew Smith's research. He's studied a lot about weaknesses of today's API designs and how they have led to security vulnerabilities.
https://ieeexplore.ieee.org/abstract/document/7676144

Yes Java has a lot of problems but they are mostly ones that have workarounds and aren't fundamentally dealbreakers. A few example issues are assignment isn't final by default, @Override isn't required to override methods, you can't have abstract static methods (sort of can workaround this now get this now with default interface methods). Java is basically just a really un-opinionated language that requires careful practices to wield it properly (see Effective Java by Joshua Bloch) but other than that it isn't a completely terrible language and you can write some really robust, easy to read code with it.

I would also have a lot more time for this article if the author actually took the time to explain the motivation behind the *FactoryFactoryFactory class instead of just discounting it without explanation and using it as the proverbial Straw Man for his article. I'm sure something this unusual must have a very interesting reason as to why it exists (I'm taking him literally here and assuming he isn't just exaggerating for comic purposes).

Effective Java is also a great read for becoming a "better" Java programmer, but may or may not be useful to you right off the bat.

Java: Even for an early version I still revisit [2] Kathy Sierra SCJP 6 book beside of new ones, a great reminder for core concepts and basics, also 'effective java' by Joshua Bloch

C: As HeckFeck mentioned it was fun to follow C Programming Language by Brian W. Kernighan, Dennis Ritchie

[1] https://www.amazon.com/Fluent-Python-Concise-Effective-Progr...

[2] https://www.amazon.co.uk/Certified-Programmer-Study-Guide-CX...

The book "Effective Java" (from 2001) still has to one the "must read" for any Java programmer that didn't read it.

In it Joshua Bloch has always been very clear, from the start, about all the deeply ingrained ugly Java warts that Java had from the start (and still has). Like for example the complete and total utter impossibility to respect the equals() and hashcode() contracts in the face of inheritance.

Took a long time to set in but now quite some Java programmers are beginning to accept that having equals() and hashcode() at the top of an inheritable OO hierarchy may not have been the greatest thing since sliced bread.

The second book to read is Goets and al.'s "Java Concurrency in Practice" (one of the best looking programming book cover ever, which never hurts an incredibly high-quality content).

But the real lesson is that: Java is too complicated and has way too many warts to ever produce beautiful code. The JVM is not all bad but "Java the language" is really fugly.

Switch to a language that has a saner way to deal with concurrency (Say Clojure's STM or Go) and you can throw most of the pages in these books to the trash.

  - You have everything organized in one place.

  - You are sure they are accurate (they often have an errata posted online).

  - You don't bother searching for content online.

As for programming languages, I don't really buy books because I find they're fairly easy to pick up once you know 2-3 (with the exception of books such as Effective Java). Don't forget there are also video tutorials which are an important resource.

The difference now is that UX has become a popular, well-understood, discipline. So we have a lot more concepts to take back into API design.

Some of us have been capturing relevant links on the topic on a Developer Experience page (https://plus.google.com/116834904360889286443/posts) and under the #devexp hashtag. We don't have t-shirts, but we do have a logo in need of much love! I'll go add a link to that presentation too.

To work with legacy code I recommend Working with Legacy Code by Martin Fowler. Lots of good ideas for handling messy codebase are described there.

Java's community has been Opinionated, whereas the JS community has been a lot more freeform. JQuery and NodeJS have been very influential in adding an opinion to the language; jquery by adding a kind of namespacing and scoping (also thanks to its predecessors / peers like YUI), NodeJS by adopting a module system (CommonJS) and centralized dependency management (NPM).

I came into JS via Java and while the lack of standards and rules / expectations was liberating, I was also missing it. It took a while before the best practices of Java made it into Javascript; in my experience, AngularJS was a big push for that, in that it was a much more opinionated way to structure your components and application - with a strong emphasis on (unit) testability.

What disappointed me was, 3 of the interviewers had no idea about my background and weren't able to extract my strengths. Even though I am a new grad, I have interned for 2 years as an app dev and learned a great deal about design, code quality, testing and etc...

I have read Effective Java, Clean Code, and Head First Design Patterns. I'm reading Java 8 in Action now. I have not memorized them page-to-page and still need more experience to master them, but at least I know some of resources I can go to for more answers. I have participated in code reviews and enjoy them. I can implement LLRBT and many of the algorithms you can expect a new grad to know but I have not invested my time on hacker rank and uva.

I don't know what SV or big tech companies are looking for. I constantly hear interviewers say they want good engineers but fail to capture the essence of a potential good engineer well. What benefit is there in hazing anyone with problems many engineers don't deal with without the tools they use every day, and with an absurd time constraint. Kosaraju didn't come up with SCC in 30 minutes and he had a PHD. Sure I can spend hours studying for whiteboard questions but to what benefit. I am sure anyone of you can come up with a whiteboard problem you can't solve in 30 minutes, but what does that say about you.

Our developers use Java (mostly).

Our research department uses whatever they are most comfortable with for research, but the result of their research is coded up in C++. If we had to do it over, we'd probably do everything in Java. Misc. notes:

Personally, I am WAY more productive in Java.

I supplement Java with Clojure.

I find the performance penalty for using Java is pretty-much negligible. It's always how you do it that matters more than what language you do it in. Don't use Java Generics for number crunching though... use a dedicated primitives collection library like Colt.

Java and C++ are quite similar in some respects. I would say though, that it's easier to go from C++ to Java, than from Java to C++.

Best C++ books:

Accelerated C++ by Andrew Koenig and Barbara E. Moo

Effective C++ by Scott Meyers (make sure you get the 3rd edition)

Best Java books:

Effective Java by Joshua Bloch

Java Concurrency in Practice by Brian Goetz, Tim Peierls, Joshua Bloch, and Joseph Bowbeer

If you have to use C++, start using the Boost C++ libraries early on. You can learn a great deal just by using the Boost libraries, and reading their documentation.

- Many engineers know Java to at least an intermediate level, so they can be productive quicker (and hiring is easier)

- We had some existing libraries written in Java, so integrating them with the web platform was much easier if we went down the JVM route

- Java is the language most familiar to members of the startup (including me, although I also have experience in RoR, Kotlin, ObjectiveC and JavaScript)

Technical:

- Java is generally very performant and running on the JVM means we don't generally have to worry about platform specific issues (there are well known exceptions of course e.g. file path issues)

- The language itself is at a reasonable level of abstraction. It is strongly typed and IMO, writing a non-trivial backend in a dynamically typed language is a sub-optimal choice. It has a huge ecosystem of robust, battle tested libraries that are indispensable to us (e.g. JGraphT). There is a huge community - you are unlikely to run into 'uncharted' territory

- It is popular to hate on Java but it really isn't that bad a language, especially if you aim to follow guidelines like those in Effective Java (probably my favourite programming book) e.g. avoiding mutable state and side-effects. It will never be as good as a modern language like Kotlin (data classes are my favourite feature there), but it is good enough

- The server frameworks available are seriously robust and 'just work'

- There is always the option of using alternative JVM languages (we use Kotlin for a large part of the backend)

In summary, we are 6 months into developing the web platform, progress is rapid, and we have no regrets (yet) about the technology choices. IMO, sometimes boring is best.

2.5 era: " ... some might argue that the third era was the “Effective” era, with books such as Meyers’ Effective C++, Bloch’s Effective Java or Wagner’s Effective C# as flagship examples. But I consider these books, as useful as they are, just an offspring of the second era; a much needed upgrade. Let’s say, then, it was the 2.5 era of programming books".

3.0 era: "... at a time where the dot-com boom opened the door for new ideas, right in the middle of the Web 2.0 craze, and right before the rise of the smartphone and social media. Through the use of comic images, unusual text layout, and a fantastic sense of humor, Kathy Sierra argues, readers can learn the concepts easier; tricking the brain into the proper levels of dopamine".

At barnes & nobles / borders I always grabbed one of these books which made content enjoyable to read. She sparked a new era of genres produced by other authors, for example, an anime version of learning python.

- Speech and Language Processing, Jurafsky & Martin

- K&R

- Sedgewick & Wayne, but more for teaching than anything else.

In a previous life:

- The C++ Standard Library, Nicolai Josuttis,

- C++ GUI Programming with Qt 4, Jasmin Blanchette and Mark Summerfield

- The C++ Programming Language, Bjarne Stroustrup

- Effective Java, Joshua Bloch

- Scott Meyers' Effective C++ books.

  East of Eden - John Steinbeck
  Of Mice and Men - John Steinbeck
  The Grapes of Wrath - John Steinbeck
  Cannery Row - John Steinbeck
  Crime and Punishment - Fyodor Dostoyevsky
  Man's Search for Meaning - Viktor E. Frankl
  Deep Work - Cal Newport
  The Little Prince - Antoine de Saint
  The Subtle Art of Not Giving a F*ck - Mark Manson
  Flowers for Algernon - Daniel Keyes
  Notes to Myself: My Struggle to Become a Person - Hugh Prather
  Tuesdays with Morrie - Mitch Albom
  I Heart Logs: Event Data, Stream Processing, and Data Integration - Jay Kreps
  Kafka: The Definitive Guide - Neha Narkhede
  Effective Java - Joshua Bloch
  Algorithms - Robert Sedgewick, Kevin Wayne

The older generation are in this place because back then none of the technologies you listed existed and so they had to know the more low level things.

A book that might help some of your knowledge gaps (at least directionally) is The Imposter's Handbook[1] by Rob Conery.

If you're specifically aiming to get away from CRUD take a look at the various Domain Driven Design books by Eric Evans[2] and others. This is the opposite direction to your ask though (more high level than low level).

If you want to go deeper in Java, read Effective Java[3] and Java Concurrency in Practice (JCIP)[4]

Lastly, if you want to experience the reasons why some of that early comp-sci stuff happened the way it did, playing with expensive hardware is the least effective way to find understanding of constraints. Instead consider grabbing devices with significant limitations like an Arduino, ESP32, or similar (I'm partial to the Wio Terminal[5] and M5Stack[6] as interesting easy to get started devices, but others would suggest various Arduinos or Raspberry Pi devices). Realistically you're going to learn much more by coming up with a self-challenging project and completing it than just by learning it for the sake of learning.

[1]: https://bigmachine.io/products/the-imposters-handbook/

[2]: https://www.amazon.com/Domain-Driven-Design-Tackling-Complex...

[3]: https://www.amazon.com/Effective-Java-Joshua-Bloch/dp/013468...

[4]: https://www.amazon.com/Java-Concurrency-Practice-CONCURRENCY...

[5]: https://www.seeedstudio.com/Wio-Terminal-p-4509.html

[6]: https://m5stack.com/

I didn't know the Java compiler converts this automatically now. Since which version is this? I suspect there might be still edge cases where it doesn't work.

I think you can really judge a language accurately by checking out its standard library. This is one of my favorite things about Go.

By comparison,

* The C++ STL. Fast and useful, but the implementation is nearly unreadable due to template soup. Here's one of the simpler parts! https://www.sgi.com/tech/stl/stl_vector.h

* PHP. So bad it's basically a strawman. I'll include it because it's hilarious:
http://www.forbes.com/sites/quora/2012/08/31/what-are-the-mo...

* Java. A bit better. Compare the readability of OpenJDK's ArrayList.java to the STL vector.h, which does essentially the same thing: http://hg.openjdk.java.net/jdk7/jdk7/jdk/file/00cd9dc3c2b5/s...

But of course the Java standard library is immense and has a lot of cruft in it. To write clean Java you really need to avoid much of the standard library (read Effective Java by Josh Bloch) and add a few important missing parts (use Guava).

Golang is really unique in that regard. You can learn Go by reading the standard library. It is beautiful, linear code. The library is pretty complete--eg you can write a one-line HTTP file server out of the box--but nothing feels extraneous. Lastly, I think it gets close to Knuth's ideal of Literate Programming. Paragraph-length comments thoughout the standard library explain what's happening, how, and why.

For example, the post talks about how io.Copy is awesome. For a concise English explanation, why not go directly to the source!

https://golang.org/src/pkg/io/io.go#L329

It is not simply 'here's a new language feature'. I find it quite informative regarding what, why, how and why not etc. His articles explain what went into the decision making. Something on the lines of discussions in Effective Java by Joshua Bloch.

His article on records: https://www.infoq.com/articles/java-14-feature-spotlight/

Effective Java by Joshua Bloch

Practical, actionable guidelines. The first edition was the best, the second was diluted somewhat by having to cover generics, in the third he admits that he doesn't really use Java much anymore... Despite that, it's well-written and still a good book.

The Linux Programming Interface by Michael Kerrisk

Covers some of the history of the Linux/Unix API, describes it in detail, has plenty of examples, compares different APIs that do similar things so you can make an informed choice (e.g. System V vs. POSIX message queues).

If any book in this list stands out for me, it's probably this one. It might be partly due to the surprise factor of how enjoyable and well-written a 1000+ page, near-reference book is.

Programming in Haskell by Graham Hutton

An intro to the language and how to approach problem solving from a functional P.O.V. Not as comprehensive as some other intros to Haskell, but Hutton is a good writer and educator, making it a good read.

Designing Data-Intensive Applications by Martin Kleppmann

Provides an overview of a number of topics related to databases, distributed systems, consensus, etc. Lots of references (many of them online) if you like that in a book. Enjoyable to read.

Parallel and Concurrent Programming in Haskell by Simon Marlow

Probably a must-read if you're into Haskell; probably too esoteric if you're not... Well written.

Type-Driven Development with Idris by Edwin Brady

Describes a programming language similar to Haskell, but strict by default and with dependent types designed-in from the start. Also describes techniques for leveraging the type system to construct functions (the type-driven part of the title). Well written.

Hacker's Delight by Henry S. Warren

Low-level bit twiddling. 'Nuff said.

So - good book, but not for this purpose.

I find Effective Java an easy read for the exact same reason, it makes a point from the very start without telling so many stories.

https://books.google.co.uk/books?id=ka2VUBqHiWkC&pg=PA73#v=o...

It's not usually pursued with the same rigour as in many functional languages, but it would be absolutely normal to see a Rectangle class with a stretchedX method which returns a new rectangle rather than mutates its receiver.

Now, you might argue that despite what Bloch, and every other good Java programmer, says, "Java as typically programmed" still trades mostly in mutable state. Since Java is actually widely used in the real world, it's typically incompetently programmed, and so this is probably true.

Nonetheless, i am confident that Java code written using immutable objects could both use and be used by other code. I say this because it's what i and my colleagues have been doing for years.

I had a go at functors in Java a while ago. You're certainly right that it's not elegant:

https://news.ycombinator.com/item?id=7898294

Some books are references and some are read throughs. I read Code Complete while in college and thought it really helped my programming. Effective Java is another great book that I've read. The Pragmatic Programmer is another one that I've read that really is worth the time.

Many books are just good references though. Pick it up and read a chapter for example. I think the more experience a programmers gets the less they need to read right through a book. When looking at a book on a particular language I can usually skip the first half because I know the parts that are common across most languages. I only need to know what's different/cool/idiomatic in this particular language.

Algorithm books are another example that falls into mostly the reference category. I don't think I've read any entire algo book, but I have read many chapters from many different algo books that touched on what I needed to learn at the time.

As a first step C/C++ developers should have read Scott Meyers' books and Java developers should know Josh Bloch's Effective Java by heart.

WRT to the (ultra-short) post this item links to, IMHO designing everything up front is neither feasible nor possible at all for any but the most trivial projects. That is something that at least the advent of agile methods even within the most conservative corporations should have taught us.

What is lacking in software development are neither the tools nor an atmosphere of less pressure. Much rather it is the sensibility for decent craftsmanship and engineering - and the knowledge of the means on how to acquire such.

Bloch's Effective Java is wonderful, but if it has a weakness, it might be that it assumes everyone is writing a library to be used by a lot of developers, many of who are outside your organization.

The example of public fields in data transfer objects is an example of this. Making the fields public is fine if this code is just for you and your team, because you can always refactor it to use accessors later if you need to. But if this code is in a library used by people outside your organization, introducing accessors later without breaking code will be almost impossible.

[0]: http://shop.oreilly.com/product/0636920032519.do

- La Zone du dehors by Alain Damasio, a french author. I must admit I liked his more recent book, La Horde du Contrevent, a lot more. Sadly, it is not available in English. Read it if you understand French and like SF.

- Chronicles of Amber by Roger Zelazny (finishing the 9th book). It's a good story, but not a must-read.

- The Fountainhead by Ayn Rand. Liked the first 150 pages I read.

- Cryptography Engineering by Niels Ferguson, Bruce Schneier, and Tadayoshi Kohno. I'm learning tons about cryptography.

- The Non-Designer's Design Book (3rd edition) by Robin Williams. Only read a few chapters, but I'm learning a lot about design. Very simple principles that change everything.

- Growing Object-Oriented Software, Guided by Tests by Steve Freeman & Nat Pryce. I decided to go with this book instead of reading Beck's book on TDD. I'm learning / revisiting a lot of best practices from TDD masters. I recommend it to Java Developers (once they have read Effective Java, of course).

I still have a lot to read (
http://i.imgur.com/lgpjf.jpg and http://www.google.com/buzz/neveue/Kc4GhaSSoLE/Un-weekend-pro... ), and am looking forward to it :)

I anyone is interested, I've spent some time researching (on HN, StackOverflow, and other communities) about design & UX, Linux & System administration, and programming. Here's the list I ended up with: http://www.google.com/buzz/neveue/NBBSEryBonS/Woot-ordering-...

Really? Java's success is - rightly - attributed to its simple and usable libraries.

> To write clean Java you really need to avoid much of the standard library (read Effective Java by Josh Bloch)

Lol, the standard ArrayList.java is written by ... Josh Bloch!

Inheritance is a fundamentally flawed concept in type systems. It suffers from the fragile base class problem. Josh Bloch, writer of Effective Java, recommends using composition over inheritance. If you want inheritance so that you can selectively override event handlers, and fall back on default implementations... you want something that's broken, because that suffers from the fragile base class problem. You need a guarantee that the superclass you are overriding won't call your subclass methods in an unexpected way... in other words, you need implementation details. A better way is to explicitly call default handlers on the superclass.

Is that a joke? $30 is quite literally nothing for a new technical book. Refactoring is still $45 new (hardcover but more than 10 years old now), Effective Java is about the same price, TAPL will set you back $60 and ATPL is $56 on Amazon, HTDP is $67, Koza's "Genetic Programming: On the Programming of Computers by Means of Natural Selection" released in 1992 is $67, SICP is $70, amazon asks for a hundred bucks for the purple dragon books, and then of course The Art of Computer Programming boxset will blow a $200 hole in your wallet.

$30? That's the price of a small and widely-distributed paperback like Friedl's Mastering Regular Expressions. It's basically the lower bound, even The Art of the Metaobject Protocol (345p, published in 1991) is $40.

Here's what's under $30: "For Dummies" books. Even the Head First collection bottoms out around $30.