Java

Java

Java is a general-purpose, object-oriented programming language designed to run on any device via the Java Virtual Machine (JVM), following the "write once, ru…

JavaScript

JavaScript is a high-level, interpreted scripting language that runs natively in web browsers and, via runtimes like Node.js, on servers — making it the primar…

Dart

Dart is a client-optimized, object-oriented programming language developed by Google, best known as the language behind the Flutter cross-platform app framewor…

Algorithms

An algorithm is a finite, well-defined sequence of steps used to solve a problem or perform a computation, forming the logical foundation of all software.

Data Structures

Data structures are specific ways of organizing, storing, and accessing data in memory — such as arrays, linked lists, trees, and hash tables — chosen to optim…

Compiler

A compiler is a program that translates source code written in a high-level programming language into a lower-level form, such as machine code or bytecode, tha…

C++

C++ is a general-purpose, compiled programming language that extends C with object-oriented programming, templates, and higher-level abstractions while retaini…

Clojure

Clojure is a modern, functional dialect of Lisp that runs primarily on the Java Virtual Machine, emphasizing immutability and simplicity for building concurren…

COBOL

COBOL (Common Business-Oriented Language) is one of the oldest programming languages still in active use, designed in 1959 for business, financial, and adminis…

Groovy

Groovy is a dynamic, optionally typed programming language that runs on the Java Virtual Machine, designed to interoperate seamlessly with Java while offering…

Garbage Collection

Garbage collection is an automatic memory management process that identifies and reclaims memory occupied by objects that a program can no longer reach or use,…

Bytecode

Bytecode is a compact, platform-independent set of instructions that sits between human-readable source code and native machine code, designed to be executed b…

IntelliJ IDEA

IntelliJ IDEA is an integrated development environment (IDE) developed by JetBrains, primarily for Java development, with strong support for Kotlin and other J…

H2 Database

H2 Database is a lightweight, open-source relational database written in Java that can run embedded inside an application's JVM process or as a standalone serv…

Derby (Apache)

Apache Derby is an open-source, pure-Java relational database management system that can be embedded directly inside an application or run as a network server,…

X10 (language)

X10 is a statically typed, object-oriented programming language developed by IBM Research for high-performance, high-productivity computing, built around the p…

Installing JMeter

Step-by-step guide to installing Apache JMeter on Windows, macOS, and Linux, including the Java prerequisite and how to verify a working install.

Writing a MapReduce Job in Java

A practical walkthrough of assembling a Driver, Mapper, and Reducer into a runnable Java MapReduce job, from configuration to cluster execution.

Clojure and Java Interop

Understand how Clojure calls Java classes and methods directly via dot notation, implements interfaces with proxy/reify/gen-class, and handles exceptions and t…

Installing Clojure and Leiningen

A step-by-step guide to setting up a working Clojure development environment, including the JDK, the Clojure CLI tools, and Leiningen.

Groovy and Annotations

Understand how Groovy's AST transformation annotations like @Canonical, @Immutable, and @CompileStatic generate real code at compile time, and how to build you…

Groovy vs Java

A side-by-side comparison of Groovy and Java covering syntax verbosity, static versus dynamic typing, performance, and when to reach for each language.

Groovy vs Java Comparison

A practical comparison of Groovy and Java covering syntax, typing, closures, and runtime performance to help you choose the right tool and write better JVM cod…

Scala vs Java

A practical comparison of Scala and Java covering syntax, type systems, concurrency, and when to choose one over the other on the JVM.

Application Properties and Profiles

How Spring Boot externalizes configuration through application.properties/yml, property precedence, and environment-specific profiles.

Authentication and Authorization in Spring

How Spring Security distinguishes proving identity (authentication) from granting access (authorization), covering roles, method security, and JWT-based statel…

Bean Scopes in Spring

Understand the difference between singleton, prototype, and web-aware bean scopes, and when scoped proxies are required.

Building Microservices with Spring Boot

How to design, discover, secure, and make resilient a set of independently deployable Spring Boot services using Spring Cloud.

Building REST Controllers

Learn how to build REST controllers in Spring Boot using @RestController, structure methods cleanly, and return well-formed HTTP responses.

Component Scanning

Learn how Spring discovers annotated classes on the classpath and registers them as beans, and how to control scan scope with filters.

Configuration Classes

Learn how @Configuration classes and @Bean methods provide explicit, programmatic bean wiring, and how to compose and conditionally activate them.

Database Migrations with Flyway

Learn how Flyway version-controls your schema with plain SQL migration scripts, integrates with Spring Boot, and keeps environments consistent.

Defining JPA Entities

Learn how to model database tables as Java classes using JPA annotations, covering identifiers, column mapping, and entity relationships.

Dependency Injection Explained

Learn how Spring's IoC container supplies objects with the collaborators they need, instead of letting objects build those collaborators themselves.

Exception Handling in Spring Boot

Learn how to handle errors gracefully in Spring Boot REST APIs using @ExceptionHandler, @ControllerAdvice, and structured error responses.

Logging in Spring Boot

How Spring Boot's default Logback-based logging works, including log levels, per-package configuration, and structured logging for production.

Querying with JPA

Go beyond basic repository methods to master JPQL, the Criteria API, pagination, and performance pitfalls like the N+1 select problem.

Repositories in Spring Data

Understand the Repository interface hierarchy in Spring Data — from Repository and CrudRepository to PagingAndSortingRepository and JpaRepository.

Request and Response Bodies

Learn how Spring Boot serializes and deserializes JSON request and response bodies using @RequestBody, @ResponseBody, and Jackson.

Request Mapping and Path Variables

Understand how Spring Boot maps HTTP requests to controller methods using @RequestMapping, HTTP-method shortcuts, and path variables.

Java Cheat Sheet

Core Java syntax, data types, collections, generics, and streams for writing robust object-oriented JVM applications.

What is Polymorphism in OOP?

Polymorphism is the object-oriented principle that lets objects of different classes respond to the same method call in their own class-specific way.

Difference Between Abstraction and Encapsulation

Abstraction hides complexity by exposing only the essential behavior of an object, while encapsulation hides an object’s internal data by bundling it with the…

What are the Four Pillars of OOP?

The four pillars of object-oriented programming are Encapsulation, Abstraction, Inheritance, and Polymorphism — the principles that structure code around objec…

Difference Between Interface and Abstract Class

An interface defines a contract of methods a class must implement with no state, while an abstract class can provide partial implementation and state and serve…

Composition vs Inheritance in OOP

Inheritance models an "is-a" relationship where a class derives from a parent, while composition models a "has-a" relationship where a class is built from othe…

What are SOLID Principles?

SOLID is five object-oriented design principles — Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion — th…

What is Inheritance in OOP?

Inheritance is the object-oriented mechanism by which a class (the subclass) acquires the fields and methods of another class (the superclass), enabling code r…

Method Overloading vs Overriding

Method overloading is defining multiple methods with the same name but different parameter lists within a class, resolved at compile time, while method overrid…

What is Encapsulation in OOP?

Encapsulation is the object-oriented principle of bundling an object’s data with the methods that operate on it and restricting direct access to that data from…

What is a Constructor in OOP?

A constructor is a special method invoked automatically when an object is created that initializes the object’s state, sharing the class’s name and having no r…

What is Abstraction in OOP?

Abstraction is the object-oriented principle of exposing only the essential features and behavior of an object while hiding the underlying implementation compl…

What is a Design Pattern?

A design pattern is a reusable, named solution to a recurring software design problem, expressed as a template of collaborating classes and objects rather than…

What is the Singleton Pattern?

The Singleton pattern restricts a class to exactly one instance and provides a single global access point to that instance, typically via a static method.

What is the Factory Pattern?

The Factory pattern delegates object creation to a dedicated method or class instead of calling a constructor directly, so callers depend on an interface rathe…

What is Dependency Injection?

Dependency injection is a technique where an object receives its dependencies from an external source rather than creating them itself, typically via construct…

Static vs Instance Methods: What is the Difference?

A static method belongs to the class itself and is called without any object instance, while an instance method belongs to a specific object and operates on th…

What is Method Overriding in OOP?

Method overriding is when a subclass provides its own implementation of a method already defined in its superclass, using the same name and signature.

What is Coupling and Cohesion in OOP?

Coupling measures how dependent one module or class is on another, while cohesion measures how strongly the responsibilities inside a single module belong toge…

What is the Observer Pattern?

The Observer pattern defines a one-to-many dependency where a subject notifies a list of registered observers automatically whenever its state changes.

What is a Virtual Function?

A virtual function is a member function declared in a base class that a derived class can override, with the actual implementation resolved at runtime based on…

Aggregation vs Composition in OOP

Aggregation and composition are both "has-a" relationships between objects, but composition implies strict ownership where the part cannot outlive the whole, w…

What is the Liskov Substitution Principle?

The Liskov Substitution Principle (LSP) states that objects of a subclass must be substitutable for objects of the base class without altering the correctness…

What is the Strategy Pattern?

The Strategy pattern defines a family of interchangeable algorithms, encapsulates each one behind a common interface, and lets the client swap the algorithm at…

What is Multiple Inheritance?

Multiple inheritance is when a class inherits fields and methods from more than one parent class simultaneously, combining their behavior into a single subclas…