Home
Welcome to the official architectural companion for the Exploring Java Libraries ecosystem.
This repository is not just a collection of examples.
It is a structured engineering knowledge system designed to help developers move from:
“I know how to use Java” to “I understand how Java behaves under real-world conditions”
Target Audience: This resource is explicitly designed for developers who already know Java syntax but want to understand underlying system behavior. This is not a tutorial dump or a quick-fix copy-paste repository.
| ⚡ I/O Systems | ⚙️ Concurrency | 🧠 Runtime | 🚀 Performance |
|---|
Modern Java development suffers from a fundamental gap:
- Documentation explains APIs
- Tutorials demonstrate usage
- But very few resources explain system behavior under load
That gap leads to:
- inefficient architectures
- misuse of concurrency primitives
- performance bottlenecks
- production debugging complexity
- hidden costs that only appear at scale
This project exists to bridge that gap by exposing the runtime, concurrency, I/O, and performance mechanics underneath the Java language.
To bridge the gap between:
API-level knowledge → System-level understanding
This repository + wiki is built as a serious learning system for engineers, not a tutorial dump.
By completing this knowledge hub, you will master:
- NIO & I/O Flow: How to design non-blocking systems and multiplexed architectures.
- Concurrency Primitives: How to safely coordinate work using thread pools, locks, and atomic operations.
- The Java Memory Model: How visibility and happens-before relationships govern multi-core execution.
- JVM Runtime Mechanics: How class loading, JIT compilation, and reflection impact system design.
- Performance Resilience: How to apply backpressure, event loops, and Mechanical Sympathy to survive extreme load.
Javadocs tell you what a method does.
This project explains:
- how it behaves internally
- why it behaves that way
- what happens under real-world load
- where the hidden costs and failure modes appear
We focus on:
- system-level behavior
- performance characteristics
- architectural trade-offs
- production-grade patterns
The philosophy is simple:
Understand the system first. Then write the code.
That is the difference between memorizing Java and engineering with Java.
This Wiki is structured like a technical architecture map, not a blog.
These pages explain how data enters, moves through, and is coordinated inside Java systems.
- 01-Core-Overview
- 01-NIO-Selector-Architecture
- 01-NIO-Blocking-vs-NonBlocking
- 01-NIO-Channel-Buffer-Model
These pages cover:
- blocking vs non-blocking I/O
- channels and buffers
- selectors and readiness
- OS-level event notification
- event-driven networking foundations
These pages explain how Java executes work safely and efficiently.
These pages cover:
- concurrency vs parallelism
- thread pools and queueing
- task submission and futures
- cancellation and shutdown
- memory visibility and ordering
- atomicity, locks, and happens-before
These pages explain what happens after code is compiled and loaded into the JVM.
These pages cover:
- JVM runtime architecture
- JIT compilation
- garbage collection
- runtime memory areas
- reflection and metaprogramming
- class loading, delegation, and isolation
These pages explain how to design and tune Java systems for stability, throughput, and low latency.
These pages cover:
- profiling and bottleneck analysis
- JVM performance thinking
- event loop architecture
- reactive and non-blocking control flow
- backpressure and overload protection
This section is the reference backbone of the Wiki. It ensures credibility by linking to official RFCs, Netty documentation, JVM specifications, and academic papers.
- 🛠️ 99-Resources — A curated library containing essential books, official docs, JVM profiling tools (e.g., async-profiler, JMH), benchmark suites, and deep-dive references.
Pro-Tip: Encountering unfamiliar terms like Mechanical Sympathy, Tail Latency, or Backpressure? Check our 99-Resources for a comprehensive engineering glossary.
The Wiki explains the system.
The repository shows it in action.
👉 https://github.com/SolisDynamics/exploring-java-libraries-1
Inside src/main/java:
-
com.solisdynamics.nio.*→ NIO, selectors, buffers -
com.solisdynamics.concurrent.*→ threading and execution -
com.solisdynamics.runtime.*→ reflection and class loading
Each example demonstrates:
- real-world behavior
- edge cases
- performance implications
- architectural trade-offs
This Wiki works best when used as a guided path, not as random reference material.
Focus on understanding the landscape before diving into the code.
-
Path:
[[01-Core-Overview]]➞[[02-Concurrency-Overview]]➞[[03-Runtime-Overview]]➞[[04-Performance-Overview]]
Learn how major subsystems behave and interact under standard conditions.
-
Path:
[[01-NIO-Channel-Buffer-Model]]➞[[02-Thread-Pool-Mechanics]]➞[[03-Reflection-Internals]]➞[[01-NIO-Blocking-vs-NonBlocking]]
Understand bottlenecks, extreme scale, and resilience patterns.
-
Path:
[[01-NIO-Selector-Architecture]]➞[[02-Java-Memory-Model]]➞[[04-Event-Loop-Design]]➞[[04-Backpressure-Strategies]]
Focus on performance, architecture, and system behavior under load.
This Wiki represents only a small portion of the full research.
The complete system includes:
- full architectural breakdowns
- extended real-world scenarios
- advanced performance strategies
- production-grade design patterns
- JVM control flags
- runtime behavior models
- concurrency failure modes
- overload control strategies
The goal is not just to read the pages. The goal is to build a mental model that scales with the complexity of real systems.
This Wiki represents only a small portion of the full research. The complete system provides a mental model that scales with the complexity of real systems.
"The Engine Room of Java."
733+ pages of intensive engineering insights. Master the raw mechanics of high-performance backend systems.
| 🛒 Store | Direct Access Link |
|---|---|
| Gumroad | 🚀 Get Immediate Access |
| Leanpub | 📖 Read on Leanpub |
| Amazon | 📦 Order on Amazon |
| Google Play | 📱 Digital Edition |
- 💻 Code Repository: Exploring Java Libraries 1
"Architecting the User Experience."
900+ pages focusing on advanced runtime behaviors, desktop architectures, and the complex Event Dispatch Thread.
| 🛒 Store | Direct Access Link |
|---|---|
| Gumroad | 🚀 Get Immediate Access |
| Leanpub | 📖 Read on Leanpub |
| Amazon | 📦 Order on Amazon |
| Google Play | 📱 Digital Edition |
- 💻 Code Repository: Exploring Java Libraries 2
- Production-Ready: Every chapter is written with real-world failure modes in mind.
- Massive Scope: Over 1,600 combined pages of deep-layer technical research.
- Runnable Knowledge: Paired with extensive GitHub repositories for hands-on learning.
This project is intended to be useful, reusable, and extensible.
Useful contributions include:
- corrections
- clarifications
- examples
- performance notes
- architecture improvements
- edge cases
- additional references
- production lessons learned
The Wiki becomes stronger when it reflects real engineering experience.
This is not a beginner tutorial repository.
If you are looking for quick copy-paste solutions, this system may feel unusually deep.
If your goal is to:
- understand how Java works under real load
- design scalable systems
- debug performance issues
- reason about concurrency correctly
- build strong architectural intuition
then you are in the right place.
If you are new to the system, begin with:
If you already know the basics, start with:
Most developers learn Java. Very few understand it deeply enough to predict how it behaves under pressure. That difference matters.
It separates:
coders → engineers
This Wiki exists to help you make that transition.