Index
A
- abstractions, Declarative Expression Is the Path to Parallelism
- acceptance tests, Feedback Loops
- access modifiers, Package-by-Feature with the Default Access Modifier
- actor model, Concurrency on the JVM
- Akka, Concurrency on the JVM
- algorithms, The JVM Is a Multiparadigm Platform: Use This to Improve Your Programming
- aliasing, Simple Value Objects
- allocation size and rate, Java Programming from a JVM Performance Perspective
- analytics and data, using to test software, Feedback Loops
- Android, Interop with Kotlin, Thinking in Coroutines
- annotations
- anticorruption layer, Behavior Is “Easy”; State Is Hard
- Apache Groovy (see Groovy)
- APIs
- application frameworks, All You Need Is Java
- application servers, Follow the Boring Standards
- approval testing, Approval Testing
- architectural quality, benefits of codifying and asserting, The Benefits of Codifying and Asserting Architectural Quality
- ArchUnit, The Benefits of Codifying and Asserting Architectural Quality, Use Custom Identity Annotations Liberally
- arrange–act–assert (tests), Program with GUTs
- AsciiDoc
- aspect-oriented programming (AOP), Use Custom Identity Annotations Liberally
- AsyncGetCallTrace, Firing on All Engines
- auditability, improving with continuous delivery, Improving Repeatability and Auditability with Continuous Delivery
- automated testing, Break Problems and Tasks into Small Chunks, Use Testing to Develop Better Software Faster
- autonomy, Production Is the Happiest Place on Earth
- @Autowired annotation, Minimal Constructors
- availability, Trade-Offs in a Microservices Architecture
B
- backend developers, “Full-Stack Developer” Is a Mindset
- backward compatibility, From Puzzles to Products
- Bazel, Only Build the Parts That Change and Reuse the Rest
- benchmarking
- better software, Deliver Better Software, Faster
- big data frameworks, Know Thy flatMap
- bin/ directory, There Are Great Tools in Your bin/ Directory
- block comments, Kinds of Comments
- boilerplate, Embrace SQL Thinking, Java Should Feel Fun, Kotlin Is a Thing, Simple Value Objects, Take Good Care of Your Dependencies
- Boolean values, refactoring to enumerations, Refactor Boolean Values to Enumerations
- browsers, backward compatibility of, Follow the Boring Standards
- bugs in proportion to lines of code, Read OpenJDK Daily
- build tool runtime, standardized version of, “But It Works on My Machine!”
- builds
- business logic frameworks, All You Need Is Java
- byte code instrumentation, Firing on All Engines
- bytecode
C
- C, Think Outside the Java Sandbox
- C#, Uncheck Your Exceptions
- caching, Inline Thinking
- CAP theorem, Trade-Offs in a Microservices Architecture
- certifications in Java, Java Certifications: Touchstone in Technology
- character encodings, Really Looking Under the Hood
- checked exceptions, Uncheck Your Exceptions
- CI/CD
- class files, modifying in the filesystem, How to Crash Your JVM
- class libraries in Java, All You Need Is Java
- classes
- Clojure, Think Outside the Java Sandbox
- cloud-native applications, Really Looking Under the Hood
- code
- code change vs. system change, From Puzzles to Products
- code katas, Learn to Kata and Kata to Learn
- code restorers, The Code Restorer
- collections
- command line, Don’t hIDE Your Tools
- comments, Kinds of Comments
- commits, frequent, Break Problems and Tasks into Small Chunks
- common Java interview questions, Technical Interviewing Is a Skill Worth Developing
- Communicating Sequential Processes (CSP), Threads Are Infrastructure; Treat Them as Such
- communication and clarity, It’s Done, But…
- community
- compilation, build tool caching of, Only Build the Parts That Change and Reuse the Rest
- compilers
- components, events between, Events Between Java Components
- composite keys, Hey Fred, Can You Pass Me the HashMap?
- computeStatData method, Learn to Use New Java Features
- concurrency
- concurrent garbage collectors, Garbage Collection Is Your Friend
- conditions, Learn Java Idioms and Cache in Your Brain
- consistency, Trade-Offs in a Microservices Architecture
- constructors, minimal, Minimal Constructors
- containers
- continuous integration (CI) builds, Builds Don’t Have To Be Slow and Unreliable
- contract testing, tools for, Use Testing to Develop Better Software Faster
- contributors, -
- cooperation as highly valued trait, Build Diverse Teams
- Coordinated Universal Time (UTC), Do You Know What Time It Is?
- copying, garbage collection by, Garbage Collection Is Your Friend
- coroutines, Kotlin Is a Thing
- correctness, obsessing over, vs. optimizing for change, From Puzzles to Products
- CountDownLatch, CountDownLatch—Friend or Foe?
- coverage, improving unit tests, Use Coverage to Improve Your Unit Tests
- curiosity, The Three Traits of Really, Really Good Developers
- CyclicBarrier, CountDownLatch—Friend or Foe?
D
- Dart, Think Outside the Java Sandbox
- data engineers, Know Thy flatMap
- data migrations, From Puzzles to Products
- data structures, interview questions about, Technical Interviewing Is a Skill Worth Developing
- data types
- databases, “Full-Stack Developer” Is a Mindset
- date and time
- daylight saving time (DST), Do You Know What Time It Is?
- debugging
- declarative programming, Declarative Expression Is the Path to Parallelism
- definition of done, It’s Done, But…
- delivering better software, faster, Deliver Better Software, Faster
- dependencies
- dependency injection frameworks, caution with, Minimal Constructors
- deployment
- designing change, From Puzzles to Products
- Developer Productivity Engineering, Builds Don’t Have To Be Slow and Unreliable
- developers, really good, traits of, The Three Traits of Really, Really Good Developers
- DevOps engineers, “Full-Stack Developer” Is a Mindset
- disk space, filling up, How to Crash Your JVM
- diversity on development teams, Build Diverse Teams
- DocBook XML, Augment Javadoc with AsciiDoc
- Docker containers
- documentation
- domain models, primitive obsession in, Refactor Boolean Values to Enumerations
- domain-driven design, ubiquitous vocabulary, Get Better at Naming Things
- domain-specific languages (DSLs), Embrace SQL Thinking
- done, definition of, It’s Done, But…
E
- Eden, The Young, the Old, and the Garbage
- Einstein (developer persona), All You Need Is Java
- Elvis (developer persona), All You Need Is Java
- empathy and imagination, The Three Traits of Really, Really Good Developers
- encapsulation
- enumerations, refactoring Boolean values to, Refactor Boolean Values to Enumerations
- environment your software is running in, experimenting with, How to Crash Your JVM
- events between Java components, Events Between Java Components
- exceptions, Uncheck Your Exceptions
- ExecutorService, CountDownLatch—Friend or Foe?
F
- failing tests, Use Testing to Develop Better Software Faster
- failures, testing against, Frequent Releases Reduce Risk
- faster delivery of better software, Deliver Better Software, Faster
- fat JARs, case against, The Case Against Fat JARs
- feature flags, From Puzzles to Products
- feedback loops, Feedback Loops
- file I/O, idiom for, Learn Java Idioms and Cache in Your Brain
- files, opening as many as possible, How to Crash Your JVM
- filters, Know Thy flatMap
- final fields in value objects, Simple Value Objects
- final variables, Don’t Vary Your Variables, Read OpenJDK Daily
- flaky tests, Builds Don’t Have To Be Slow and Unreliable
- flame graphs, Firing on All Engines
- flatMap, Optional Is a Lawbreaking Monad but a Good Type
- Flutter, Think Outside the Java Sandbox
- Fork/Join framework, Threads Are Infrastructure; Treat Them as Such
- fractions, adding, as simple coding kata, Take “Separation of Concerns” Seriously
- FrameMaker, Augment Javadoc with AsciiDoc
- frameworks
- Frege, Think Outside the Java Sandbox
- frontend developers, “Full-Stack Developer” Is a Mindset
- frontend development, “Full-Stack Developer” Is a Mindset
- frontends, building without frameworks, Follow the Boring Standards
- full-stack deveopers, “Full-Stack Developer” Is a Mindset
- fun with Java, Java Should Feel Fun
- functional programming, Make Code Simple and Readable
- fuzz testing, The Unreasonable Effectiveness of Fuzz Testing
G
- garbage collection
- algorithms for, Really Looking Under the Hood
- JVM performance and, Java Programming from a JVM Performance Perspective
- references and, The Young, the Old, and the Garbage
- strategies, The Young, the Old, and the Garbage
- tasks of garbage collector, The Young, the Old, and the Garbage
- unsung hero of Java, Garbage Collection Is Your Friend
- generation-based fuzzers, The Unreasonable Effectiveness of Fuzz Testing
- generational hypothesis, Garbage Collection Is Your Friend
- getter methods, Learn to Use New Java Features
- getters and setters
- given–when–then, Program with GUTs
- Go language, Think Outside the Java Sandbox
- golden master testing, Approval Testing
- (see also approval testing)
- Gradle, Only Build the Parts That Change and Reuse the Rest
- Gradle Wrapper, “But It Works on My Machine!”
- Groovy, Open Source Projects Aren’t Magic
- GUTs (good unit tests), Program with GUTs
I
- idioms (Java), Learn Java Idioms and Cache in Your Brain
- imagination, The Three Traits of Really, Really Good Developers
- immutability
- imperative and declarative thinking, The JVM Is a Multiparadigm Platform: Use This to Improve Your Programming
- imperative programming, Declarative Expression Is the Path to Parallelism
- implicit iteration, The JVM Is a Multiparadigm Platform: Use This to Improve Your Programming
- inconsistent state, difficulty of debugging, Behavior Is “Easy”; State Is Hard
- indentation in code, Make Code Simple and Readable
- industrial-strength technologies, necessity of, The Necessity of Industrial-Strength Technologies
- infrastructure as code, “But It Works on My Machine!”
- inheritance, Behavior Is “Easy”; State Is Hard
- initializing variables to null, avoiding, How to Avoid Null
- @Inject annotation, Minimal Constructors
- inline types, Inline Thinking
- Instant, Do You Know What Time It Is?
- integrated development environments (IDEs)
- integration testing, Unlocking the Hidden Potential of Integration Testing Using Containers, Use Testing to Develop Better Software Faster
- interfaces, large, breaking into smaller pieces, Let’s Make a Contract: The Art of Designing a Java API
- interoperability with Kotlin, Interop with Kotlin
- interviewing developers, Technical Interviewing Is a Skill Worth Developing
- issue trackers, Open Source Projects Aren’t Magic
J
- JARs, In the Language Wars, Java Holds Its Own
- Java
- advantages of, In the Language Wars, Java Holds Its Own
- certifications in, Java Certifications: Touchstone in Technology, Why I Don’t Hold Any Value in Certifications
- class libraries, All You Need Is Java
- design and background, In the Language Wars, Java Holds Its Own
- disadvantages of, In the Language Wars, Java Holds Its Own
- evolving nature of, Keep Your Finger on the Pulse
- interoperability with Kotlin, Interop with Kotlin
- learning idioms, Learn Java Idioms and Cache in Your Brain
- learning to use new features, Learn to Use New Java Features
- making code simple and readable, Make Code Simple and Readable
- 1990s design, Java Is a ’90s Kid
- programming from JVM performance perspective, Java Programming from a JVM Performance Perspective
- programming that is fun, Java Should Feel Fun
- really looking under the hood, Really Looking Under the Hood
- rebirth of, The Rebirth of Java
- revolutionary changes in, The JVM Is a Multiparadigm Platform: Use This to Improve Your Programming
- using Groovy with, Make Your Java Groovier
- Java Memory Model, Concurrency on the JVM
- java.time library, Do You Know What Time It Is?, Name the Date
- java.util.Date, Java Is a ’90s Kid, Name the Date
- javac, Don’t hIDE Your Tools
- Javadoc, Augment Javadoc with AsciiDoc
- JavaFX bar chart, Learn to Use New Java Features
- javap, There Are Great Tools in Your bin/ Directory
- JavaScript, Think Outside the Java Sandbox
- jconsole, There Are Great Tools in Your bin/ Directory
- JCP (Java Community Process) Program and how to participate, What Is the JCP Program and How to Participate
- jhat, There Are Great Tools in Your bin/ Directory
- jinfo, There Are Great Tools in Your bin/ Directory
- jmap, There Are Great Tools in Your bin/ Directory
- JMH (Java Microbenchmarking Harness), Benchmarking Is Hard—JMH Helps
- Joyce, Bruce, All You Need Is Java
- JPA/Hibernate implementations, Really Looking Under the Hood
- jps, There Are Great Tools in Your bin/ Directory
- jshell, There Are Great Tools in Your bin/ Directory, Think Outside the Java Sandbox
- JsonSlurper, Make Your Java Groovier
- jstack, There Are Great Tools in Your bin/ Directory
- JUnit testing framework, Approval Testing, The Benefits of Codifying and Asserting Architectural Quality
- jvisualvm, There Are Great Tools in Your bin/ Directory
- JVMs
- adaptive JVM, demanding, Java Programming from a JVM Performance Perspective
- AsyncGetCallTrace feature, Firing on All Engines
- concurrency on, Concurrency on the JVM
- difficulty of benchmarking and microbenchmarking on, Benchmarking Is Hard—JMH Helps
- finding ways to crash the JVM, How to Crash Your JVM
- GC strategies varying by implementation, Garbage Collection Is Your Friend
- graphical tools for connecting to/running JVMs, There Are Great Tools in Your bin/ Directory
- Java programming from JVM performance perspective, Java Programming from a JVM Performance Perspective
- JVM ergonomics, Be Aware of Your Container Surroundings
- multiparadigm JVM, using to improve programming, The JVM Is a Multiparadigm Platform: Use This to Improve Your Programming
- older, running inside Docker containers, Be Aware of Your Container Surroundings
- parameters configured by JVM ergonomics, Be Aware of Your Container Surroundings
- profilers, Really Looking Under the Hood
- rediscovering the JVM through Clojure, Rediscover the JVM Through Clojure
L
- lambda expressions, The JVM Is a Multiparadigm Platform: Use This to Improve Your Programming
- lambdas, Concurrency on the JVM, Java Should Feel Fun, Learn to Use New Java Features, Make Code Simple and Readable, Really Looking Under the Hood
- LaTeX formats, use with AsciiDoc, Augment Javadoc with AsciiDoc
- launching multiple concurrent tasks, CountDownLatch—Friend or Foe?
- layer-based access rules, enforcing with ArchUnit, The Benefits of Codifying and Asserting Architectural Quality
- legacy code, Learn to Love Your Legacy Code
- libraries, All You Need Is Java
- line comments, Kinds of Comments
- listeners
- lists
- LocalDateTime, Do You Know What Time It Is?
- localizing variable scope, Don’t Vary Your Variables
- locks, Threads Are Infrastructure; Treat Them as Such
- long-term stability in development, encouraging, The Code Restorer
- Long-Term Supported (LTS) Java versions, The Rebirth of Java
- looping, Learn Java Idioms and Cache in Your Brain
M
- magic type, using var as, Java’s Unspeakable Types
- many-to-one relationships, Really Looking Under the Hood
- maps, Know Thy flatMap
- mark-and-sweep garbage collection, Garbage Collection Is Your Friend
- markup formats (lightweight), Augment Javadoc with AsciiDoc
- MathML formats, using wih AsciiDoc, Augment Javadoc with AsciiDoc
- Maven, Only Build the Parts That Change and Reuse the Rest
- Maven Wrapper, “But It Works on My Machine!”
- memory
- message flow between actors, implementing concurrency, Concurrency on the JVM
- meta guiding in speed-reading, Refactoring Toward Speed-Reading
- method references, The JVM Is a Multiparadigm Platform: Use This to Improve Your Programming, Learn to Use New Java Features
- methods
- microbenchmarking, Benchmarking Is Hard—JMH Helps
- microservices, Production Is the Happiest Place on Earth
- module declarations, Take Care of Your Module Declarations
- monads, Optional Is a Lawbreaking Monad but a Good Type
- Mort (developer persona), All You Need Is Java
- multiparadigm languages, The JVM Is a Multiparadigm Platform: Use This to Improve Your Programming
- multithreading
- mutation testing, tool for, Use Testing to Develop Better Software Faster
- mutation-based fuzzers, The Unreasonable Effectiveness of Fuzz Testing
- mutexes, Threads Are Infrastructure; Treat Them as Such
N
- naming
- naming conventions
- native code, writing, How to Crash Your JVM
- Noda Time (.NET), Do You Know What Time It Is?
- Node.js, Think Outside the Java Sandbox
- non-heap/perm (memory), The Young, the Old, and the Garbage
- nondenotable types, Java’s Unspeakable Types
- NoSQL databases, “Full-Stack Developer” Is a Mindset
- noun phrases for class names, Get Better at Naming Things
- nulls, How to Avoid Null
O
- object locality, Garbage Collection Is Your Friend
- object-oriented langauges, The JVM Is a Multiparadigm Platform: Use This to Improve Your Programming
- object-oriented principles, using in test code, Using Object-Oriented Principles in Test Code
- object-relational mappers (ORMs), Embrace SQL Thinking
- objects
- observability, From Puzzles to Products, Production Is the Happiest Place on Earth
- old generation, The Young, the Old, and the Garbage
- one-to-many relationships, Really Looking Under the Hood
- open source projects, Open Source Projects Aren’t Magic
- OpenJDK, Read OpenJDK Daily
- Optional, How to Avoid Null, Let’s Make a Contract: The Art of Designing a Java API
- Oracle Corporation, professional certifications in Java, Java Certifications: Touchstone in Technology, Why I Don’t Hold Any Value in Certifications
- ordered collections, Know Your Collections
- overengineering, avoiding, Make Code Simple and Readable
- overfitting tests, Program with GUTs
P
- package-by-feature with default access modifier, Package-by-Feature with the Default Access Modifier
- package-private access, Package-by-Feature with the Default Access Modifier
- Page Object Model design pattern, Using Object-Oriented Principles in Test Code
- pair programming, Feedback Loops, Make Code Simple and Readable
- parallelism
- parameters
- partition tolerance, Trade-Offs in a Microservices Architecture
- performance tests, tools for, Use Testing to Develop Better Software Faster
- performance, improvement through efficient garbage collection, Garbage Collection Is Your Friend
- Perl, Think Outside the Java Sandbox
- personalities within development teams, Build Diverse Teams
- phantom references, The Young, the Old, and the Garbage
- polymorphism, Behavior Is “Easy”; State Is Hard
- primitive types, Java Is a ’90s Kid
- problems, breaking into chunks, Break Problems and Tasks into Small Chunks
- process ID, finding and killing, How to Crash Your JVM
- production environment, loving, Production Is the Happiest Place on Earth
- profilers (JVM), Really Looking Under the Hood
- profiling code, Firing on All Engines
- profit, focus on, The Code Restorer
- programmatic documentation, identity notations as, Use Custom Identity Annotations Liberally
- programming languages
- psychological safety, Build Diverse Teams
- puzzles to products, From Puzzles to Products
- Python, Think Outside the Java Sandbox
R
- R, Think Outside the Java Sandbox
- RAM, high cost of reading from, Inline Thinking
- reactive programming, Concurrency on the JVM
- readable and simple code, Make Code Simple and Readable
- readable code, writing, Write “Readable Code”
- reading code using speed-reading, Refactoring Toward Speed-Reading
- record syntax (Java 14), Learn to Use New Java Features, Simple Value Objects
- Red, Green, Refactor process in TDD, Test-Driven Development
- refactoring, Test-Driven Development
- reference types, Inline Thinking
- references, GC collection of, The Young, the Old, and the Garbage
- relational constraints in SQL queries, Embrace SQL Thinking
- relational databases, “Full-Stack Developer” Is a Mindset
- relationship names for entity pairs, Get Better at Naming Things
- release cycles for Java, Learn to Use New Java Features, The Rebirth of Java
- releases
- repeatability, improving with continuous delivery, Improving Repeatability and Auditability with Continuous Delivery
- REPL (read–eval–print loop), Rediscover the JVM Through Clojure
- REST APIs, Approval Testing
- returning null, avoiding, How to Avoid Null
- risk
- Ruby, Think Outside the Java Sandbox
- Rust, Think Outside the Java Sandbox
S
- sampling by Java profilers, Firing on All Engines
- Scala, The JVM Is a Multiparadigm Platform: Use This to Improve Your Programming, Think Outside the Java Sandbox
- scalable vector graphics (SVGs), generation by profiler tools, Firing on All Engines
- scope, localizing for variables, Don’t Vary Your Variables
- separation of concerns, taking seriously, Take “Separation of Concerns” Seriously
- serverless architectures, All You Need Is Java
- servlets, Keep Your Finger on the Pulse
- Set, Know Your Collections
- shared memory multithreading, Threads Are Infrastructure; Treat Them as Such
- short-term focus in development, problems with, The Code Restorer
- SlimFast (Maven plug-in), The Case Against Fat JARs
- snapshot testing, Approval Testing
- sockets, opening as many as possible, How to Crash Your JVM
- soft references, The Young, the Old, and the Garbage
- software architectures, Trade-Offs in a Microservices Architecture
- sorted collections, Know Your Collections
- specifications for Java technologies, What Is the JCP Program and How to Participate
- speed-reading, refactoring toward, Refactoring Toward Speed-Reading
- SQL
- stack traces
- standards
- state
- stop-the-world garbage collectors, Garbage Collection Is Your Friend
- strangler pattern, Learn to Love Your Legacy Code
- streaming libraries, Know Thy flatMap
- streams, Learn Java Idioms and Cache in Your Brain, Let’s Make a Contract: The Art of Designing a Java API, Make Code Simple and Readable, Really Looking Under the Hood
- subvocalization, Refactoring Toward Speed-Reading
- survivors, The Young, the Old, and the Garbage
- Swing, Keep Your Finger on the Pulse
- synchronized statements, Threads Are Infrastructure; Treat Them as Such
- system change, From Puzzles to Products
- System.exit, creating class at runtime that calls, How to Crash Your JVM
T
- Takari (Maven plug-in), “But It Works on My Machine!”
- tasks, breaking into chunks, Break Problems and Tasks into Small Chunks
- TCP/IP networking, Really Looking Under the Hood
- teams, successful and diverse, building, Build Diverse Teams
- technical interviewing, learning skills in, Technical Interviewing Is a Skill Worth Developing
- test automation, Use Testing to Develop Better Software Faster
- test-driven development (TDD), Test-Driven Development
- testing
- testing frameworks, classic, Approval Testing
- threads
- three-tier architecture, business applications, Package-by-Feature with the Default Access Modifier
- Throwable class, Uncheck Your Exceptions
- throws clause, Uncheck Your Exceptions
- time, Do You Know What Time It Is?
- TimeZone with UTC offsets and daylight saving time rules, Do You Know What Time It Is?
- tools
- touchstone, Java Certifications: Touchstone in Technology
- traits of really good developers, The Three Traits of Really, Really Good Developers
- trust among team members, Build Diverse Teams
U
- ubiquitous vocabulatory, Get Better at Naming Things
- unchecked exceptions, Uncheck Your Exceptions
- underfitting tests, Program with GUTs
- undifferentiated heavy lifting, Production Is the Happiest Place on Earth
- unhandled checked exceptions, Uncheck Your Exceptions
- unit of test (UoT), isolating, Java Programming from a JVM Performance Perspective
- unit testing frameworks
- unit tests, Feedback Loops
- unknown unknowns, testing and, Frequent Releases Reduce Risk
- unordered collections, Know Your Collections
- unreliable builds, Builds Don’t Have To Be Slow and Unreliable
- Unsafe class, How to Crash Your JVM
- unsorted collections, Know Your Collections
V
- value objects, simple, Simple Value Objects
- varargs, Let’s Make a Contract: The Art of Designing a Java API
- variables
- variables, not varying, Don’t Vary Your Variables
- verbose code, avoiding, Make Code Simple and Readable
- verbosity of Java, In the Language Wars, Java Holds Its Own, Java Should Feel Fun, Make Your Java Groovier
- vocabulary, development in writing programs, Hey Fred, Can You Pass Me the HashMap?
- vulnerabilities in dependencies, Take Good Care of Your Dependencies
W
- weak references, The Young, the Old, and the Garbage
- web development technologies, “Full-Stack Developer” Is a Mindset
- web/JavaScript ecosystem, lack of standardization in frameworks, Follow the Boring Standards
- Windows, running Maven Wrapper goals on, “But It Works on My Machine!”
- WORA (write once, run anywhere) principle, In the Language Wars, Java Holds Its Own
- wrappers, “But It Works on My Machine!”
..................Content has been hidden....................
You can't read the all page of ebook, please click
here login for view all page.