Blog

245 articles

Long-form teaching guides that walk through each interview topic end-to-end, with worked code examples and the concepts behind every question.

Showing 245 of 245 articles

Spring Boot · Actuator & ObservabilitySpring Boot Actuator Endpoints: Production-Ready MonitoringA practical guide to Spring Boot Actuator — the key endpoints, exposing vs enabling, health groups, securing endpoints, a separate management port, runtime log levels, and custom @Endpoint beans.Updated 2026-06-26
Spring Boot · Async & MessagingSpring Boot @Async and @Scheduled: Off-Thread and On-Time WorkA practical guide to running work off the request thread in Spring Boot — enabling @Async, returning CompletableFuture, custom bounded executors, the self-invocation trap, fixedRate vs fixedDelay vs cron, exception handling, and surviving multiple instances.Updated 2026-06-26
Spring Boot · CoreHow Spring Boot Auto-Configuration Actually WorksA from-scratch walkthrough of Spring Boot auto-configuration — how @EnableAutoConfiguration discovers classes, how @Conditional gates them, how to debug what applied, and how to override or write your own.Updated 2026-06-26
Spring Boot · Dependency InjectionThe Spring IoC Container Explained: Beans, Scopes, and LifecycleA ground-up tour of the Spring IoC container — inversion of control, the ApplicationContext, the bean lifecycle, singleton vs prototype scopes, scoped proxies, and why constructor injection beats getBean().Updated 2026-06-26
Spring Boot · Data AccessMapping JPA Entities in Spring Boot, ExplainedHow a plain Java class becomes a database table in Spring Boot — @Entity, identity and generation strategies, column mapping, embeddables and enums, the entity lifecycle, dirty checking, and the equals/hashCode trap.Updated 2026-06-26
Spring Boot · Web MVCBuilding REST Controllers in Spring Boot, ExplainedHow Spring MVC turns an HTTP request into a controller method call — @RestController, the mapping shortcuts, binding path variables and query params, ResponseEntity, content negotiation, and the conventions of a clean REST API.Updated 2026-06-26
Spring Boot · SecuritySpring Security Basics: The Filter Chain, ExplainedHow Spring Security actually works — the servlet filter chain, the SecurityFilterChain bean, authentication vs authorization, the SecurityContext, password encoding, CSRF, CORS, and stateless vs session security.Updated 2026-06-26
Spring Boot · TestingUnit Testing Spring Boot: Fast Tests Without the ContextHow to write genuinely fast Spring Boot unit tests — plain JUnit 5, Mockito for collaborators, @Mock vs @MockBean, constructor injection for testability, AssertJ, verifying interactions, and controlling time.Updated 2026-06-26
Spring Boot · Async & MessagingSpring Boot Application Events: In-Process Pub/Sub Done RightHow Spring's application event system works — publishing POJO events, @EventListener, why listeners are synchronous by default, making them @Async, @TransactionalEventListener for after-commit side effects, conditional and ordered listeners, and where events stop being the right tool.Updated 2026-06-26
Spring Boot · SecurityHow Authentication Works in Spring SecurityThe authentication flow end to end — AuthenticationManager and providers, UserDetailsService and UserDetails, DaoAuthenticationProvider, form login vs HTTP Basic, custom providers, account status, login events, and logout.Updated 2026-06-26
Spring Boot · Dependency InjectionSpring Stereotype Annotations and Injection Styles, ExplainedA practical guide to @Component, @Service, @Repository, @Controller, @RestController, and @Autowired — how component scanning finds beans, and why constructor injection beats field injection.Updated 2026-06-26
Spring Boot · Actuator & ObservabilityCustom Health Indicators and Micrometer Metrics in Spring BootBuild custom Spring Boot health indicators, understand the Health/Status aggregation model, wire health groups to Kubernetes probes, and expose Micrometer metrics — Counters, Gauges, Timers, tags, and Prometheus.Updated 2026-06-26
Spring Boot · CoreSpring Boot Configuration: Properties, Profiles, and PrecedenceA practical guide to externalized configuration in Spring Boot — property source precedence, @ConfigurationProperties vs @Value, profiles, relaxed binding, validation, and handling secrets safely.Updated 2026-06-26
Spring Boot · Data AccessJPA Relationships and Fetching in Spring Boot, ExplainedModeling associations and controlling how they load — owning vs inverse side, LAZY vs EAGER, the N+1 problem, JOIN FETCH and entity graphs, cascade and orphanRemoval, and when to ditch @ManyToMany for a join entity.Updated 2026-06-26
Spring Boot · Web MVCRequest and Response Handling in Spring MVC, ExplainedA practical tour of how Spring MVC reads and writes HTTP — message converters, bodies, headers and cookies, file uploads, CORS, filters versus interceptors, async responses, and streaming large payloads.Updated 2026-06-26
Spring Boot · TestingSpring Boot Test Slices: @WebMvcTest, @DataJpaTest, and FriendsTest slices let you load one layer of a Spring Boot app instead of the whole context — @WebMvcTest with MockMvc, @DataJpaTest with TestEntityManager, @JsonTest, @RestClientTest, @MockBean, and the pitfalls that trip people up.Updated 2026-06-26
Spring Boot · CoreThe Spring Boot Application Lifecycle, Start to ShutdownFollow a Spring Boot app from SpringApplication.run through context refresh, bean lifecycle callbacks, runners and events, all the way to graceful shutdown — with the hooks you need at each stage.Updated 2026-06-26
Spring Boot · SecurityAuthorization in Spring Security: URL and Method RulesControlling access in Spring Security — URL authorization rules and matchers, method security with @PreAuthorize and @PostAuthorize, @Secured vs SpEL, role hierarchies, the 403 path, instance-level permissions, and defense in depth.Updated 2026-06-26
Spring Boot · Web MVCException Handling in Spring MVC, ExplainedHow to turn exceptions into clean HTTP responses in Spring Boot — @ExceptionHandler, global @RestControllerAdvice, mapping exceptions to status codes, the default error controller, ProblemDetail (RFC 7807), and designing a consistent API error model.Updated 2026-06-26
Spring Boot · Dependency InjectionResolving the Right Bean: @Qualifier, @Primary, and Spring's Resolution OrderHow Spring picks which bean to inject when several match — the type → @Primary → @Qualifier → name resolution ladder, custom qualifiers, @Resource, generics as qualifiers, and fixing NoUniqueBeanDefinitionException.Updated 2026-06-26
Spring Boot · TestingSpring Boot Integration Testing with @SpringBootTest and TestcontainersFull-context Spring Boot integration tests — @SpringBootTest web environments, TestRestTemplate, Testcontainers with @ServiceConnection, context caching, @Transactional rollback caveats, test profiles, and testing async behavior.Updated 2026-06-26
Spring Boot · Actuator & ObservabilitySpring Boot Logging: Logback, Levels, Files, and Structured JSONA practical tour of Spring Boot logging — the SLF4J + Logback default stack, levels and groups, file rotation, logback-spring.xml profiles, structured JSON, runtime level changes via actuator, and MDC correlation IDs.Updated 2026-06-26
Spring Boot · Async & MessagingSpring Boot Messaging Basics: JMS, RabbitMQ, and Kafka ExplainedA grounded introduction to messaging in Spring Boot — why brokers beat direct calls, JMS vs AMQP vs Kafka, queues vs topics, templates and listeners, acknowledgement modes and delivery guarantees, idempotent consumers, dead-letter queues, and the dual-write problem.Updated 2026-06-26
Spring Boot · Data AccessSpring Data JPA Repositories, ExplainedHow Spring Data turns an interface into a working DAO — the repository hierarchy, derived query methods, @Query and native queries, paging and projections, modifying queries, and the runtime proxy that generates it all.Updated 2026-06-26
Spring Boot · Dependency InjectionConfiguring Beans in Spring: @Bean, @Conditional, @Value, and SpELHow to define and configure beans with Java config — @Configuration and @Bean, lifecycle callbacks, conditional registration, @Value and @ConfigurationProperties, SpEL, and Java config vs component scanning.Updated 2026-06-26
Spring Boot · SecurityJWT and OAuth2 in Spring Boot, ExplainedStateless authentication done right — JWT structure and validation, the OAuth2 resource server, oauth2Login and the authorization-code flow, OAuth2 vs OIDC, access and refresh tokens, scopes to authorities, revocation, and JWT pitfalls.Updated 2026-06-26
Spring Boot · Data AccessDeclarative Transactions in Spring Boot, ExplainedHow @Transactional really works — the proxy model and its self-invocation trap, propagation and isolation, default rollback rules, readOnly, flush vs commit, and optimistic vs pessimistic locking.Updated 2026-06-26
Spring Boot · Web MVCValidation and JSON Serialization in Spring Boot, ExplainedHow Spring Boot validates input and renders JSON — @Valid versus @Validated, JSR-380 constraints and custom validators, validation groups, Jackson annotations, dates and naming strategies, DTOs versus entities, and customizing the ObjectMapper.Updated 2026-06-26
React · PatternsReact Compound Components — Complete Interview GuideMaster React compound components for interviews — Context-based state sharing, dot-notation APIs, controlled vs uncontrolled modes, TypeScript typing, and performance optimisation patterns.Updated 2026-06-24
React · State and Data FlowLifting State Up in React — A Complete GuideA practical guide to lifting state up in React — single source of truth, callback props, sibling communication, derived state, and when to stop.Updated 2026-06-24
React · State ManagementRedux Toolkit in React — Complete Interview GuideMaster Redux Toolkit for React interviews — createSlice, configureStore, createAsyncThunk, RTK Query, and when to choose Redux over simpler solutions.Updated 2026-06-24
React · RoutingReact Router v6 Routing Basics — Complete Interview GuideMaster React Router v6 routing basics for interviews — BrowserRouter, Route, Link, NavLink, Outlet, nested routes, index routes, useNavigate, and 404 catch-all routes.Updated 2026-06-24
React · TestingReact Testing Library — Complete Interview GuideLearn React Testing Library from first principles — the testing philosophy, queries, screen, userEvent, waitFor, jest-dom matchers, and async testing patterns that interviewers ask about.Updated 2026-06-24
React · Rendering and PerformanceReact Virtual DOM and Reconciliation — A Complete GuideReact virtual DOM and reconciliation interview questions — diffing algorithm, Fiber architecture, keys, bailout conditions, and how React decides what to re-render.Updated 2026-06-24
React · TestingReact Component Interaction Testing — Complete GuideMaster React component interaction testing — clicks, form submission, keyboard navigation, modals, portals, context, routing, and integration test patterns with React Testing Library.Updated 2026-06-24
React · State and Data FlowReact Context API — A Complete GuideA complete guide to the React Context API — createContext, useContext, Providers, re-render patterns, multiple contexts, and when to use Context vs. Redux.Updated 2026-06-24
React · RoutingReact Router v6 Dynamic & Nested Routes — Complete Interview GuideMaster React Router v6 dynamic and nested routes for interviews — useParams, Outlet, layout routes, index routes, useOutletContext, and the data API with loaders.Updated 2026-06-24
React · Rendering and PerformanceReact.memo — A Complete Guide with ExamplesReact.memo interview questions — when to memoize components, shallow equality, custom comparators, pitfalls, and when memo actually hurts performance.Updated 2026-06-24
React · PatternsReact Render Props & HOCs — Complete Interview GuideMaster React render props and HOCs for interviews — function-as-child, higher-order components, cross-cutting concerns, prop collision, hooks vs HOCs, and TypeScript generics.Updated 2026-06-24
React · State ManagementZustand for React — Complete Interview GuideMaster Zustand for React interviews — store creation, selectors, middleware, async actions, and when to choose Zustand over Redux or Context.Updated 2026-06-24
React · State ManagementReact Context vs Redux — Complete Interview GuideContext vs Redux for React interviews — understand re-render behavior, performance trade-offs, and when each solution is the right choice.Updated 2026-06-24
React · State and Data FlowControlled vs Uncontrolled Components in React — A Complete GuideA complete guide to controlled and uncontrolled components in React — value vs defaultValue, refs, when to use each, and how form libraries fit in.Updated 2026-06-24
React · PatternsReact Error Boundaries — Complete Interview GuideMaster React error boundaries for interviews — componentDidCatch, getDerivedStateFromError, fallback UI, async errors, react-error-boundary library, and Suspense integration.Updated 2026-06-24
React · TestingMocking Async in React Tests — Complete GuideMaster async React testing — mock fetch, set up MSW, test loading and error states, control timers with vi.useFakeTimers, mock modules, test React Query, debounce, and localStorage.Updated 2026-06-24
React · RoutingReact Router v6 Navigation Hooks — Complete Interview GuideMaster React Router v6 navigation hooks for interviews — useNavigate, useParams, useLocation, useSearchParams, useMatch, and useBlocker with real examples.Updated 2026-06-24
React · Rendering and PerformanceReact useMemo and useCallback Patterns — A Complete GuideReact useMemo and useCallback interview questions — memoization patterns, dependency arrays, when to use each hook, referential stability, and common pitfalls.Updated 2026-06-24
React · State ManagementAsync State & React Query — Complete React Interview GuideMaster React Query for interviews — useQuery, useMutation, caching, query keys, optimistic updates, and why server state deserves its own management layer.Updated 2026-06-24
React · Rendering and PerformanceReact Code Splitting and Lazy Loading — A Complete GuideReact code splitting and lazy loading interview questions — React.lazy, dynamic imports, Suspense boundaries, route-based splitting, bundle optimization, and prefetching strategies.Updated 2026-06-24
React · PatternsReact Portals & Refs — Complete Interview GuideMaster React portals and refs for interviews — createPortal, DOM escape hatch, useRef, callback refs, and direct DOM manipulation patterns.Updated 2026-06-24
React · State and Data FlowProp Drilling and Composition in React — A Complete GuideA complete guide to prop drilling and composition in React — what prop drilling is, why it hurts, and how to fix it with children, slots, Context, render props, and compound components.Updated 2026-06-24
React · RoutingReact Router v6 Protected Routes — Complete Interview GuideMaster React Router v6 protected routes for interviews — RequireAuth wrapper, Navigate redirect, role-based access, auth context hook, and redirect-after-login patterns.Updated 2026-06-24
React · TestingTesting React Custom Hooks — Complete GuideLearn how to test React custom hooks with renderHook — async hooks, context- dependent hooks, timer hooks, useReducer hooks, cleanup verification, and when to test hooks directly versus through components.Updated 2026-06-24
React · PatternsReact forwardRef & useImperativeHandle — Complete Interview GuideMaster React forwardRef and useImperativeHandle for interviews — ref forwarding, imperative API design, focus control, TypeScript typing, and React 19 changes.Updated 2026-06-24
React · Rendering and PerformanceReact Suspense and Concurrent Rendering — A Complete GuideReact Suspense and concurrent rendering interview questions — Suspense for data fetching, useTransition, useDeferredValue, startTransition, concurrent features, and React 18 rendering model.Updated 2026-06-24
React · ComponentsReact JSX — A Complete Guide with ExamplesReact JSX interview questions — JSX syntax, transpilation, fragments, expressions, boolean attributes, and the differences between JSX and HTML.Updated 2026-06-23
React · ComponentsReact Props and Component Types — A Complete Interview GuideReact props and component types interview questions — function vs class components, children, defaultProps, PropTypes, composition over inheritance, and controlled components.Updated 2026-06-23
React · ComponentsReact Event Handling — A Complete Interview GuideReact event handling interview questions — SyntheticEvent, camelCase events, preventDefault, stopPropagation, passing arguments, controlled inputs, and event delegation.Updated 2026-06-23
React · HooksReact useContext Hook — Complete Guide for InterviewsReact useContext interview guide — creating and consuming context, avoiding unnecessary re-renders, splitting contexts, and when to use context vs a state library.Updated 2026-06-23
React · ComponentsReact Conditional Rendering — A Complete Interview GuideReact conditional rendering interview questions — ternary, &&, null, guard clauses, loading states, CSS display vs conditional mounting, and clean multi-condition patterns.Updated 2026-06-23
React · HooksReact useReducer Hook — Complete Guide for InterviewsReact useReducer interview guide — reducer functions, dispatch, action types, the initializer pattern, context integration, Immer, and when to prefer useReducer over useState.Updated 2026-06-23
React · ComponentsReact Lists and Keys — A Complete Interview GuideReact lists and keys interview questions — key prop, reconciliation, index as key pitfalls, stable keys, Fragment in lists, and rendering nested arrays.Updated 2026-06-23
React · HooksReact useCallback & useMemo — Complete Interview GuideReact useCallback and useMemo interview guide — referential stability, when to memoize, dependency arrays, React.memo interaction, and avoiding premature optimization.Updated 2026-06-23
React · HooksReact useRef Hook — Complete Interview Guide with ExamplesMaster the React useRef hook for interviews — DOM access, mutable instance variables, forwardRef, useImperativeHandle, callback refs, and when to use ref vs state.Updated 2026-06-23
React · HooksReact Custom Hooks — Complete Interview Guide with ExamplesMaster React custom hooks for interviews — naming rules, extracting shared logic, usePrevious, useDebounce, useLocalStorage, useMediaQuery, hook composition, and testing.Updated 2026-06-23
.NET Core · ASP.NET CoreHow the ASP.NET Core Middleware Pipeline WorksHow the ASP.NET Core middleware pipeline processes requests — the order that matters, when short-circuiting applies, and how to write DI-aware custom middleware without introducing bugs.Updated 2026-06-23
.NET Core · C# CoreHow C# Async/Await Works Under the HoodWhat the C# compiler actually generates for async/await — the state machine, SynchronizationContext, the deadlock pattern that affects ASP.NET apps, and when to use ValueTask over Task.Updated 2026-06-23
.NET Core · SecurityAuthentication in ASP.NET CoreHow ASP.NET Core authentication works end-to-end — cookie auth, ClaimsPrincipal, multiple schemes, custom handlers, and the challenge vs forbid distinction that trips up most developers.Updated 2026-06-23
.NET Core · Performance & DeploymentCaching in ASP.NET Core: IMemoryCache, Redis, and Output CacheCaching in ASP.NET Core — when to use IMemoryCache vs Redis, how cache-aside differs from write-through, output caching in .NET 7+, and the stampede problem that hits every high-traffic app eventually.Updated 2026-06-23
.NET Core · Dependency InjectionDependency Injection in .NET CoreThe .NET Core DI container from the ground up — IServiceCollection, constructor injection, open generic registrations, keyed services, and the three anti-patterns that interviewers routinely probe.Updated 2026-06-23
.NET Core · Entity Framework CoreEF Core DbContext, DbSet, and Change TrackingHow EF Core tracks changes, manages entity state, and persists data — including why Singleton lifetime is a bug, when to pool contexts, and how to add audit logging with interceptors.Updated 2026-06-23
.NET Core · TestingUnit Testing in .NET with xUnitHow to write effective unit tests in .NET — xUnit vs NUnit, the AAA structure, data-driven tests with Theory, test isolation, and the design habits that make code easy to test in the first place.Updated 2026-06-23
.NET Core · ASP.NET CoreRouting in ASP.NET CoreHow ASP.NET Core routing maps requests to handlers — attribute vs conventional routing, route constraints, link generation, minimal API route groups, and how to debug ambiguous routes.Updated 2026-06-23
.NET Core · SecurityPolicy-Based Authorization in ASP.NET CoreHow policy-based authorization works in ASP.NET Core — requirements, handlers, resource-based checks, and building dynamic policies when static attributes are not flexible enough.Updated 2026-06-23
.NET Core · C# CoreC# Delegates, Events, and the Observer PatternHow C# delegates and events work — multicast invocation, the EventHandler pattern, the memory leak you get when you forget to unsubscribe, and when to reach for IObservable instead.Updated 2026-06-23
.NET Core · Entity Framework CoreWorking with EF Core MigrationsEF Core migrations from first principles — how the Up/Down workflow operates, bundles for deployment, seeding data, and the patterns that prevent schema drift from sneaking into CI.Updated 2026-06-23
.NET Core · Performance & DeploymentStructured Logging and Monitoring in ASP.NET CoreStructured logging, health checks, and observability in ASP.NET Core — ILogger message templates, Serilog sinks, log scopes for correlation, OpenTelemetry metrics, and how to keep logging fast in hot paths.Updated 2026-06-23
.NET Core · TestingMocking in .NET with Moq and NSubstituteHow to use Moq and NSubstitute to isolate dependencies in .NET tests — Setup, Verify, argument matchers, strict vs loose behavior, and the over-mocking mistake that makes tests brittle.Updated 2026-06-23
.NET Core · Dependency InjectionService Lifetimes in .NET Core DIWhen to use Singleton, Scoped, or Transient in .NET Core DI — how captive dependencies cause subtle bugs, how disposal interacts with lifetime, and using ValidateScopes to catch registration mistakes before they reach production.Updated 2026-06-23
.NET Core · ASP.NET CoreASP.NET Core Controllers, Model Binding, and Action FiltersHow ASP.NET Core controllers process requests — model binding sources, the ApiController attribute, action filters, content negotiation, and the IActionResult hierarchy.Updated 2026-06-23
.NET Core · Performance & DeploymentDeploying ASP.NET Core to Docker, Kubernetes, and AzureHow to get an ASP.NET Core app into production — publish modes, multi-stage Docker builds, Kubernetes health probes, graceful shutdown, and the configuration mistakes that bite most teams on first deployment.Updated 2026-06-23
.NET Core · Entity Framework CoreHow EF Core Translates LINQ to SQLHow EF Core translates LINQ to SQL — deferred execution, the IQueryable vs IEnumerable distinction that causes full table scans, the N+1 trap, and the query options that actually matter for performance.Updated 2026-06-23
.NET Core · TestingIntegration Testing in ASP.NET Core with WebApplicationFactoryHow to test the full ASP.NET Core pipeline with WebApplicationFactory — swapping real dependencies with test doubles, using SQLite for database tests, and running authenticated requests without a real identity provider.Updated 2026-06-23
.NET Core · SecurityJWT Authentication in ASP.NET CoreHow JWT authentication works in ASP.NET Core — token structure, validation parameters, generating and rotating tokens, symmetric vs asymmetric signing, and the security mistakes interviewers use to filter candidates.Updated 2026-06-23
.NET Core · Dependency InjectionThe .NET Options Pattern: IOptions, IOptionsSnapshot, and IOptionsMonitorHow the .NET Options pattern works — binding configuration to typed classes, picking between IOptions, IOptionsSnapshot, and IOptionsMonitor, and validating settings before the app starts.Updated 2026-06-23
.NET Core · C# CoreC# Pattern Matching and Switch ExpressionsHow C# pattern matching works — switch expressions, type and property patterns, list patterns, and how the compiler generates efficient code for each form.Updated 2026-06-23
.NET Core · ASP.NET CoreASP.NET Core Configuration in DepthHow ASP.NET Core configuration actually works — layered providers, the IOptions family, strongly-typed settings, and validating config at startup before bad values cause runtime errors.Updated 2026-06-23
.NET Core · C# CoreChoosing the Right C# CollectionHow to pick the right .NET collection for the job — the internals that affect performance, thread-safe options, immutable vs read-only abstractions, and when Span<T> eliminates allocations entirely.Updated 2026-06-23
.NET Core · Entity Framework CoreConfiguring Relationships in EF CoreHow EF Core models relationships between entities — fluent configuration vs data annotations, cascade delete defaults, owned types, inheritance strategies, and optimistic concurrency with row versioning.Updated 2026-06-23
.NET Core · C# CoreException Handling Patterns in C#Exception handling in C# — why throw ex destroys the stack trace, when to write custom exceptions, how AggregateException works in async code, and setting up a global handler in ASP.NET Core.Updated 2026-06-23
.NET Core · FundamentalsHow the .NET CLR Works: JIT, GC, and the Assembly ModelHow the .NET CLR takes C# from source to running code — IL, tiered JIT compilation, garbage collection generations, and what changed between .NET Framework, .NET Core, and modern .NET.Updated 2026-06-22
.NET Core · FundamentalsValue Types vs Reference Types in C#How C# splits types between the stack and the heap — copy semantics, boxing costs, struct vs class trade-offs, and the ref struct constraint that makes Span<T> possible.Updated 2026-06-22
.NET Core · FundamentalsC# Generics: Type Constraints, Covariance, and ContravarianceHow C# generics work under the CLR — reification vs type erasure, constraints, variance with out/in, and why generic collections are faster than their non-generic predecessors.Updated 2026-06-22
.NET Core · FundamentalsHow LINQ Works in C#: Deferred Execution and IQueryableHow LINQ defers execution and why it matters — the difference between IEnumerable and IQueryable, common operators that trip up developers, and the performance pitfalls to watch for in database queries.Updated 2026-06-22
.NET Core · FundamentalsNull Safety in C#: Nullable Types and Nullable Reference TypesHow null works in C# — the difference between nullable value types and C# 8 nullable reference types, the operators that make null handling safe, and how flow analysis catches NullReferenceExceptions at compile time.Updated 2026-06-22
Python · Comprehensions & IterationPython Generators vs Iterators vs Comprehensions — Choosing the Right ToolPython generators vs iterators vs list comprehensions — memory footprint, laziness, reusability, and the decision rule for picking the right iteration tool in interviews and production code.Updated 2026-06-21
Python · Memory & InternalsPython == vs is — Equality vs Identity and the Interning TrapPython == vs is explained — what each operator actually tests, when is "accidentally" works on numbers and strings, the only correct uses of is, and the one rule that makes the right choice automatic.Updated 2026-06-21
Python · Object-Oriented ProgrammingPython @classmethod vs @staticmethod vs Instance Method — When to Use EachPython @classmethod vs @staticmethod vs instance method explained — what each receives as its first argument, the alternative-constructor pattern, subclass safety, and the decision rule that makes the right choice obvious.Updated 2026-06-21
Python · Concurrency & ParallelismPython threading vs multiprocessing vs asyncio — Which to Use WhenPython threading vs multiprocessing vs asyncio explained — the GIL, I/O-bound vs CPU-bound work, when each model helps and when it doesn't, and the decision rule engineers use in interviews and production.Updated 2026-06-21
Python · Data StructuresPython list vs tuple vs set — Choosing the Right Data StructurePython list vs tuple vs set explained — mutability, hashability, O(1) membership testing, and the one-question decision rule that makes the right choice obvious in code and interviews.Updated 2026-06-21
Python · Object-Oriented ProgrammingPython ABC vs Protocol — Nominal vs Structural Typing ExplainedPython ABC vs Protocol explained — nominal vs structural subtyping, runtime enforcement vs static checking, @runtime_checkable, and the decision rule for choosing between them in interviews and modern Python code.Updated 2026-06-21
SQL · Window FunctionsSQL Window Functions vs GROUP BY — What the Difference Is and When to Use EachSQL window functions vs GROUP BY explained — row preservation, PARTITION BY, the queries each makes possible, and the decision rule for writing clear, correct aggregation SQL.Updated 2026-06-21
SQL · Subqueries & CTEsSQL JOINs vs Subqueries vs CTEs — Performance and When to Use EachSQL JOINs vs subqueries vs CTEs — how the query planner treats each, when correlated subqueries kill performance, and the decision rule for writing readable, fast SQL in interviews and production.Updated 2026-06-21
SQL · Schema & Data TypesSQL Data Types — Choosing the Right Type for Every ColumnSQL data types explained — integers, decimals, TEXT vs VARCHAR, DATE vs TIMESTAMP, BOOLEAN, JSON, and the hidden cost of wrong type choices.Updated 2026-06-20
SQL · Indexes & PerformanceSQL Indexes — B-tree, Composite, Partial, and Covering IndexesSQL indexes explained — B-tree internals, composite index column order, partial indexes, covering indexes with INCLUDE, and what kills index use.Updated 2026-06-20
SQL · Modifying DataSQL INSERT, UPDATE, DELETE — DML That Stays Safe at ScaleSQL DML explained — INSERT with conflict handling, bulk updates, safe deletes, UPSERT patterns, batching, and the difference between DELETE and TRUNCATE.Updated 2026-06-20
SQL · Security & IntegritySQL Permissions & Roles — GRANT, REVOKE, and Least PrivilegeSQL access control explained — GRANT, REVOKE, roles, least privilege, row-level security, schema permissions, and securing a production database connection.Updated 2026-06-20
SQL · Built-in FunctionsSQL String & Numeric Functions — CONCAT, SUBSTRING, ROUND, and MoreSQL string and numeric functions with real examples — CONCAT, SUBSTRING, TRIM, REPLACE, LENGTH, ROUND, CEIL, FLOOR, MOD, and aggregate math functions.Updated 2026-06-20
SQL · Subqueries & CTEsSQL Subqueries — Scalar, Correlated, and Derived Table PatternsSQL subquery types explained with real examples — scalar subqueries, correlated subqueries, derived tables, EXISTS, and when to use each.Updated 2026-06-20
SQL · TransactionsSQL Transactions — ACID, COMMIT, ROLLBACK, and SAVEPOINTSQL transactions explained — ACID properties, BEGIN/COMMIT/ROLLBACK, SAVEPOINT, autocommit, and how to write multi-step writes that never leave the database in a partial state.Updated 2026-06-20
SQL · Window FunctionsSQL Window Functions — OVER, PARTITION BY, and When to Use ThemSQL window functions explained — OVER, PARTITION BY, ORDER BY inside windows, aggregate vs ranking window functions, and when to use them over GROUP BY.Updated 2026-06-20
SQL · Subqueries & CTEsSQL CTEs Explained — WITH Clauses, Recursive Queries, and Best PracticesSQL Common Table Expressions (WITH) explained — readable multi-step queries, recursive CTEs for hierarchies, and when CTEs vs subqueries vs temp tables.Updated 2026-06-20
SQL · Built-in FunctionsSQL Date & Time Functions — NOW, DATE_TRUNC, EXTRACT, and IntervalsSQL date and time functions with real examples — NOW, CURRENT_DATE, DATE_TRUNC, EXTRACT, date arithmetic, TO_CHAR, and timezone handling.Updated 2026-06-20
SQL · Schema & Data TypesSQL DDL — CREATE, ALTER, and DROP Tables SafelySQL DDL explained — CREATE TABLE, ALTER TABLE, DROP TABLE, schema migrations, and how to make schema changes safely without locking production tables.Updated 2026-06-20
SQL · Security & IntegritySQL Injection — How It Works and How to Prevent ItSQL injection explained — how attacks work, parameterised queries, ORM safety, stored procedure risks, second-order injection, and a defence-in-depth checklist.Updated 2026-06-20
SQL · TransactionsSQL Isolation Levels — Dirty Reads, Phantom Reads, and MVCCSQL isolation levels explained — READ COMMITTED, REPEATABLE READ, SERIALIZABLE, dirty reads, phantom reads, lost updates, MVCC, and SELECT FOR UPDATE.Updated 2026-06-20
SQL · Indexes & PerformanceSQL Query Optimization — Reading EXPLAIN, Fixing Slow QueriesSQL query optimization guide — reading EXPLAIN ANALYZE output, identifying sequential scans, fixing N+1 queries, join strategies, and statistics.Updated 2026-06-20
SQL · Window FunctionsSQL Ranking Functions — ROW_NUMBER, RANK, DENSE_RANK, and NTILESQL ROW_NUMBER, RANK, DENSE_RANK, NTILE, and PERCENT_RANK — differences explained with real examples for top-N filtering, deduplication, and bucketing.Updated 2026-06-20
SQL · Query BasicsSQL SELECT & WHERE — Filtering Rows the Right WayHow SELECT and WHERE work in SQL — column aliases, wildcard pitfalls, comparison operators, NULL handling, LIKE patterns, and IN vs EXISTS.Updated 2026-06-20
SQL · Modifying DataSQL Views — Simplifying Queries, Controlling Access, and Materialized ViewsSQL views explained — regular vs materialized views, updatable views, security views, view performance, and when to use each type with real examples.Updated 2026-06-20
SQL · Built-in FunctionsSQL CASE, COALESCE, and NULL Handling — Practical PatternsSQL CASE expressions, COALESCE, NULLIF, conditional aggregation, and NULL logic explained — with real examples for data cleaning, pivoting, and reporting.Updated 2026-06-20
SQL · Schema & Data TypesSQL Constraints — PRIMARY KEY, FOREIGN KEY, UNIQUE, CHECK, and NOT NULLSQL constraints explained — how PRIMARY KEY, FOREIGN KEY, UNIQUE, CHECK, and NOT NULL protect data integrity, with cascades and deferrable constraints.Updated 2026-06-20
SQL · Query BasicsSQL ORDER BY, LIMIT & OFFSET — Sorting and Paging ResultsHow SQL ORDER BY, LIMIT, OFFSET, and FETCH work — multi-column sorts, NULL ordering, stable pagination, and the keyset alternative to OFFSET.Updated 2026-06-20
SQL · Window FunctionsSQL Window Frames, LAG, and LEAD — Moving Averages and Period ComparisonsSQL window frames (ROWS vs RANGE), LAG, LEAD, FIRST_VALUE, LAST_VALUE — period-over-period comparisons, moving averages, and gap detection explained.Updated 2026-06-20
SQL · Query BasicsSQL Aggregation — GROUP BY, HAVING, and Aggregate FunctionsSQL aggregation explained — COUNT, SUM, AVG, MIN, MAX, GROUP BY, HAVING, and conditional aggregation with real e-commerce examples.Updated 2026-06-20
SQL · Schema & Data TypesDatabase Normalization — 1NF, 2NF, 3NF, and When to DenormalizeDatabase normalization explained with a real e-commerce schema — 1NF, 2NF, 3NF normal forms, update anomalies, and when denormalization is the right call.Updated 2026-06-20
SQL · Query BasicsSQL Set Operations — UNION, INTERSECT, and EXCEPT ExplainedSQL UNION, UNION ALL, INTERSECT, and EXCEPT with real examples — stacking result sets, deduplication costs, and when to use each operator.Updated 2026-06-20
Java · Object-Oriented ProgrammingJava Classes, Objects & Constructors — A Complete GuideJava classes and objects explained — fields and methods, constructors and chaining with this()/super(), this vs super, static vs instance members, final, access modifiers, initializer blocks, and how new allocates on the heap.Updated 2026-06-20
Java · GenericsJava Generics — Type Safety, Generic Classes, Methods & the Diamond OperatorA practical guide to Java generics — why they exist, how to write generic classes and methods, type-parameter conventions, the diamond operator, raw types, generic invariance, and generic constructors.Updated 2026-06-20
Java · JVM InternalsJava JVM Memory Explained — Heap, Stack, and Everything In BetweenA complete guide to JVM memory — stack vs heap, generational heap regions, Metaspace, escape analysis, TLABs, GC roots, object headers, and how to diagnose OutOfMemoryError and StackOverflowError in production.Updated 2026-06-20
Java · Streams & FunctionalJava Lambdas & Functional Interfaces — A Practical GuideHow Java lambdas and functional interfaces actually work — syntax, the java.util.function family, composition, method references, effectively-final capture, and how lambdas differ from anonymous classes.Updated 2026-06-20
Java · Modern JavaJava Records Explained — Immutable Data Classes Without the BoilerplateComplete guide to Java records — record components, canonical and compact constructors, immutability caveats, records vs Lombok, Jackson integration, generic records, local records, serialisation, and use with sealed interfaces and pattern matching.Updated 2026-06-20
Java · JVM InternalsJava Garbage Collection Deep Dive — G1, ZGC, Tuning, and Avoiding GC PausesEverything you need to know about Java GC — mark-and-sweep, generational collection, Serial/Parallel/G1/ZGC/Shenandoah collectors, stop-the-world pauses, GC logs, key tuning flags, finalization pitfalls, and diagnosing GC-related production incidents.Updated 2026-06-20
Java · GenericsJava Generics — Wildcards, Bounded Types & the PECS PrincipleA guide to Java wildcards and bounded types — unbounded, upper- and lower-bounded wildcards, the PECS principle, bounded type parameters, multiple and recursive bounds, wildcard capture, and why generics are invariant.Updated 2026-06-20
Java · CollectionsHow Java HashMap Works Internally — Buckets, Hashing, Resizing & TreeificationA deep dive into Java HashMap internals — the bucket array and Node, the spread function, power-of-two indexing, load factor and resizing, collision handling and treeification, the hashCode/equals contract, null handling, and thread safety.Updated 2026-06-20
Java · Modern JavaJava Sealed Classes — Closed Hierarchies, Exhaustive Switch, and ADTsHow Java sealed classes work — the permits clause, final/sealed/non-sealed modifiers, sealed interfaces, exhaustive switch expressions, algebraic data types with records, sealed vs enum vs abstract class, and inspecting permitted subtypes at runtime.Updated 2026-06-20
Java · Streams & FunctionalJava Stream API — Pipelines, Laziness & the Core Operations ExplainedA practical guide to the Java Stream API: how a stream pipeline works, lazy intermediate vs eager terminal operations, short-circuiting, the core ops (filter/map/flatMap/reduce), primitive streams, and parallel-stream pitfalls.Updated 2026-06-20
Java · FundamentalsJava Strings — Immutability, the String Pool & StringBuilder ExplainedHow Java Strings really work — why they're immutable, the string pool and intern(), == vs equals, String vs StringBuilder vs StringBuffer, concatenation performance, key API methods, text blocks, and char[] for passwords.Updated 2026-06-20
Java · ConcurrencyJava Synchronization — synchronized, Locks, wait/notify & DeadlockHow Java synchronization actually works — the synchronized keyword and intrinsic monitors, happens-before visibility, wait/notify, ReentrantLock vs synchronized, ReadWriteLock, Condition, and how to avoid deadlock.Updated 2026-06-20
Java · ExceptionsJava Try-With-Resources — Automatic Resource Management ExplainedHow Java try-with-resources works under the hood — AutoCloseable and Closeable, compiler desugaring, reverse close ordering, suppressed exceptions, the effectively-final form, and when to still reach for try/finally.Updated 2026-06-20
Java · FundamentalsJava Arrays — Declaration, the Arrays Utility Class & GotchasA practical guide to Java arrays — declaring and initializing them, default values and fixed length, length vs length() vs size(), jagged arrays, array covariance and ArrayStoreException, the Arrays utility class, copying, and array vs ArrayList.Updated 2026-06-20
Java · JVM InternalsJava Class Loading Explained — ClassLoaders, Delegation, and Metaspace LeaksHow Java class loading works — the Bootstrap/Platform/App ClassLoader hierarchy, parent-delegation model, loading/linking/initialisation phases, class identity, ClassNotFoundException vs NoClassDefFoundError, custom ClassLoaders, class unloading, and diagnosing Metaspace leaks in hot-deploy environments.Updated 2026-06-20
Java · Streams & FunctionalJava Collectors & groupingBy — collect(), Downstream Collectors & Custom CollectorsA deep guide to Java Collectors — the collect() mutable reduction, the four-part Collector anatomy, toMap merge functions, groupingBy with downstream and nested collectors, partitioningBy, joining, the statistics collectors, collectingAndThen, and writing a custom Collector.of.Updated 2026-06-20
Java · ExceptionsJava Custom Exceptions — Design, Chaining & Best PracticesHow to create custom exceptions in Java the right way — checked vs unchecked design, the four standard constructors, exception chaining and translation, custom fields, serialVersionUID, and modern unchecked-default style.Updated 2026-06-20
Java · ConcurrencyJava Executors, Thread Pools & CompletableFuture — A Complete GuideA deep guide to Java concurrency with executors — the Executor framework, tuning ThreadPoolExecutor, Callable and Future, composing async work with CompletableFuture, graceful shutdown, and virtual threads.Updated 2026-06-20
Java · GenericsJava Type Erasure Explained — How Generics Vanish at RuntimeHow Java type erasure works — why generics are compile-time only, reifiable vs non-reifiable types, generic array and heap pollution restrictions, bridge methods, name clashes, and the Class<T> type-token escape hatch.Updated 2026-06-20
Java · Object-Oriented ProgrammingJava Polymorphism Explained — Overriding vs Overloading & Dynamic DispatchHow Java polymorphism really works — runtime vs compile-time, method overriding rules, overload resolution, dynamic dispatch, covariant returns, why fields and statics are hidden not overridden, and upcasting with instanceof.Updated 2026-06-20
Java · CollectionsJava Set Explained — HashSet vs LinkedHashSet vs TreeSetA deep guide to Java's Set implementations — HashSet, LinkedHashSet and TreeSet — covering dedup via equals/hashCode and compareTo, ordering, NavigableSet, EnumSet, concurrent sets and set algebra.Updated 2026-06-20
Java · Modern JavaJava Switch Pattern Matching — Expressions, Type Patterns, and Record DeconstructionComplete guide to Java switch pattern matching — switch expressions vs statements, arrow vs colon syntax, yield, type patterns, guarded patterns with when, record deconstruction, exhaustiveness, null handling, and dominance rules.Updated 2026-06-20
Java · ConcurrencyJava Concurrent Collections — ConcurrentHashMap, BlockingQueue & AtomicsA practical guide to Java's concurrent collections — why ConcurrentHashMap beats synchronized wrappers, weakly consistent iterators, copy-on-write structures, the BlockingQueue family, and the atomic package with CAS.Updated 2026-06-20
Java · Object-Oriented ProgrammingJava Interfaces vs Abstract Classes — When to Use WhichJava interfaces vs abstract classes explained — abstraction, default/static/private interface methods, functional and marker interfaces, multiple inheritance of type, default-method conflict resolution, and how to choose the right one in interviews.Updated 2026-06-20
Java · FundamentalsJava Keywords & Modifiers — Access, static, final & abstract ExplainedA guide to Java keywords and modifiers — the four access levels, static vs instance, final variables/methods/classes, abstract and its illegal combos, transient, volatile, synchronized, this/super, instanceof, and var.Updated 2026-06-20
Java · Streams & FunctionalJava Optional — A Practical Guide to Avoiding NullPointerExceptionMaster Java Optional to kill NullPointerExceptions for good — creating, consuming, and transforming values, the orElse vs orElseGet trap, and the anti-patterns interviewers love to ask about.Updated 2026-06-20
Java · CollectionsJava Queue & Deque — ArrayDeque, PriorityQueue & Producer-ConsumerA deep guide to Java's Queue and Deque interfaces — the throwing vs returning method families, ArrayDeque as a fast stack, PriorityQueue heap ordering, and BlockingQueue producer-consumer patterns.Updated 2026-06-20
Java · Modern JavaJava Text Blocks — Multi-line Strings Without the Escape ClutterEverything about Java text blocks — triple-quote syntax, incidental whitespace stripping, line-ending normalisation, new escape sequences, formatted(), trailing-space handling, and practical examples with SQL, JSON, and HTML.Updated 2026-06-20
Java · CollectionsJava Comparable vs Comparator — Sorting, Chaining & the PitfallsJava Comparable vs Comparator explained — natural vs custom ordering, the compareTo contract and the a-b overflow trap, comparator factory chaining, and how every Java sort (Collections, List, Arrays, Stream, TreeSet, heaps) picks its order.Updated 2026-06-20
Java · Object-Oriented ProgrammingJava equals & hashCode Contract — Identity, Equality, and Hash CollectionsMaster Java's equals/hashCode contract — == vs equals, identity vs equality, the five equals properties, why equal objects must share a hash, how HashMap breaks when you get it wrong, instanceof vs getClass, Objects helpers, and records.Updated 2026-06-20
Java · Modern JavaJava instanceof Pattern Matching — Type Tests Without the Redundant CastComplete guide to Java instanceof pattern matching — binding variables, scope and flow-sensitive typing, negation guards, compound conditions, null safety, equals() improvements, generics limitation, and the relationship to switch type patterns.Updated 2026-06-20
Java · ConcurrencyJava volatile & the Java Memory Model — Visibility, happens-before & Safe PublicationHow the Java Memory Model really works — the visibility problem, the happens-before relationship, what volatile guarantees (and what it doesn't), double-checked locking, safe publication, final-field freeze, and long tearing.Updated 2026-06-20
Java · Modern JavaJava Virtual Threads (Project Loom) — Thread-per-Request at ScaleComplete guide to Java virtual threads — how they differ from platform threads, carrier threads, the thread-per-request model, pinning, ThreadLocal vs ScopedValue, structured concurrency, when not to use virtual threads, migration from thread pools, and comparison with reactive programming.Updated 2026-06-20
Java · Modern JavaJava Record Patterns — Inline Deconstruction for Cleaner Switch DispatchComplete guide to Java record patterns — destructuring record components in instanceof and switch, nested record patterns, var in patterns, guarded patterns, exhaustiveness, generics caveats, null handling, and replacing the Visitor pattern.Updated 2026-06-20
Java · Modern JavaJava Sequenced Collections — getFirst, getLast, and reversed() for Every Ordered TypeComplete guide to Java 21 sequenced collections — SequencedCollection, SequencedSet, and SequencedMap interfaces, getFirst/getLast/addFirst/addLast, reversed() live views, which existing types implement the new interfaces, and replacing pre-Java-21 workarounds.Updated 2026-06-20
Python · Errors & ExceptionsPython Context Managers and the with Statement ExplainedHow Python context managers and the with statement work — __enter__ and __exit__, contextlib.contextmanager, exception handling in __exit__, and managing multiple resources.Updated 2026-06-19
Python · FunctionsPython Decorators Explained — Wrapping Functions, functools.wraps, and Decorators with ArgumentsHow Python decorators work — the @ syntax as sugar for wrapping, why you need functools.wraps, decorators that take arguments, class-based decorators, and stacking order.Updated 2026-06-19
Python · Data StructuresPython Dictionaries Explained — Ordering, Lookups, and MergingHow Python dictionaries work — insertion ordering since 3.7, get vs setdefault, merging with the union operator, keys/values/items views, hashable keys, and O(1) lookups.Updated 2026-06-19
Python · Object-Oriented ProgrammingPython Dunder Methods Explained — Operator Overloading and the Data ModelHow Python's dunder (magic) methods work — __repr__ vs __str__, __eq__ and __hash__, operator overloading, the sequence protocol, __call__, and how they hook into the data model.Updated 2026-06-19
Python · Pythonic IdiomsPython EAFP vs LBYL Explained — Why Pythonistas Ask Forgiveness, Not PermissionThe two coding styles for handling possible failure in Python — EAFP (try/except) vs LBYL (check first) — why EAFP is usually more Pythonic, and when LBYL and race conditions tip the balance.Updated 2026-06-19
Python · Functional ProgrammingPython functools Explained — lru_cache, partial, reduce, wraps, and cached_propertyA practical tour of Python's functools module — memoising with lru_cache and cache, building specialised callables with partial, reduce, preserving metadata with wraps, and cached_property.Updated 2026-06-19
Python · Memory & InternalsPython Garbage Collection Explained — Reference Counting, Cycle Detection, and the gc ModuleHow CPython manages memory — reference counting as the primary mechanism, the cyclic garbage collector that handles reference cycles, generational collection, and how to work with the gc module.Updated 2026-06-19
Python · Comprehensions & IterationPython Generators and yield Explained — Lazy Iteration and MemoryHow Python generators and yield work — lazy evaluation, the memory win over lists, generator expressions vs comprehensions, yield from, and infinite sequences.Updated 2026-06-19
Python · Concurrency & ParallelismPython Threading and the GIL Explained — Threads vs MultiprocessingWhat the Global Interpreter Lock is, why threads don't speed up CPU-bound Python but help I/O-bound work, race conditions and locks, and when to reach for multiprocessing.Updated 2026-06-19
Python · Modules, Packages & EnvironmentsPython Import System Explained — Modules, sys.path, Caching, and Absolute vs Relative ImportsHow Python's import system works — what happens on import, module caching in sys.modules, how sys.path is searched, absolute vs relative imports, and avoiding circular import problems.Updated 2026-06-19
Python · Object-Oriented ProgrammingPython Inheritance and the MRO Explained — super(), the Diamond Problem, and MixinsHow Python inheritance works — single vs multiple inheritance, the C3 method resolution order, what super() really does, how the diamond problem is solved, and mixins.Updated 2026-06-19
Python · Data StructuresPython Lists and Slicing Explained — append vs extend, sort vs sorted, and Negative StepsHow Python lists work — slicing with negative steps, the difference between append, extend, and insert, list.sort vs sorted, and when a list is the wrong tool.Updated 2026-06-19
Python · TestingPython pytest Explained — assert, Fixtures, Parametrize, and Testing ExceptionsHow to write tests with pytest — plain assert with rich introspection, fixtures for setup and teardown, parametrize for table-driven tests, and pytest.raises for asserting exceptions.Updated 2026-06-19
Python · Standard Library EssentialsPython Regular Expressions Explained — The re Module, Groups, and Common PatternsHow to use Python's re module — match vs search vs findall, capturing and named groups, substitution with re.sub, compiling patterns, and why raw strings and non-greedy matching matter.Updated 2026-06-19
Python · Type Hints & TypingPython Type Hints Explained — Annotations, Optional, and mypyHow Python type hints work — whether they're enforced at runtime, Optional and Union (and the | syntax), built-in generics like list[int], Any vs object, and what mypy does.Updated 2026-06-19
Python · Object-Oriented ProgrammingPython Classes and Instances Explained — __init__ vs __new__, self, and AttributesHow Python classes and instances work — what self is, __init__ vs __new__, instance vs class attributes, __repr__ vs __str__, and the object creation flow.Updated 2026-06-19
Python · Comprehensions & IterationPython Comprehensions Explained — List, Dict, Set, and When Not to Use ThemHow Python comprehensions work — filtering and conditional transforms, nested comprehensions, dict and set comprehensions, and when a plain loop is the better choice.Updated 2026-06-19
Python · Standard Library EssentialsPython Files & pathlib Explained — Reading, Writing, and Modern Path HandlingHow to work with files and paths in Python — opening files with context managers, read/write modes, text vs binary, and the modern pathlib API that replaces os.path string juggling.Updated 2026-06-19
Python · FunctionsPython Function Arguments Explained — *args, **kwargs, Defaults, and Keyword-OnlyHow Python function arguments work — positional vs keyword, *args and **kwargs, default values and the mutable-default trap, keyword-only and positional-only parameters, and the correct parameter order.Updated 2026-06-19
Python · Type Hints & TypingPython Generics & Protocols Explained — TypeVar, Generic Classes, and Structural TypingHow to write reusable, precisely-typed Python — generics with TypeVar and the 3.12 syntax, generic classes, bounded type variables, and Protocols for structural (duck) typing.Updated 2026-06-19
Python · Memory & InternalsPython Identity Explained — is vs ==, id(), and Integer/String InterningHow object identity works in Python — the difference between is and ==, what id() returns, and why small-integer and string interning makes is behave in surprising ways.Updated 2026-06-19
Python · Functional ProgrammingPython map, filter & reduce Explained — Functional Transforms vs ComprehensionsHow map, filter, and reduce work in Python — lazy iterators, when they beat comprehensions, why reduce moved to functools, and the Pythonic alternatives most code should prefer.Updated 2026-06-19
Python · TestingPython Mocking & Patching Explained — unittest.mock, patch, and Asserting CallsHow to isolate code under test with unittest.mock — Mock and MagicMock, patching with the right target, setting return values and side effects, asserting calls, and the "patch where it's used" rule.Updated 2026-06-19
Python · Concurrency & ParallelismPython Multiprocessing Explained — Escaping the GIL, Process Pools, and Sharing DataHow Python multiprocessing achieves true parallelism by sidestepping the GIL — spawning processes, using Pool, passing data with pickling, and sharing state with queues and shared memory.Updated 2026-06-19
Python · Modules, Packages & EnvironmentsPython Packages & __main__ Explained — __init__.py, Running Modules, and Package LayoutHow Python packages work — __init__.py and what it's for, the __name__ == "__main__" idiom, running packages with python -m and __main__.py, and modern src-layout project structure.Updated 2026-06-19
Python · Pythonic IdiomsPython PEP 8 & Style Explained — Naming, Layout, and Writing Idiomatic CodeWhat PEP 8 actually requires — naming conventions, indentation and line length, import ordering, whitespace rules — plus the tools (black, ruff) that enforce style so you never argue about it again.Updated 2026-06-19
Python · FundamentalsPython Scope and the LEGB Rule Explained — global, nonlocal, and ClosuresHow Python resolves names with the LEGB rule, why assignment makes a name local (and triggers UnboundLocalError), and what the global and nonlocal keywords actually do.Updated 2026-06-19
Python · Errors & ExceptionsPython try/except/else/finally Explained — Catching Exceptions the Right WayHow Python exception handling works — the full try/except/else/finally structure, catching specific exceptions, exception chaining with raise from, and the patterns that avoid swallowing bugs.Updated 2026-06-19
Python · Data StructuresPython Tuples and Named Tuples Explained — Immutability, Packing, and namedtupleWhen to use a tuple over a list, how packing and unpacking work, whether tuple immutability is deep, and how namedtuple and typing.NamedTuple give fields names.Updated 2026-06-19
Python · Concurrency & ParallelismPython asyncio Explained — Coroutines, the Event Loop, await, and Running Tasks ConcurrentlyHow Python's asyncio works — what a coroutine really is, what await does, how the event loop schedules tasks, and how to run many I/O-bound operations concurrently without threads.Updated 2026-06-19
Python · FunctionsPython Closures Explained — Free Variables, nonlocal, and the Loop TrapWhat a Python closure is, how free variables are captured, the role of nonlocal, the late-binding loop gotcha, and when a closure beats a class.Updated 2026-06-19
Python · Pythonic IdiomsPython Common Gotchas Explained — Mutable Defaults, Late Binding, and Other TrapsThe Python gotchas that bite everyone — mutable default arguments, late-binding closures in loops, modifying a list while iterating, is vs ==, and the classic copy and integer-caching surprises.Updated 2026-06-19
Python · Memory & InternalsThe CPython Execution Model Explained — Bytecode, the Interpreter Loop, and the GILHow CPython actually runs your code — compilation to bytecode, code objects and the evaluation loop, the stack-based virtual machine, .pyc caching, and where the GIL fits in.Updated 2026-06-19
Python · Errors & ExceptionsPython Custom Exceptions Explained — The Exception Hierarchy and Designing Your Own ErrorsHow Python's exception hierarchy is structured and how to design custom exceptions — subclassing Exception, building an exception base class for your package, adding attributes, and when to create new types.Updated 2026-06-19
Python · Standard Library EssentialsPython datetime Explained — date, time, timedelta, Timezones, and ParsingHow Python's datetime module works — date vs datetime, naive vs aware timezones, arithmetic with timedelta, parsing and formatting with strptime and strftime, and why you should default to UTC.Updated 2026-06-19
Python · Comprehensions & IterationPython Iterators and the Iterator Protocol Explained — iter, next, and for LoopsHow Python iteration really works — iterable vs iterator, the __iter__/__next__ protocol, what for loops do under the hood, and why an iterator is exhausted after one pass.Updated 2026-06-19
Python · Functional ProgrammingPython itertools Explained — Lazy Iterators for Chaining, Grouping, and CombinatoricsA practical tour of Python's itertools — infinite iterators, chain, islice, groupby, accumulate, and the combinatoric tools product, permutations, and combinations, all lazy and memory-efficient.Updated 2026-06-19
Python · FundamentalsPython Numbers and Operators Explained — int, float, Floor Division, and FloatsPython's numeric types and operators — why integers never overflow, how floor division and modulo behave with negatives, and why 0.1 + 0.2 isn't 0.3.Updated 2026-06-19
Python · Modules, Packages & EnvironmentsPython Virtual Environments & pip Explained — venv, Dependency Isolation, and Reproducible InstallsWhy Python projects need virtual environments and how to use them — creating venvs, how pip installs packages, pinning with requirements.txt, and modern tooling like pyproject.toml and uv.Updated 2026-06-19
Python · Concurrency & ParallelismPython concurrent.futures Explained — ThreadPoolExecutor, ProcessPoolExecutor, and FuturesHow to use concurrent.futures — the high-level Executor API, the difference between ThreadPoolExecutor and ProcessPoolExecutor, working with Future objects, and map vs submit.Updated 2026-06-19
Python · Comprehensions & IterationPython enumerate, zip and Unpacking Explained — Indexes, Pairing, and Star ArgsHow to loop the Pythonic way with enumerate and zip, unzip with zip(*), zip_longest, extended star unpacking, and building dicts from paired iterables.Updated 2026-06-19
Python · Standard Library EssentialsPython Serialization Explained — JSON, CSV, and pickle for Saving and Exchanging DataHow to serialize data in Python — the json module for interchange, the csv module for tabular data, pickle for Python objects, and the security and portability trade-offs between them.Updated 2026-06-19
Python · FunctionsPython Lambdas and Higher-Order Functions Explained — key=, First-Class FunctionsWhat Python lambdas are and their limits, lambda vs def, higher-order functions, how the key argument powers sorted/max/min, and what first-class functions mean.Updated 2026-06-19
Python · Object-Oriented ProgrammingPython Methods and Properties Explained — staticmethod, classmethod, and @propertyThe difference between instance methods, classmethods, and staticmethods, how classmethods make alternative constructors, and how @property gives computed and read-only attributes.Updated 2026-06-19
Python · Data StructuresPython Sets and Frozensets Explained — Set Operations, O(1) Membership, and DedupHow Python sets work — union/intersection/difference, why membership testing is O(1), removing duplicates, add vs discard vs remove, and when you need a frozenset.Updated 2026-06-19
Python · FundamentalsPython Strings and Formatting Explained — f-strings, str vs bytes, and joinPython string formatting compared (f-strings, .format, %), the difference between str and bytes, why join beats += in a loop, and the format spec mini-language.Updated 2026-06-19
Python · Data StructuresPython collections Module Explained — Counter, defaultdict, and dequeThe specialised containers in Python's collections module — Counter for tallying, defaultdict for grouping, deque for fast ends, ChainMap, and where OrderedDict still fits.Updated 2026-06-19
Python · Object-Oriented ProgrammingPython Dataclasses and __slots__ Explained — @dataclass, frozen, and field()What @dataclass generates for you, frozen dataclasses, why mutable defaults need field(default_factory), what __slots__ buys you, and choosing between a dataclass and a namedtuple.Updated 2026-06-19
Python · FundamentalsPython Truthiness and Type Conversion Explained — Falsy Values, and/or, and __bool__Which Python values are falsy, how custom objects decide their truthiness with __bool__ and __len__, what and/or actually return, and how explicit conversions like int() and list() work.Updated 2026-06-19
Python · Object-Oriented ProgrammingPython Abstract Base Classes and Protocols Explained — ABCs, Duck Typing, and ProtocolHow Python defines interfaces — abstract base classes with @abstractmethod, collections.abc, duck typing, and typing.Protocol for structural (static) typing.Updated 2026-06-19
JavaScript · Arrays & IterationJavaScript Array Methods Explained — map, filter, reduce and the Iteration ToolkitMaster JavaScript array iteration methods — map, filter, reduce, forEach, some, every, find, flatMap and more. Learn what each does, when to use it, and the patterns that matter.Updated 2026-06-18
JavaScript · Classes & OOPJavaScript Class Syntax & Methods Explained — Fields, Getters, and the Prototype TruthA complete guide to JavaScript class syntax — constructors, methods, fields, getters and setters, and what classes really compile to under the hood.Updated 2026-06-18
JavaScript · Modern JavaScript (ES6+)JavaScript Destructuring, Spread & Rest — The Complete Guide to Objects and ArraysMaster object destructuring, spread, and rest in modern JavaScript — renaming, defaults, nested patterns, merging objects, rest parameters, and the shallow-copy pitfall.Updated 2026-06-18
JavaScript · Objects & PrototypesJavaScript Objects & Properties — Creation, Descriptors, Getters and EnumerationA complete guide to JavaScript objects — ways to create them, property descriptors, getters and setters, enumeration, freezing, and copying. Learn how the object model really works.Updated 2026-06-18
JavaScript · Classes & OOPJavaScript Class Inheritance — extends, super, and Method Overriding ExplainedMaster class inheritance in JavaScript — how extends builds the prototype chain, what super does in constructors and methods, overriding, and the rules you must follow.Updated 2026-06-18
JavaScript · Arrays & IterationMutating vs Non-Mutating Array Methods in JavaScript — Immutability Done RightUnderstand which JavaScript array methods mutate and which return new arrays — push vs concat, sort vs toSorted, copying, and why immutability prevents whole classes of bugs.Updated 2026-06-18
JavaScript · Modern JavaScript (ES6+)Optional Chaining & Nullish Coalescing in JavaScript — Safe Access Done RightLearn optional chaining (?.) and nullish coalescing (??) in JavaScript — safe property access, the falsy-vs-nullish distinction, logical assignment operators, and the pitfalls to avoid.Updated 2026-06-18
JavaScript · Objects & PrototypesJavaScript Prototypes & the Prototype Chain Explained — A Visual GuideUnderstand JavaScript prototypes and the prototype chain — how property lookup works, __proto__ vs prototype, Object.create, and why this model underpins inheritance in JS.Updated 2026-06-18
JavaScript · Arrays & IterationJavaScript Array Searching & Sorting — indexOf, find, the sort() Gotcha and ComparatorsLearn to search and sort arrays in JavaScript — indexOf vs includes, the NaN gotcha, find, the notorious sort() string-coercion bug, comparators, stable sort and multi-key sorting.Updated 2026-06-18
JavaScript · FunctionsJavaScript Higher-Order Functions — Currying, Composition, Memoization and MoreMaster higher-order functions in JavaScript — functions that take or return functions. Learn callbacks, composition, currying, partial application, memoization, debounce and throttle.Updated 2026-06-18
JavaScript · Objects & PrototypesPrototypal Inheritance in JavaScript — The Complete Practical GuideLearn prototypal inheritance in JavaScript — delegation vs concatenation, Object.create patterns, sharing behavior, overriding methods, and how it differs from classical inheritance.Updated 2026-06-18
JavaScript · Classes & OOPJavaScript Static & Private Class Members — Fields, Methods, and True EncapsulationLearn static and private members in JavaScript classes — static fields and methods, the hash private syntax, private methods, static blocks, and real encapsulation versus convention.Updated 2026-06-18
JavaScript · Modern JavaScript (ES6+)JavaScript Template Literals & Tagged Templates — Interpolation, Multiline and DSLsMaster JavaScript template literals — interpolation, multiline strings, expression embedding, tagged templates, String.raw, and the security pitfalls of unescaped interpolation.Updated 2026-06-18
JavaScript · Arrays & IterationJavaScript Array Destructuring & Spread — Unpacking, Copying and Combining ArraysMaster array destructuring and the spread operator in JavaScript — defaults, skipping, swapping, nested patterns, rest elements, copying and merging arrays, and consuming iterables.Updated 2026-06-18
JavaScript · FunctionsJavaScript Function Types & Parameters — Declarations, Arrows, Defaults and RestA complete guide to JavaScript function types and parameters — declarations vs expressions vs arrows, default and rest parameters, the arguments object, and parameter destructuring.Updated 2026-06-18
JavaScript · Classes & OOPJavaScript Mixins & Composition — Sharing Behavior Beyond Single InheritanceLearn mixins and composition in JavaScript — why single inheritance is limiting, how to build mixins with functions and Object.assign, and why composition often beats deep class hierarchies.Updated 2026-06-18
JavaScript · Objects & PrototypesThe new Operator & Constructor Functions in JavaScript — How Object Creation Really WorksA deep dive into JavaScript's new operator and constructor functions — what new actually does step by step, return values, new.target, and the classic forgotten-new bug.Updated 2026-06-18
JavaScript · Modern JavaScript (ES6+)JavaScript Symbols Explained — Unique Keys, the Global Registry and Well-Known SymbolsUnderstand JavaScript Symbols — unique primitive keys, Symbol.for and the global registry, hidden properties, and well-known symbols like Symbol.iterator and Symbol.toPrimitive that hook into the language.Updated 2026-06-18
JavaScript · FunctionsJavaScript Generators & Iterators Explained — Lazy Sequences and the Iteration ProtocolsUnderstand JavaScript generators and iterators — the iterator and iterable protocols, function* and yield, lazy and infinite sequences, two-way communication, and async generators.Updated 2026-06-18
Java · CollectionsJava Collections Framework — Lists, Maps & Sets ExplainedJava Collections Framework interview questions — List vs Set vs Map, ArrayList vs LinkedList, HashMap internals, fail-fast iterators, Comparable vs Comparator, generics and immutable collections.Updated 2026-06-18
Java · ConcurrencyJava Concurrency — Threads, Synchronization & the Executor FrameworkJava concurrency interview questions — threads vs Runnable, synchronized, volatile, the memory model, deadlock, wait/notify, executors, futures, CompletableFuture and atomic classes.Updated 2026-06-18
Java · FundamentalsJava Data Types & Variables — Primitives, Wrappers & the String PoolJava data types and variables interview questions — primitives vs wrappers, autoboxing, Integer caching, String immutability and the pool, pass-by-value, casting and the var keyword.Updated 2026-06-18
Java · ExceptionsJava Exception Handling — Checked vs Unchecked, try/catch & Best PracticesJava exception handling interview questions — checked vs unchecked, the exception hierarchy, try/catch/finally, try-with-resources, custom exceptions, chaining, and common pitfalls like swallowing exceptions.Updated 2026-06-18
Java · Object-Oriented ProgrammingJava OOP — Inheritance, Polymorphism, Abstraction & EncapsulationJava OOP interview questions — the four pillars, inheritance vs composition, abstract classes vs interfaces, overloading vs overriding, polymorphism, the equals/hashCode contract, records and enums.Updated 2026-06-18
JavaScript · FunctionsJavaScript Closures Explained — From Basics to Advanced PatternsJavaScript closure interview questions and answers — what closures are, how they capture variables, practical uses and common pitfalls.Updated 2026-06-17
JavaScript · Asynchronous JavaScriptJavaScript Promises & Async/Await — The Complete GuideJavaScript promise and async/await interview questions — states, chaining, error handling, Promise.all vs race, and converting callbacks.Updated 2026-06-17
JavaScript · FundamentalsJavaScript Variables, Scope & Hoisting — var, let & const ExplainedCommon JavaScript interview questions on var, let and const, scope, hoisting and the temporal dead zone, with clear answers and examples.Updated 2026-06-17
JavaScript · FundamentalsJavaScript Data Types & Type Coercion — The Complete GuideJavaScript interview questions on primitive types, type coercion, == vs ===, truthy/falsy values and checking types, with examples.Updated 2026-06-17
JavaScript · Asynchronous JavaScriptThe JavaScript Event Loop — How Asynchronous Code Really WorksJavaScript event loop interview questions — the call stack, task and microtask queues, and how asynchronous code is scheduled.Updated 2026-06-17
JavaScript · FunctionsThe "this" Keyword in JavaScript — A Complete Guide to BindingJavaScript `this` interview questions — how this is bound, arrow vs regular functions, call/apply/bind and common context bugs.Updated 2026-06-17
React · HooksReact useState Hook — A Complete Guide with ExamplesReact useState interview questions — state updates, batching, functional updates, lazy initialization and why state seems one render behind.Updated 2026-06-17
React · HooksReact useEffect Hook — A Complete Guide to Effects, Dependencies & CleanupReact useEffect interview questions and answers — the dependency array, cleanup functions, effect timing and common mistakes.Updated 2026-06-17
Python · FundamentalsPython Mutability — Mutable vs Immutable Types ExplainedPython interview questions on mutable vs immutable types, the mutable default argument trap, is vs ==, and shallow vs deep copy.Updated 2026-06-17
SQL · Query BasicsSQL Joins Explained — INNER, OUTER, SELF & Anti-Joins with ExamplesSQL join interview questions — inner vs outer joins, left vs right, self joins and how NULLs behave, with examples.Updated 2026-06-17