Name: Effective Java
ISBN: 9780321356680

Effective Java

This highly anticipated new edition of the classic, Jolt Award-winning work has been thoroughly updated to cover Java SE 5 and Java SE 6 features introduced since the first edition. Bloch explores new design patterns and language idioms, showing you how to make the most of features ranging from generics to enums, annotations to autoboxing.

What Hacker News says

tedgghAug 2026

Effective Java by Joshua Bloch helped me grow from amateur to decent developer. And I never wrote a line of Java.

thread

stevoskiMay 2025

A good starting point is Joshua Bloch’s Effective Java. He shares some stories there from Java’s early days, and - at least in passing - mentions some aspects of the String class’s history.

thread

melingApr 2025

I read it about two years ago, and would definitely recommend it. It has a similar vibe to Josh Bloch’s Effective Java.

thread

wduquetteApr 2025

Heh. The books on the list would be the ones from which I learned new ways to think about programming. Most of them are now long out-of-date, as witness the discussion on "101 BASIC Games" going on elsewhere on Hacker News.

"101 Basic Games", edited by David Ahl and published by DEC. I learned to program by typing in the code from this book back in the late '70's.

"Write Your Own Programming Language Using C++", by Norman E. Smith. This is about writing a simple Forth interpreter. I used what I learned to write a simple Forth interpreter in C, which I then used as an embedded extension language in a couple of apps I was working on at the time. This was on a VAX, and rather before I'd ever heard of anything like TCL/TK.

"Tcl and the Tk Toolkit", by John Ousterhout, which (among other things) explained how an embedded extension language ought to work.

The O'Reilly X Windows books, and various O'Reilly books with animals on the cover. They were essential references, back in the day.

"The C++ FAQs", by I don't remember who. I never used C++ much; but this book was an excellent introduction to all of the pitfalls in the C++ of the day, and how to use C++ without shooting yourself in the foot--and an even better example of how to write for programmers. It was a big influence on how I later wrote programmer's documentation.

"Refactoring", by Martin Fowler. I've never followed the advice in this book slavishly, but it's tremendously affirming to read a new book encouraging you to do what you were doing already without having a name for it.

"Effective Java", by Joshua Bloch, which I spent a lot of time with about ten years ago; it helped me come to grips with Java and avoid a variety of foot-guns, much like "The C++ FAQs".

Various Lisp books; I don't like Lisp all that much, or Scheme either; but I come back to one or the other every few years and take another look, because I always learn something.

Various other texts on specific programming languages, as I experiment with them; "Learn You a Haskell for a Great Good" sticks out mostly because it has a memorable title.

And "Crafting Interpreters", which I've worked all the way through and then run with. Last month I implemented a simple Datalog implementation in a few days using the techniques from CI; I'll soon be integrating it into a much enhanced version of Nystrom's Lox.

thread

swahJan 2025

Perplexity:

Based on the discussions from the provided Hacker News threads, here is a list of ten notable books recommended by users, particularly in the context of software engineering and programming:

## Top Ten Recommended Books

- *The Pragmatic Programmer* by Andrew Hunt and David Thomas A classic in software development, this book offers practical advice and principles for programmers.

- *Clean Code: A Handbook of Agile Software Craftsmanship* by Robert C. Martin This book emphasizes writing clean, maintainable code and has become a staple in programming literature.

- *A Philosophy of Software Design* by John Ousterhout This book provides insights into software design principles and the importance of simplicity in design.

- *Domain-Driven Design: Tackling Complexity in the Heart of Software* by Eric Evans A foundational text for understanding complex software systems and how to manage them effectively.

- *Designing Data-Intensive Applications* by Martin Kleppmann This book covers the principles of designing applications that handle large volumes of data efficiently.

- *Refactoring: Improving the Design of Existing Code* by Martin Fowler Focuses on the process of refactoring code to improve its structure without changing its functionality.

- *Code Complete: A Practical Handbook of Software Construction* by Steve McConnell This comprehensive guide covers best practices in software construction and coding techniques.

- *Effective Java* by Joshua Bloch A must-read for Java developers, this book provides best practices for writing robust Java code.

- *The Mythical Man-Month: Essays on Software Engineering* by Frederick P. Brooks Jr. A classic work discussing the complexities and challenges of managing software projects.

- *Programming Pearls* by Jon Bentley This book presents programming problems and solutions that enhance problem-solving skills and algorithmic thinking.

These books are highly regarded within the programming community and cover a range of topics from coding practices to software design philosophies, making them valuable resources for both new and experienced developers.

Citations: [1] https://news.ycombinator.com/item?id=41387062 [2] https://news.ycombinator.com/item?id=35929112 [3] https://news.ycombinator.com/item?id=32130578 [4] https://news.ycombinator.com/item?id=41387062 [5] https://news.ycombinator.com/item?id=35929112 [6] https://news.ycombinator.com/item?id=32130578 [7] https://news.ycombinator.com/item?id=29498220 [8] https://news.ycombinator.com/item?id=29306651

thread

nayukiDec 2024

And your reply is half right, half wrong. Let me address the wrong parts.

> Duck typing vs. abstract base classes / You can do both in Python

I'm saying that the original intent of Python was duck typing, but then people realized that abstract base classes play an important role - e.g. isinstance() testing, static type annotations. So they still ended up where Java started.

> Static type hints / I don't even know what that means.

I'm saying that Python was designed with no type annotations on variables (though values did have types), and then they realized that people wanted this feature... and ended up where C/C++/Java/C# have been all along. Python became "enterprisey".

And then, Python implemented type hints rather badly from 3.0 through 3.10 and beyond. It doesn't include types in the official documentation, so now you have to guess what open() returns (it's typing.BinaryIO/typing.TextIO). It doesn't have an official type checker, instead relying on third-party tools like mypy. It moved items between typing and collections.abc. It requires `from future import __annotations__` for non-trivial programs. It changed typing.List to just list in 3.9. It introduced the | (union) operator in 3.10. And a bunch more little things I can't recall; it just had a bad out-of-the-box experience and kept tweaking things over the decade. Documenting generics and especially protocols in Python takes effort.

> Python was created in 1989. Java was created in 1996

Wrong. Java was created in 1991, and the first version released in 1996. https://en.wikipedia.org/wiki/Java_(programming_language)

Python 1 was released in 1994, and 2 in 2000. They had their chance to make breaking changes. https://en.wikipedia.org/wiki/History_of_Python

While you're right that Python predates Java, it's not by as many years as claimed.

> Various OOP concepts that are much better explained in Java than Python

To exemplify, here is how you figure out how to override `==`: https://docs.python.org/3/library/stdtypes.html#comparisons , https://docs.python.org/3/reference/expressions.html#express... . Notably, there is no documentation for object.__eq__().

Here is the Java version: https://docs.oracle.com/en/java/javase/23/docs/api/java.base...

Now for __hash__() / hashCode(), the Java version is clearer: https://docs.python.org/3/reference/datamodel.html#object.__... , https://docs.oracle.com/en/java/javase/23/docs/api/java.base...

Python __del__ is buried in the "Data model" page: https://docs.python.org/3/reference/datamodel.html#object.__... . Java's finalize() is easily found on Object: https://docs.oracle.com/en/java/javase/23/docs/api/java.base... . Furthermore, Joshua Bloch's book "Effective Java" has a chapter titled "Avoid finalizers and cleaners" that explains in detail why finalizers are problematic.

Python explains a lot less about weakref than Java: https://docs.python.org/3/library/weakref.html , https://docs.oracle.com/javase/8/docs/api/java/lang/ref/pack...

> Java is a pure-OO language

Extremely wrong. Java has primitive numeric types, which do not have methods or fields, and undergo painful boxing/unboxing conversions to interoperate with the OO world. Whether the performance benefits are worth it or not is debatable, but what's not debatable is that Java is not pure OOP. Some say that Java is a bad copy of Smalltalk, which I heard is fully object-oriented.

> Python is a procedural language with OO as an optional feature

Wrong. Every Python value is an object that can be inspected (dir(), .__dict__, etc.). And in the CPython API, every Python value is a PyObject*. I have ample grounds to believe that Python is more OO than Java.

thread