Forem: shantanu mahakale

Quick Recap: Caching in Java

shantanu mahakale — Fri, 21 Nov 2025 16:21:18 +0000

Caching stores frequently accessed data in memory to improve performance and reduce expensive calls (e.g., DB/API). It helps speed up applications and reduce load on resources.

Java provides multiple ways to implement caching — from simple in-memory maps to production-grade caching frameworks.

Why Use Caching?

✔ Improves performance

✔ Reduces DB/API calls

✔ Faster response times

✔ Better scalability

✔ Helps design high-performance systems

Types of Caching

Cache Type	Description	Example Use Case
In-Memory	Stored in JVM memory	Java Map, LRU Cache
Distributed	Shared across servers	Redis, Hazelcast
Local + Remote	Hybrid	Ehcache with DB store
Application-Level	Annotations-based	Spring Cache

Simple In-Memory Cache Using Map

Map<String, String> cache = new HashMap<>();
cache.put("user:1", "John");
cache.get("user:1"); // Fast lookup

⚠ Not thread-safe & no eviction policy.

LRU Cache (Least Recently Used)

Using LinkedHashMap:

LinkedHashMap<K,V> cache = new LinkedHashMap<>(16, 0.75f, true) {
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return size() > 100; // Max entries
}
};

👉 Removes least-used items automatically

👉 Best for lightweight caching

Concurrent Caching

Use ConcurrentHashMap for thread-safe cache:

ConcurrentHashMap<String, Object> cache = new ConcurrentHashMap<>();

✔ Safe for multi-threaded access

❌ No eviction/TTL built-in

Popular Caching Libraries

Library	Type	Use Case
Ehcache	Local / Hybrid	Spring apps, Hibernate
Caffeine	In-memory	High-performance LRU/TTL
Redis	Distributed	Microservices, APIs
Hazelcast	Distributed	Cluster-wide caching
Guava Cache	In-memory	Simple TTL, eviction

Example: Using Caffeine Cache (High Performance)

Cache<String, Object> cache = Caffeine.newBuilder()
.maximumSize(1000)
.expireAfterWrite(10, TimeUnit.MINUTES)
.build();
cache.put("user:1", userObject);
cache.getIfPresent("user:1");

✔ Very fast in-memory caching

✔ Supports eviction & TTL

✔ Used in modern Spring Boot apps

Spring Boot Caching (Annotation-Based)

Enable Caching:

@EnableCaching
@SpringBootApplication
public class App {}

Apply Cache:

@Cacheable("users")
public User getUser(int id) {
return userRepo.findById(id); // Runs only once
}

Evict Cache:

@CacheEvict(value="users", allEntries=true)
public void clearCache() {}

Supports: Caffeine, Redis, Ehcache, Hazelcast.

When to Use Which Cache?

Scenario	Recommended Cache
Basic in-memory	HashMap / ConcurrentHashMap
LRU logic	LinkedHashMap / Caffeine
Spring Boot apps	@Cacheable + Caffeine
Microservices	Redis / Hazelcast
Distributed apps	Redis / Memcached

Common Pitfalls

❌ Memory leaks (no eviction)

❌ Stale data issues

❌ Incorrect TTL configuration

❌ Using cache for everything

❌ Cache inconsistency across multiple nodes

Best Practices

✔ Monitor cache hit/miss ratio

✔ Set eviction & TTL policies

✔ Avoid caching large objects

✔ Use caching only for read-heavy data

✔ Prefer Caffeine or Redis for production

Quick Recap: Maps in Java

shantanu mahakale — Fri, 21 Nov 2025 16:09:32 +0000

Java provides multiple Map implementations — each designed for different use cases such as fast lookups, sorted data, concurrency, or predictable order. Understanding their internal working helps in writing performant code.

Main Map Implementations

Map Type	Ordering	Thread-Safe	Best For
HashMap	No order	❌ No	Fast lookup
LinkedHashMap	Insertion order	❌ No	Caching (LRU)
TreeMap	Sorted order	❌ No	Range queries
ConcurrentHashMap	No order	✔ Yes	Concurrent access

1. HashMap (Most Used)

Uses array + linked list / tree (red-black tree)
Default capacity = 16, load factor = 0.75
Collisions handled using chaining

Hashing Logic:

index = hash(key) & (n - 1) // n = array size

When collision occurs:

Java 8+: if bucket size > 8 → converts list → tree (better performance)

Time Complexity:
| Operation | Average | Worst |
|-----------|---------|-------|
| get/put | O(1) | O(n) (if all collide) |

Best For: Fast lookups, general-purpose storage

Not Thread-safe

2. LinkedHashMap

Extends HashMap → maintains insertion order
Uses doubly linked list + HashMap
Can be used for LRU Cache

// LRU Cache Example
LinkedHashMap<K,V> cache = new LinkedHashMap<>(16, 0.75f, true) {
  protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
  return size() > 100;
  }
};

Best For: Caching / maintaining order

3. TreeMap

Implements Red-Black Tree
Keys sorted in natural order or using Comparator
Supports range queries, floorKey(), ceilingKey()

TreeMap<Integer, String> map = new TreeMap<>();
map.put(10, "A");
map.put(5, "B");

Time Complexity (always):

get() → O(log n)
put() → O(log n)

Best For: Sorted data, range-based queries

Cannot store null keys

4. ConcurrentHashMap

Thread-safe, non-blocking concurrent access
Uses bucket-level locking (segments) in Java 7
Java 8+: CAS + synchronized blocks, no segments

Key Idea:

Multiple threads can read/write safely
No synchronized keyword needed

// Example
Map<String, Integer> map = new ConcurrentHashMap<>();
map.put("A", 1);

Best For: Highly concurrent applications

Internal Comparison

Feature	HashMap	LinkedHashMap	TreeMap	ConcurrentHashMap
Order	No	Insertion	Sorted	No
Thread-safe	No	No	No	Yes
Null Keys	1 allowed	1 allowed	❌ No	❌ No
Performance	Fastest	Slight overhead	O(log n)	High in concurrency

When to Use What?

Scenario	Recommended Map
Fast lookup	HashMap
Maintain order	LinkedHashMap
Sorted data	TreeMap
Multithreading	ConcurrentHashMap
LRU Cache	LinkedHashMap
Range queries	TreeMap

Quick Recap: Internal Working of Lists in Java

shantanu mahakale — Fri, 21 Nov 2025 16:05:04 +0000

Java provides multiple List implementations — each with different internal mechanisms and performance trade-offs. Choosing the right one based on use case is important for performance.

Most Common List Implementations

List Type	Main Feature	Use Case
ArrayList	Fast reads	General-purpose
LinkedList	Fast insert/delete	Frequent add/remove
Vector	Synchronized ArrayList	Legacy thread-safe code
CopyOnWriteArrayList	Thread-safe & immutable copy on write	Concurrent reads, few writes

1. ArrayList (Most Used)

Backed by dynamic array (Object[])
Fast random access — O(1) using index
When full → grows by 50% (in newer JDKs)
Not thread-safe

Internal Resize Logic:

newCapacity = oldCapacity + (oldCapacity >> 1); // 1.5x growth

Best For: Read-heavy operations & small modifications

Avoid When: Frequent insert/delete from middle → O(n) shifts

2. LinkedList

Doubly Linked List internally (prev, next pointers)
No index-based access → O(n)
Insertion & deletion = O(1) (if position known)
More memory overhead (storing pointers)

Node Structure:

class Node<E> {
  E item;
  Node<E> next;
  Node<E> prev;
}

Best For: Queue/Deque, frequent add/remove

Avoid When: Random access & large data reads

3. Vector (Legacy Thread-Safe)

Same as ArrayList but synchronized
Grows by 100% (double size)
Old and not used in modern apps

Resize Logic:

newCapacity = oldCapacity * 2;

Best For: Legacy apps with single-threaded logic

Avoid When: Modern concurrency → use ArrayList + sync or CopyOnWriteArrayList

4. CopyOnWriteArrayList

Used in concurrent environments
On every write → creates new copy of array
No locks during read → very fast reads
Write operations = expensive (copy on each change)

Internal Write Logic:

public boolean add(E e) {
synchronized (lock) {
Object[] newArr = Arrays.copyOf(oldArr, oldArr.length + 1);
newArr[last] = e;
array = newArr;
}
}

Best For: Many reads, very few writes

Avoid When: Write-heavy operations (slow performance)

Performance Comparison

Operation	ArrayList	LinkedList	CopyOnWriteArrayList
Read by index	🚀 Fast	❌ Slow	🚀 Fast
Insert/Delete middle	❌ Slow	🚀 Fast	❌ Very slow
Thread safety	No	No	Yes
Memory usage	Low	High	Medium–High

When to Use What?

Scenario	Recommended List
Random access	ArrayList
Frequent insert/delete	LinkedList
Legacy sync code	Vector
Concurrent reads, few writes	CopyOnWriteArrayList
Queue / Deque	LinkedList

Summary

List Type	Backed By	Best Use
ArrayList	Dynamic array	Fast lookup
LinkedList	Doubly linked list	Frequent addition/removal
Vector	Dynamic array (synchronized)	Legacy systems
CopyOnWriteArrayList	Dynamic array clone	Concurrent reads

Quick Recap: Design Patterns in Java (Real Examples)

shantanu mahakale — Fri, 21 Nov 2025 15:56:52 +0000

Design patterns provide reusable solutions to common software problems. Here’s a concise recap with actual Java / Spring framework examples — not generic ones.

Creational Patterns

Singleton

Ensures only one instance exists.

/ Real Example:
Calendar calendar = Calendar.getInstance();
Runtime runtime = Runtime.getRuntime();

Used in logging, DB connections, cache managers.

Factory Method

Creates objects without exposing logic.

// Example: Java Collections
List<String> list = List.of("A", "B"); // Java 9 Factory
NumberFormat format = NumberFormat.getInstance();

Spring Example: BeanFactory.getBean("beanName")

Builder Pattern

Best for creating complex objects with many fields.

// Example: StringBuilder
String result = new StringBuilder()
  .append("Hello ")
  .append("World")
  .toString();

Also used in Lombok: @Builder

Prototype Pattern

Create objects by cloning.

// Example: Object clone()
Employee cloned = (Employee) employee.clone();

Useful when object creation is costly.

Structural Patterns

Adapter Pattern

Converts one interface to another.

// Example: InputStreamReader adapts InputStream to Reader.
Reader reader = new InputStreamReader(inputStream);

Used when integrating legacy systems.

Decorator Pattern

Adds functionality at runtime.

// Example: I/O Streams
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("file.txt"));

Also in Spring: HandlerInterceptor, Filter

Facade Pattern

Provides a simplified interface.

// Example: JDBC
Connection conn = DriverManager.getConnection(url);
// JDBC hides complex driver logic!

Also: HibernateTemplate, RestTemplate

Proxy Pattern

Controls access to an object.

// Example: Java Dynamic Proxy (used in Spring AOP)
Proxy.newProxyInstance(...)

Used for authentication, logging, lazy loading.

Behavioral Patterns

Observer Pattern

Notifies when state changes.

// Example: PropertyChangeListener (Java Beans)
button.addActionListener(...);

Spring Example: ApplicationEventPublisher

Strategy Pattern

Different algorithms, same interface.

// Example: Comparator
Collections.sort(list, (a, b) -> a.compareTo(b));

Spring: AuthenticationStrategy, RetryStrategy

Template Method Pattern

Defines skeleton → subclasses override steps.

// Example: HttpServlet.doGet() / doPost()
abstract class HttpServlet {
  protected void doGet() {}
}

Spring JDBC Template follows this pattern.

Command Pattern

Encapsulates a request as an object.

// Example: Runnable
ExecutorService.exec(new MyTask());

Used in scheduling, undo operations.

Iterator Pattern

Sequential access without exposing structure.

// Example:
Iterator<String> itr = list.iterator();

Summary Table

Pattern	Real Java Example
Singleton	Runtime.getRuntime()
Factory	NumberFormat.getInstance()
Builder	StringBuilder
Adapter	InputStreamReader
Decorator	BufferedInputStream
Facade	JDBC (DriverManager)
Proxy	Spring AOP / Dynamic Proxy
Observer	ActionListener
Strategy	Comparator
Template Method	HttpServlet
Command	Runnable

Quick Recap: Elasticsearch & Lucene

shantanu mahakale — Fri, 21 Nov 2025 15:17:53 +0000

Elasticsearch is a distributed search and analytics engine, built on top of Apache Lucene. It is commonly used for full-text search, log analytics, metrics, and real-time data exploration.

Lucene is the core indexing + search library behind Elasticsearch — Elasticsearch is Lucene made easy + scalable.

What is Lucene?

Lucene is a low-level search/indexing library written in Java.

It provides:

Full-text search
Tokenization & analyzers
Inverted index mechanism
Scoring & relevance ranking

👉 Lucene is NOT a server or database — it’s just a library.

What is Elasticsearch?

Elasticsearch is an open-source distributed search engine built on top of Lucene with:

REST API-based querying
Distributed storage (shards & replicas)
Full-text search + filtering + aggregations
Scalable architecture for big data

Client → Elasticsearch → Lucene Index → Results

Key Concepts in Elasticsearch

Concept	Meaning
Index	Like a database
Document	JSON object (like a row)
Field	Key-value inside document
Shard	Partition of an index
Replica	Copy of shard (for fault tolerance)

Lucene: Inverted Index (Core Idea)

Lucene converts text into tokens and builds a reverse lookup table:

Text: "Java is great. Java streams are powerful."
Inverted Index:
"java" → [doc1, doc1]
"is" → [doc1]
"streams" → [doc1]

👉 Faster to search “java” instead of scanning entire text.

Elasticsearch Search Flow

Text → Analyzer → Tokens
Tokens stored in inverted index (Lucene)
Query converted into tokens
Relevant documents matched + scored
Sorted + returned as results

Example Query (Search API)

GET users/_search
{
  "query": {
    "match": { "name": "shantanu" }
  }
}

Full Text Search vs Exact Match

Search Type	Example	When Used
`match`	"java developer"	Full-text search
`term`	"400"	Exact value match
`wildcard`	"dev*"	Pattern-based search

Aggregations (Analytics Support)

GET logs/_search
{
  "aggs": {
    "errors_by_status": {
      "terms": { "field": "status_code" }
    }
  }
}

👉 Works like SQL GROUP BY.

When to Use Elasticsearch?

✔ Full-text search

✔ Log analytics (ELK stack)

✔ Real-time dashboards

✔ Autocomplete & suggestions

✔ Distributed scalability

Examples: eCommerce search, StackOverflow search, Kibana dashboards, Log analysis.

When NOT to Use Elasticsearch?

❌ As a replacement for a relational DB

❌ For complex transactions

❌ For small datasets

❌ When ACID guarantees are critical

Use PostgreSQL/MySQL instead.

Summary Table

Feature	Elasticsearch	Lucene
Type	Distributed search engine	Search library
Interface	REST API	Java library
Storage	JSON documents	Inverted index
Scale	Distributed (clusters)	Single machine
Use Case	Search & analytics	Core indexing logic

Quick Recap: JPA (Java Persistence API)

shantanu mahakale — Fri, 21 Nov 2025 15:13:46 +0000

JPA is a standard in Java for object-relational mapping (ORM) — it allows developers to map Java objects to database tables and perform CRUD operations without writing SQL manually.

It is mainly used with relational databases (e.g., Oracle, PostgreSQL, MySQL) and can also be used with MongoDB using Spring Data.

Core Concepts in JPA

Entity → Represents a table row
Entity Manager → Handles DB operations
Persistence Context → Cache/session for entities
Repository → Interface for CRUD queries
Transaction → Ensures atomic operations

Mapping Entities (Oracle Example)

@Entity
@Table(name = "users")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private String name;

JPA Annotations Cheat Sheet

Annotation	Purpose
`@Entity`	Marks a class as a DB entity
`@Table`	Maps to DB table
`@Id`	Primary key
`@GeneratedValue`	Auto-increment strategy
`@Column`	Map field to column
`@OneToMany`	Relationship mapping
`@ManyToOne`	Foreign key relation
`@Transactional`	Wrap method in transaction

Spring Data JPA Repository (Oracle Example)

public interface UserRepo extends JpaRepository<User, Long> {
List<User> findByName(String name);
}

👉 No SQL needed — method names generate queries.

Transactions (Relational DBs)

@Transactional
public void saveUser(User user) {
repo.save(user);
}

👉 Guarantees ACID behavior with Oracle/Postgres/MySQL.

JPA with MongoDB (Spring Data)

MongoDB is NoSQL, so traditional JPA is not used. Instead, we use Spring Data MongoDB, which follows a similar repository pattern.

Entity for MongoDB:

@Document(collection = "users")
public class User {
@Id
private String id;
private String name;
}

Repository:

public interface UserRepo extends MongoRepository<User, String> {}

👉 Still works like JPA, but no joins, no relationships, no transactions across collections.

JPA vs MongoDB – Key Differences

Feature	JPA (Oracle)	MongoDB
Database Type	Relational (SQL)	NoSQL (Document)
Schema	Fixed	Flexible
Transactions	ACID	Limited (single doc)
Joins	Yes	No (embed instead)
Querying	JPQL / Criteria	Mongo Query DSL
Repository	JpaRepository	MongoRepository

When to Use JPA (Relational)

✔ Complex relationships

✔ Transactions required

✔ Strong schema & constraints

✔ Enterprise applications

Examples: Oracle, PostgreSQL, MySQL

When to Use MongoDB (NoSQL)

✔ Flexible schema

✔ High scalability

✔ JSON-style data

✔ Fast reads/writes

✔ No complex joins needed

Examples: Logs, user profiles, IoT data, analytics

Summary

Use Case	Recommended
Banking / Finance	JPA with Oracle
Microservices	JPA + PostgreSQL OR MongoDB
IoT / Analytics	MongoDB
High reads/writes	MongoDB
Strict schema	JPA

Quick Recap: Java Threads

shantanu mahakale — Fri, 21 Nov 2025 15:09:53 +0000

Java supports multithreading to perform multiple tasks concurrently. Threads allow efficient use of CPU cores, improve performance, and enable responsive applications. They are a core part of Java concurrency.

What is a Thread?

A thread is a lightweight unit of execution within a process.

A Java application starts with a single main thread but can spawn multiple threads to run tasks in parallel.

Ways to Create Threads

1. Extending `Thread` class

class MyThread extends Thread {
public void run() {
System.out.println("Thread running");
}
}
new MyThread().start();

2. Implementing `Runnable`

class MyTask implements Runnable {
public void run() {
System.out.println("Task executed");
}
}
new Thread(new MyTask()).start();

3. Using Lambda (Java 8+)

new Thread(() -> System.out.println("Lambda thread")).start();

4. Using `ExecutorService` (Preferred)

ExecutorService exec = Executors.newFixedThreadPool(5);
exec.submit(() -> System.out.println("Task"));
exec.shutdown();

Thread States

State	Meaning
NEW	Created but not started
RUNNABLE	Running or ready to run
BLOCKED	Waiting for monitor lock
WAITING	Waiting indefinitely
TIMED_WAITING	Waiting with timeout
TERMINATED	Finished

Thread Lifecycle

NEW → RUNNABLE → WAITING/BLOCKED → RUNNABLE → TERMINATED

Common Thread Methods

Method	Purpose
`start()`	Starts thread
`run()`	Code executed by thread
`sleep(ms)`	Pause thread
`join()`	Wait for thread to finish
`yield()`	Hint to switch threads
`interrupt()`	Interrupt thread

Synchronization

Used to prevent race conditions when multiple threads access shared resources.

synchronized void increment() {
count++;
}

Or using intrinsic locks:

synchronized(obj) {
// critical section
}

Deadlock

Occurs when two threads wait for each other’s resources — both get stuck forever.

Thread A has Lock1 → waiting for Lock2
Thread B has Lock2 → waiting for Lock1

👉 Avoid by always acquiring locks in the same order.

Thread Pool (Executor Framework)

Better than creating threads manually.

ExecutorService pool = Executors.newFixedThreadPool(10);
pool.submit(task);
pool.shutdown();

Benefits:

Reuses threads
Improves performance
Manages queue & scheduling

Future & Callable (Return Values from Threads)

Callable<Integer> task = () -> 10 * 2;
Future<Integer> result = executor.submit(task);
System.out.println(result.get()); // 20

Virtual Threads (Java 19+ / 21)

Lightweight threads — thousands can be created with minimal overhead.

Thread.startVirtualThread(() -> {
// task goes here
});

👉 Game changer for concurrency & high-throughput apps.

Summary Table

Concept	Purpose
Thread	Unit of execution
Runnable	Task without return
Callable	Task with return
ExecutorService	Manages thread pool
synchronized	Prevents race conditions
Future	Get result of async task
Virtual Thread	Lightweight concurrency

Quick Recap: Spring Boot Versions

shantanu mahakale — Fri, 21 Nov 2025 14:48:37 +0000

Spring Boot simplifies Java backend development by providing auto-configuration, embedded servers, production-ready features, and rapid development support. Here's a version-wise recap focusing on features that actually impact coding experience.

Spring Boot 1.x (2014)

First release of Spring Boot
Embedded Tomcat/Jetty — no external server needed
Auto-configuration (core feature introduced)
Spring Boot Starter dependencies (spring-boot-starter-web)
application.properties for configuration 👉 Foundation for rapid development in Spring.

Spring Boot 2.x (Major Evolution)

Spring Boot 2.0

Based on Spring Framework 5
Reactive programming with WebFlux
Java 8+ required
Actuator redesigned with /actuator/* endpoints
Gradle plugin improved 👉 Start of reactive and microservice-ready Spring.

Spring Boot 2.1

Better Kubernetes support
Enhanced Actuator metrics (Micrometer)
Lazy initialization support

Spring Boot 2.2

Java 11 support
Reactive health indicators
Startup time optimization

Spring Boot 2.3

Docker & Container support
Better Graceful Shutdown
Improved tests

Spring Boot 2.4

New config loading system
Better support for external configs
Removed bootstrap.properties for Spring Cloud

Spring Boot 2.5

Improved embedded server performance
Layered JARs for Docker image optimization
Easier startup tracking and metrics

Spring Boot 2.6 – 2.7

Deprecation of older patterns (MVC fallback)
Spring Native & AOT (Ahead-of-Time compilation)
Hints of moving toward Spring Boot 3 standards

👉 Spring Boot 2.x focused heavily on microservices, Docker, and reactive architectures.

Spring Boot 3.x (Current Stable Major)

Java 17 required (minimum)
Jakarta namespace migration (javax → jakarta)
Built on Spring Framework 6
AOT & GraalVM Native Image support
Better performance & memory footprint
@HttpExchange & declarative HTTP clients
Enhanced observability (Micrometer + Actuator) 👉 Major breaking change due to Jakarta migration.

Summary Table

Version	Key Highlights
1.x	Embedded server, auto-config
2.0	WebFlux, Java 8+, Actuator redesign
2.3	Docker support, health checks
2.4	New config loading
2.6–2.7	Native image hints, AOT prep
3.x	Jakarta migration, Java 17+, HTTP client

What Should Developers Know Today?

Area	Recommendation
New projects	Use Spring Boot 3.x
Native/GraalVM	Use Spring Boot 3.x with AOT
Legacy upgrades	Move from 2.x → 3.x (Jakarta migration)
Performance-focused apps	Watch for Spring Boot 4 & Loom

Quick Recap: Angular Versions

shantanu mahakale — Fri, 21 Nov 2025 14:42:08 +0000

Angular continues to evolve with a strong focus on performance, developer productivity, and reduced bundle size. Here's a version-wise recap from Angular 8 onwards — covering the most relevant features for developers.

Angular 8

Ivy Engine (Preview) – New rendering engine
Differential Loading – Generates separate bundles for modern & legacy browsers
Lazy Loading with Dynamic Imports

loadChildren: () => import('./module').then(m => m.Module)

Web Worker Support (ng generate web-worker) 👉 Foundation for future major upgrades.

Angular 9

Ivy Rendering Engine becomes default
Smaller bundle sizes
Faster compilation
Better debugging & type checking
Improved Test Performance 👉 A major change — Ivy officially replaces View Engine.

Angular 10

Smaller, cleaner package size
Optional chaining & nullish coalescing (TS 3.9)

user?.address?.city
value ?? 'default'

Stricter project setup (ng new app --strict)
New Date Range Picker in Angular Material 👉 Focus on quality and type safety.

Angular 11

Faster builds & HMR (Hot Module Replacement)

ng serve --hmr

Automatic font optimization
Updated ESLint instead of TSLint
Improved logging & debugging 👉 Better DX (Developer Experience).

Angular 12

Removed support for View Engine → Ivy-only
Strict mode by default
Webpack 5 support
Nullish Coalescing in templates

{{ user?.name ?? 'Guest' }}

👉 Push towards modern tooling.

Angular 13

No more ngcc (Angular Compatibility Compiler)
ESBuild for faster builds
Simplified Angular Package Format
Component API improvements 👉 Cleaned up legacy dependencies — faster builds.

Angular 14

Standalone Components (major change!)

@Component({
standalone: true,
template: <h1>Hello</h1>
})
export class HelloComponent {}

Typed Reactive Forms
Better CLI autocompletion 👉 Can build apps without NgModule — huge shift.

Angular 15

Standalone APIs officially stable
Functional route guards & resolvers

const authGuard: CanActivateFn = (route, state) => true;

Improved performance
Directive composition API 👉 Encourages modular and cleaner applications.

Angular 16

Signals (reactivity model, preview)

const count = signal(0);
count.set(5);

Server-side rendering improvements
Better hydration
Faster compilation 👉 Signals simplify state management — major future shift.

Angular 17 (Latest Major)

Full support for Signals (stable)
New Control Flow Syntax

@if(condition) { ... }
@for(item of items) { ... }

Better SSR & hydration
Improved routing with deferrable views
Standalone apps now the default 👉 Angular becomes lighter, more React-like.

Summary Table

Version	Key Features
Angular 8	Ivy (preview), differential loading
Angular 9	Ivy default, faster builds
Angular 10	Optional chaining, strict mode
Angular 11	HMR, ESLint, font optimization
Angular 12	Ivy-only, Webpack 5
Angular 13	ESBuild, removed ngcc
Angular 14	Standalone components, typed forms
Angular 15	Functional guards, modular architecture
Angular 16	Signals (preview), SSR upgrades
Angular 17	Signals stable, new control flow

Quick Recap: Java Versions

shantanu mahakale — Fri, 21 Nov 2025 14:30:00 +0000

Here’s a practical summary of the most useful Java features added from Java 8 to recent versions, focusing on what developers actually use in daily coding.

Java 8 (Most Impactful Release)

Lambda Expressions → Functional programming
Stream API → Declarative data processing
Functional Interfaces (@FunctionalInterface)
Default & Static Methods in Interfaces
Optional Class – Avoid null checks
Date/Time API (java.time) – Replaces old Date/Calendar
Method References (:: operator)

👉 Most popular version in production even today.

Java 9

Modules (JPMS) – module-info.java
JShell – REPL for testing code quickly
Factory Methods for Collections

List.of(1, 2, 3);
Set.of("A", "B");

Improved Stream API: takeWhile(), dropWhile(), iterate()

Java 10

Local Variable Type Inference (var)

var name = "Shantanu";
var list = new ArrayList<String>();

👉 Not like JavaScript – only for local vars.

Java 11 (LTS Release)

HTTP Client API (modern replacement for HttpURLConnection)

HttpClient client = HttpClient.newHttpClient();

String Methods

"hello".isBlank();
"line1\nline2".lines();
"test".repeat(3);

var allowed in lambda params

👉 Very stable & widely used enterprise version after Java 8.

Java 14

Switch Expressions (Enhanced)

int result = switch(x) {
case 1 -> 100;
case 2 -> 200;
default -> 0;
};

Records (Preview) – Lightweight data classes
NullPointerException with details

Java 15

Text Blocks (Multiline Strings)

String json = """
{
"name": "John"
}
""";

👉 Clean JSON, SQL, HTML formatting.

Java 16

Records (Final Release)

public record User(String name, int age) {}

Pattern Matching for instanceof

if (obj instanceof String s) {
System.out.println(s.toUpperCase());
}

Java 17 (LTS)

Sealed Classes

public sealed class Animal permits Dog, Cat {}

Switch pattern matching (Preview)
Stronger encapsulation & security updates

👉 Current long-term support (LTS) version used widely in new projects.

Java 19 / 20 (Preview Features)

Virtual Threads (Project Loom)

Thread.startVirtualThread(() -> {
// lightweight threads
});

👉 Massive performance boost for high-concurrency apps.

Structured Concurrency Better control over multi-threading workflows.

Java 21 (LTS – Most Recent Major)

Virtual Threads (Final) – Game changer for performance
String Templates (Preview)

STR."Hello, ${name}!"

Sequenced Collections – Ordered access to elements
Record Patterns – Destructuring syntax
Pattern Matching Enhancements

👉 Consider upgrading if starting a new application.

Summary Table

Version	Key Features
Java 8	Lambdas, Streams, Optional, Date API
Java 9	Modules, JShell
Java 10	var keyword
Java 11	HTTP Client API, String methods
Java 14	Switch expressions, Records (preview)
Java 15	Text Blocks
Java 16	Records, Pattern Matching
Java 17	LTS, Sealed Classes
Java 19/20	Virtual Threads (preview)
Java 21	Virtual Threads (final), String templates

Quick Recap: Java Streams

shantanu mahakale — Fri, 21 Nov 2025 14:20:18 +0000

Java Streams (introduced in Java 8) provide a functional, declarative way to process collections. They allow writing cleaner and more readable code using pipelines like:

source → intermediate operations → terminal operation

Streams do not modify original data — they create a new result.

Key Features of Streams

Supports functional programming style
Works with Collections, Arrays, I/O data
Lazy evaluation (executed only when needed)
Supports parallel processing
No modification of original data
Readable pipelines for data processing

Stream Pipeline

collection.stream()
.filter(...)
.map(...)
.sorted(...)
.collect(...);

Source → stream()

Intermediate Ops → filter(), map(), sorted()

Terminal Ops → collect(), forEach(), reduce()

Common Intermediate Operations

Method	Purpose
`filter()`	Keep only matching elements
`map()`	Transform elements
`sorted()`	Sort elements
`distinct()`	Remove duplicates
`limit()` / `skip()`	Pagination-like usage
`peek()`	Debug/log values

Common Terminal Operations

Method	Purpose
`collect()`	Convert to List/Set/Map
`forEach()`	Loop through items
`count()`	Count elements
`min()` / `max()`	Find smallest/largest
`reduce()`	Aggregate into a single result
`toArray()`	Convert to array

Examples

Filter & Collect

List<Integer> evens = nums.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());

Map (Transform)

List<Integer> doubled = nums.stream()
.map(n -> n * 2)
.collect(Collectors.toList());

Reduce (Sum)

int sum = nums.stream()
.reduce(0, Integer::sum);

Sorting

List<String> sorted = names.stream()
.sorted()
.collect(Collectors.toList());

Parallel Streams

list.parallelStream()
.forEach(System.out::println);

👉 Used for large data processing

⚠️ Avoid for small collections (thread overhead)

⚠️ Be careful with shared mutable data

When to Use Java Streams?

✔ Cleaner & readable code

✔ Complex data transformation

✔ Large dataset processing

✔ Aggregations and filtering

✔ Multi-core parallel processing (parallelStream)

❌ Avoid when:

Debugging is complex
Performance is critical with small data
Code readability becomes worse

Summary Table

Concept	Key Idea
Stream	Flow of data without storage
Intermediate Op	Returns another Stream
Terminal Op	Produces final result
Immutable	Original data not changed
Lazy Eval	Runs only when needed
Functional	Uses lambda expressions

Quick Recap: System Design Components

shantanu mahakale — Fri, 21 Nov 2025 14:13:49 +0000

In modern distributed systems, different components work together to handle requests, scale applications, and ensure reliability. Here’s a quick summary of commonly used components with real-world tools for each.

API Gateway

Acts as the single entry point for all client requests. It routes requests to internal services, handles authentication, rate limiting, caching, and request validation.

Tools/Examples:

Kong
Amazon API Gateway
Apigee (Google)
Nginx (can be configured as gateway)
Zuul (Netflix OSS)

👉 Best for microservices architecture to centralize all API traffic.

Reverse Proxy

Sits between clients and backend servers. It forwards client requests to the appropriate server while hiding the server details. Can also handle caching, SSL termination, compression.

Tools/Examples:

Nginx
Apache HTTP Server
HAProxy
Caddy

👉 Used to improve security and manage traffic flow to backend servers.

Load Balancer

Distributes incoming traffic across multiple servers to prevent overload and ensure high availability. Helps with scalability and fault tolerance.

Types:

Layer 4 (Transport) – Uses TCP/UDP
Layer 7 (Application) – Uses HTTP/HTTPS & application logic

Tools/Examples:

AWS ELB / ALB
HAProxy
Nginx
Traefik
F5 Big-IP

👉 Ensures no single server becomes a bottleneck.

CDN (Content Delivery Network)

Caches and delivers static assets (images, videos, scripts) from edge locations closer to users — improving performance and latency.

Tools/Examples:

Cloudflare
Akamai
AWS CloudFront
Fastly

👉 Best for static assets, video streaming, and global content delivery.

Message Queue / Streaming

Used for asynchronous communication between services. Helps with decoupling, buffering, and reliable message delivery.

Tools/Examples:

Kafka
RabbitMQ
AWS SQS
Google Pub/Sub
ActiveMQ

👉 Ideal when services shouldn’t wait for each other.

Cache Layer

Stores frequently accessed data to reduce database load and improve speed. Can be in-memory or distributed.

Tools/Examples:

Redis
Memcached
Hazelcast
Aerospike

👉 Great for session storage, lookup data, leaderboards, caching SQL queries.

Database Types (Quick Recap)

Type	Use Case	Tools
SQL	Strong consistency	PostgreSQL, MySQL, Oracle
NoSQL	High scalability	MongoDB, Cassandra, DynamoDB
In-Memory	Fast reads	Redis, Memcached
Graph	Relationships	Neo4j, JanusGraph

Service Discovery

Automatically tracks available services and their dynamic locations (IP/ports). Essential in microservices.

Tools/Examples:

Consul
Eureka (Netflix)
Etcd
Zookeeper

👉 Helps services find and communicate with each other without manual config.

Summary Table

Component	Purpose	Tools
API Gateway	Entry point for clients	Kong, API Gateway, Zuul
Reverse Proxy	Forward client requests	Nginx, Apache, HAProxy
Load Balancer	Distribute traffic	AWS ELB, Nginx, Traefik
CDN	Deliver static content	Cloudflare, Akamai
Message Queue	Async communication	Kafka, RabbitMQ
Cache	Fast data access	Redis, Memcached
Service Discovery	Track service IPs	Consul, Eureka

Forem: shantanu mahakale

Quick Recap: Caching in Java

Why Use Caching?

Types of Caching

Simple In-Memory Cache Using Map

LRU Cache (Least Recently Used)

Concurrent Caching

Popular Caching Libraries

Example: Using Caffeine Cache (High Performance)

Spring Boot Caching (Annotation-Based)

Enable Caching:

Apply Cache:

Evict Cache:

When to Use Which Cache?

Common Pitfalls

Best Practices

Quick Recap: Maps in Java

Main Map Implementations

1. HashMap (Most Used)

2. LinkedHashMap

3. TreeMap

4. ConcurrentHashMap

Internal Comparison

When to Use What?

Quick Recap: Internal Working of Lists in Java

Most Common List Implementations

1. ArrayList (Most Used)

2. LinkedList

3. Vector (Legacy Thread-Safe)

4. CopyOnWriteArrayList

Performance Comparison

When to Use What?

Summary

Quick Recap: Design Patterns in Java (Real Examples)

Creational Patterns

Singleton

Factory Method

Builder Pattern

Prototype Pattern

Structural Patterns

Adapter Pattern

Decorator Pattern

Facade Pattern

Proxy Pattern

Behavioral Patterns

Observer Pattern

Strategy Pattern

Template Method Pattern

Command Pattern

Iterator Pattern

Summary Table

Quick Recap: Elasticsearch & Lucene

What is Lucene?

What is Elasticsearch?

Key Concepts in Elasticsearch

Lucene: Inverted Index (Core Idea)

Elasticsearch Search Flow

Example Query (Search API)

Full Text Search vs Exact Match

Aggregations (Analytics Support)

When to Use Elasticsearch?

When NOT to Use Elasticsearch?

Summary Table

Quick Recap: JPA (Java Persistence API)

Core Concepts in JPA

Mapping Entities (Oracle Example)

JPA Annotations Cheat Sheet

Spring Data JPA Repository (Oracle Example)

Transactions (Relational DBs)

JPA with MongoDB (Spring Data)

Entity for MongoDB:

Repository:

JPA vs MongoDB – Key Differences

When to Use JPA (Relational)

When to Use MongoDB (NoSQL)

Summary

Quick Recap: Java Threads

What is a Thread?

Ways to Create Threads

1. Extending Thread class

1. Extending `Thread` class

2. Implementing `Runnable`

4. Using `ExecutorService` (Preferred)