Last Saturday (11-07-2026)
- I attended the Code on JVM Meetup, and it was a great learning experience. Although I primarily work on frontend development and am currently exploring Java Full Stack, this meetup gave me a broader perspective on how large-scale systems are designed and how modern applications handle performance, scalability, and massive amounts of data.
Here are some of my key takeaways from the event.
Session 1: Engineering Building Blocks
The first session wasn't just about Java—it focused on the engineering concepts that power real-world applications.
Data Structures & Problem Solving
The speaker emphasized the importance of strengthening Data Structures and Algorithms (DSA).
Some recommended platforms for practice:
- LeetCode
- HackerRank
They also suggested exploring Abstract Syntax Trees (ASTs) to understand how programming languages parse and analyze code.
Another important concept discussed was Big O Notation, which helps measure the time and space complexity of algorithms.
Bloom Filter
One concept that caught my attention was the Bloom Filter.
A Bloom Filter is a space-efficient probabilistic data structure used to quickly check whether an element may exist in a dataset.
It is commonly used in:
- Apache Cassandra
- Google Chrome
- Feed readers
I learned that Bloom Filters are designed to save memory while providing very fast lookups, although they may occasionally produce false positives.
HNSW Graph & RAG
Another interesting topic was the HNSW (Hierarchical Navigable Small World) Graph.
It is widely used for:
- Vector databases
- AI Search
- Recommendation systems
The speaker also clarified something I hadn't thought about before:
RAG (Retrieval-Augmented Generation) is not an AI model itself—it is an algorithmic approach that retrieves relevant information before an AI generates a response.
That was an important distinction for me.
Skip List
We also learned about Skip Lists, which provide faster searching compared to traditional linked lists.
Real-world use cases include:
- Redis Sorted Sets
- Rate Limiting
- Storage Engines
LSM Trees
The session then moved to Log-Structured Merge Trees (LSM Trees).
LSM Trees are optimized for writing large amounts of data to disk and are commonly used in databases.
Examples include:
- RocksDB
- CockroachDB
- Cassandra
- Instagram's backend systems
This helped me understand how databases efficiently handle high write workloads.
Consistent Hashing
Another fascinating topic was Consistent Hashing.
It is used to distribute requests across multiple servers without causing major redistribution when servers are added or removed.
Applications include:
- Load Balancing
- CDNs like Akamai
- Amazon DynamoDB
- Discord Routing
Learning how requests are routed efficiently in distributed systems was particularly interesting.
Hexagonal Grid (H3 Index)
I also discovered H3, a hexagonal geospatial indexing system developed by Uber.
It is used in location-based applications such as:
- Uber
- Swiggy
- Zomato
- Ola
- Other ride-sharing platforms
This was one of the most practical concepts discussed because it directly connects to apps many of us use every day.
HyperLogLog
One concept I had never heard of before was HyperLogLog.
It is an algorithm used to estimate the number of unique elements in a huge dataset while consuming very little memory.
Some interesting facts:
- Uses only about 12 KB of memory.
- Has an approximate error rate of 0.81%.
It is useful for:
- Reddit analytics
- Google BigQuery
- Large-scale analytics dashboards
React Uses Trees Too
One interesting point was that tree data structures are also used in React's reconciliation process, where React compares the old Virtual DOM with the new Virtual DOM to efficiently update the UI.
As someone interested in frontend development, this connection between DSA and React really stood out.
Session 2: Building a Micro SaaS
The second session was presented by Angel John.
The discussion focused on building Micro SaaS products.
Some advice that stayed with me:
- Build products that solve real problems.
- Find people who are actually willing to pay for your solution.
- Validate your idea before investing too much time into development.
This session reminded me that building software isn't only about writing code—it's about solving meaningful problems.
Session 3: Handling High Load Applications
The final session focused on Java performance and handling high-load systems.
Topics covered included:
- Bytes
- Input Streams
- Streaming Response Body
- Virtual Threads (JDK 21)
- Reactive Pipelines
One practical takeaway was choosing the right approach depending on file size:
- Small files → Byte arrays
- Medium files → Input Streams
- Large files → Streaming Response Body
- High concurrency → Streaming Response Body + Virtual Threads
The speaker also introduced Virtual Threads in JDK 21, explaining how they improve memory efficiency and make handling thousands of concurrent requests much easier.
Another topic was Reactive Pipelines using Flux<DataBuffer> for efficient streaming.
My Overall Experience
This meetup exposed me to many engineering concepts that I had only heard about briefly before.
Some topics, like Bloom Filters, HyperLogLog, Consistent Hashing, and H3 indexing, were completely new to me, and I'm excited to explore them further.
The biggest takeaway for me was that software engineering goes far beyond writing code. Understanding the data structures, algorithms, and system design principles behind modern applications helps us appreciate how products like Google Chrome, Uber, Discord, Instagram, and Amazon scale to millions of users.
I'm looking forward to attending more tech meetups and continuing to learn from the developer community.
If you've attended a meetup recently, I'd love to hear about your biggest takeaway in the comments!
Top comments (0)