-
Notifications
You must be signed in to change notification settings - Fork 0
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”
Modern Java development suffers from a fundamental gap:
- Documentation explains APIs
- Tutorials demonstrate usage
- But very few resources explain system behavior under load
This leads to:
❌ Inefficient architectures
❌ Misuse of concurrency primitives
❌ Performance bottlenecks
❌ Production debugging complexity
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.
Javadoc tells you what a method does.
This project explains:
- How it behaves internally
- Why it behaves that way
- What happens under real-world load
We focus on:
✔ System-level behavior
✔ Performance characteristics
✔ Architectural trade-offs
✔ Production-grade patterns
This Wiki is structured like a technical architecture map, not a blog.
👉 01-Core-Overview
System-level overview of Java I/O architecture.
👉 01-NIO-Selector-Architecture
Non-blocking I/O internals, event loops, OS-level multiplexing.
👉 01-NIO-Blocking-vs-NonBlocking
Thread-per-connection vs event-driven systems.
👉 01-NIO-Channel-Buffer-Model
How data flows through buffers and channels.
👉 02-Concurrency-Overview
Mental model for concurrency systems.
👉 02-Thread-Pool-Mechanics
Thread pool lifecycle and real-world behavior.
👉 02-ExecutorService-Internals
Execution pipelines and scheduling internals.
👉 02-Java-Memory-Model
Visibility, ordering, and correctness.
👉 03-Runtime-Overview
How Java behaves at runtime.
👉 03-Reflection-Internals
Cost, caching, and dynamic invocation.
👉 03-ClassLoader-Architecture
Class loading, isolation, and delegation.
👉 04-Performance-Overview
System-level performance thinking.
👉 04-Event-Loop-Design
Designing scalable event-driven systems.
👉 04-Backpressure-Strategies
Controlling overload in distributed systems.
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 & execution -
com.solisdynamics.runtime.*→ reflection & classloading
Each example demonstrates:
✔ Real-world behavior
✔ Edge cases
✔ Performance implications
Start with:
👉 01-Core-Overview
👉 02-Concurrency-Overview
Focus on:
👉 NIO systems
👉 Thread pools
👉 Blocking vs non-blocking
Go directly into:
👉 Selector architecture
👉 Memory model
👉 Event loop design
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
733+ pages covering:
java.niojava.util.concurrent- System-level backend patterns
👉 Gumroad
https://solisdynamics.gumroad.com/l/java-libraries-guide-1
👉 Leanpub
https://leanpub.com/java-libraries-guide-1
👉 Amazon
https://www.amazon.com/dp/B0GWWXB5BV
900+ pages covering:
- Swing / AWT
- Event Dispatch Thread (EDT)
- Desktop architecture
👉 https://solisdynamics.gumroad.com/l/java-libraries-guide-2
This project is open to contributions:
- Open issues for bugs or requests
- Submit pull requests for improvements
- Suggest new deep-dive topics
If this helped you:
⭐ Star the repository
This is not a beginner tutorial repository.
If you are looking for quick copy-paste solutions, this is not the right place.
If you want to:
✔ Understand how Java behaves under load
✔ Build scalable systems
✔ Think like a systems engineer
→ You are in the right place.
👉 01-Core-Overview
👉 01-NIO-Selector-Architecture
Most developers learn Java.
Very few understand it.
That difference separates:
coders → engineers