61 docs tagged with "books"

A complete index of every item in *Effective Java (3rd Edition)* with links to the relevant chapter documentation.

Why clean code matters, the cost of bad code, and what experts say good code looks like.

Most modern applications are **data-intensive**, not compute-intensive. The bottleneck is rarely the CPU — it's the amount of data, how fast it changes, and.

**Part I — Foundation**

So far the book has focused on systems that handle requests as they arrive (OLTP) or read/write in real-time. But some of the most important data processing.

Designing small, cohesive classes with a single responsibility and organizing them for change.

When used to best advantage, exceptions can improve a program's readability, reliability, and maintainability. When used improperly, they can have the opposite.

**Part II — Implementation**

Threads allow multiple activities to proceed concurrently. Concurrent programming is harder than single-threaded programming because more things can go wrong.

**Part II — Implementation**

Batch processing has one problem: **latency**. A job that runs once a day means insights that are 24 hours stale. Stream processing is like a continuous batch.

Separating system construction from use, dependency injection, and scaling clean architecture.

Kent Beck's four rules of simple design and how following them leads to emergent good design.

**Part II — Implementation**

This chapter concerns **object serialization** — Java's framework for encoding objects as byte streams (*serializing*) and reconstructing objects from their.

The final chapter synthesizes everything in the book and looks forward. It addresses two questions:

The challenges of concurrent programming and principles for writing safe, clean concurrent code.

**Part II — Implementation**

A case study showing how iterative refactoring transforms a messy first draft into clean code.

**Part II — People**

A case study refactoring real JUnit source code to demonstrate clean code principles in practice.

**Part III — People**

A thorough case study refactoring a real-world date library to illustrate deep clean code principles.

**Part III — People**

A comprehensive catalog of code smells and heuristics for identifying and fixing bad code.

This chapter covers the full lifecycle of objects: when and how to create them, when and how to avoid creating them, how to ensure they are destroyed in a.

Data models are probably the most important part of developing software — they shape not just how we write the code, but how we *think about the problem*. Each.

**Part I — Foundation**

How to choose names that reveal intent and make code self-documenting.

Rules for writing small, focused functions that do exactly one thing well.

Although `Object` is a concrete class, it is designed primarily for extension. All of its nonfinal methods (`equals`, `hashCode`, `toString`, `clone`, and.

**Part I — Foundation**

As an application developer, you usually just call your database and trust it to do the right thing. But to choose the right database and tune it properly, you.

Classes and interfaces are the heart of the Java programming language. This chapter gives guidelines for making the best use of these language elements so that.

When comments help, when they hurt, and why good code rarely needs them.

Applications change over time — requirements evolve, new features are added, bugs are fixed. Your data model must evolve too. But in large systems, you can't.

**Part I — Foundation**

Code formatting as communication — how visual structure conveys meaning and intent.

Generics were added in Java 5. Before generics, you had to cast every object read from a collection — if someone accidentally inserted an object of the wrong.

**Part II — Implementation**

**Replication** means keeping a copy of the same data on multiple machines (connected via a network). Reasons to replicate:

Java supports two special-purpose families of reference types: *enum types* (a kind of class) and *annotation types* (a kind of interface). This chapter.

The fundamental tension between objects and data structures, and when to use each.

For very large datasets or very high query throughput, a single machine is not enough. **Partitioning** (also called sharding) breaks the data into.

**Part II — Implementation**

**Part II — Implementation**

Writing error handling that is robust, clean, and doesn't obscure your business logic.

Java 8 added lambda expressions, method references, and the Streams API. This chapter covers best practices for using these powerful new facilities.

Real applications are messy — the database can crash, network connections can drop, multiple clients write concurrently, and partial reads of partially updated.

Strategies for cleanly integrating third-party code and managing the edges of your system.

**Part II — Implementation**

This chapter discusses several aspects of method design: how to treat parameters and return values, how to design method signatures, and how to document.

Working with distributed systems requires a fundamentally different mindset than single-machine programming. In a single process, if something works once, it.

Chapter 8 cataloged everything that can go wrong in distributed systems. This chapter asks: **given all those failure modes, what guarantees can we actually.

This chapter covers the nuts and bolts of Java programming: local variables, control structures, libraries, data types, and using two non-language features.

**Part II — Implementation**

Why tests must be clean, what makes a good test, and the F.I.R.S.T. principles.

Modern applications are not **compute-intensive** (CPU is rarely the bottleneck) — they are **data-intensive**. The real challenges are:

This guide provides a detailed, chapter-by-chapter breakdown of Sam Newman's *Building Microservices* (2nd Edition).

Clean Code - A Handbook of Agile Software Craftsmanship by Robert C. Martin

**Effective Java (3rd Edition)** by Joshua Bloch is the definitive guide to writing correct, efficient, and maintainable Java code. It contains **90 items** -.