Study Books

Comprehensive study materials on Python, Java, and interview preparation.

No books found.

Filter by Topic

429s and Backoff
Abstract Classes
Abstraction Discipline
Access Modifiers and Visibility
Advanced Python
Aggregation Patterns
Annotation Processors
Answer Structure
API Contract Testing
API Errors
API Evolution
API Versioning
Application Properties
Architecture
Argparse And Commands
Arrange Act Assert
async def and await
Asynchronous HTTP
Atomic Variables
Authentication
Automation Scripts
Background Jobs
Backpressure Strategies
Basic HTTP Clients
Basic Modeling
Basic pytest Assertions
Basic SQLite Queries
Batch Helpers
Batching
Bean Scope
Behavioral Stories
BigDecimal and Money
Blocking the Event Loop
Boundary And Failure Tests
Bounded Contexts
Branching Policies
Breaking Encapsulation
Build Lifecycle
Build Tools
Builder Pattern
Built-in Types and None
Caching
Cancellation
Career Growth
Cause Chaining and Error Context
Checked vs Unchecked Exceptions
Choosing The Model
Choosing the Right Collection
Circuit Breakers
Class Loading
Class-Based Context Managers
Classes and Objects
Cleaner Domain Modeling
CLI Design
Closures and Scope
Code Quality
Code Reading
Code Reading and Debugging
Code Reading and Refactoring to Objects
Code Reading and State Safety
Code Reading with Collections
Code Reading with Exceptions
Code Reading with Modern Java
Code Reading with Related Types
Code Review
Code Review (Spotting Bugs)
Code Safety
Collection Performance Basics
Collections
Collections • ArrayDeque as a Queue
Collections • ArrayDeque as a Stack
Collections • ArrayList vs LinkedList
Collections • Comparable vs Comparator
Collections • HashMap Internals
Collections • HashSet Membership and Deduplication
Collections • HashSet vs TreeSet
Collections • LinkedHashMap and Iteration Order
Collections • List, Set, and Map
Collections • LRU Cache with LinkedHashMap
Collections • PriorityQueue and Heap Basics
Collections • TreeMap and NavigableMap
Collections • TreeSet and NavigableSet
CompletableFuture
Composition
Composition vs Inheritance
Concurrency
Concurrency • BlockingQueue and Producer-Consumer
Concurrency • ConcurrentHashMap and Concurrent Collections
Concurrency • ConcurrentLinkedQueue
Concurrency • ConcurrentSkipListMap
Concurrency • CopyOnWriteArrayList
Concurrency • Deadlocks and Race Conditions
Concurrency • ExecutorService, Future, and CompletableFuture
Concurrency • Java Memory Model, volatile, and synchronized
Concurrency • Thread Lifecycle and Creation
Concurrent Collections
Conditions and Branching
Console Input and Output
Constructor vs Field Injection
Constructors
Container And Process Shape
contextlib Helpers
Continuous Integration
Control Flow
Controlled Mutation
Controller Testing
Controllers, Services, Repositories
Core Collections
Core Java
Core Java • equals() and hashCode() Contract
Core Java • equals() vs ==
Core Java • Immutable Class Design
Core Java • Primitive Types and Wrappers
Core Java • static, final, and Initialization
Core Java • String Immutability
Core Java • StringBuilder vs StringBuffer
Cross-Site Request Forgery (CSRF)
Cross-Site Scripting (XSS)
CSV Parsing
Custom Annotations
Custom Exceptions
Data Access
Data Cleanup
Data Structure Choice
Data Structures • Adjacency List vs Adjacency Matrix
Data Structures • Arrays and Indexed Access
Data Structures • Balanced Search Trees
Data Structures • Binary Search Tree
Data Structures • Binary Search Trees
Data Structures • Binary Tree Traversals
Data Structures • bisect on Sorted Lists
Data Structures • Breadth-First Search
Data Structures • Circular Queue and Ring Buffer
Data Structures • collections.deque for Stacks and Queues
Data Structures • Collisions and Load Factor
Data Structures • Counter and Frequency Maps
Data Structures • defaultdict for Grouping
Data Structures • Depth-First Search
Data Structures • Deque for Sliding Window Maximum
Data Structures • Dictionaries and Hash Tables
Data Structures • Doubly Linked Lists
Data Structures • Dynamic Arrays and Resizing
Data Structures • Fast and Slow Pointers
Data Structures • Graphs and Adjacency Lists
Data Structures • Hash Tables and Hashing
Data Structures • Heap Operations and Invariants
Data Structures • heapq and Priority Queues
Data Structures • Linked List Reversal
Data Structures • Linked Lists
Data Structures • Lists as Dynamic Arrays
Data Structures • Monotonic Stack
Data Structures • Prefix Sums
Data Structures • Prefix Sums on Arrays
Data Structures • Queue Fundamentals
Data Structures • Queues and Breadth-First Search
Data Structures • Sets and Membership Testing
Data Structures • Singly Linked Lists
Data Structures • Sliding Window
Data Structures • Sliding Window on Arrays
Data Structures • Stack Fundamentals
Data Structures • Top-K with a Heap
Data Structures • Topological Sort
Data Structures • Tree Fundamentals
Data Structures • Trees and Traversal Orders
Data Structures • Trie / Prefix Tree
Data Structures • Trie and Prefix Tree
Data Structures • Tuples and Fixed Records
Data Structures • Two-Dimensional Arrays
Data Structures • Two-Pointer Technique
Data Structures • Union-Find / Disjoint Set
Data Structures • Union-Find and Disjoint Set
Database per Service
Dataclass Basics
Debugging
Debugging Stories
Decorator Factories
Decorator Pattern
Default Methods and Multiple Inheritance Rules
Defending Tradeoffs
Defensive Copying
Dependency Hygiene
Dependency Injection
Dependency Management
Deserialization Safety
Design Patterns
Design • Design Patterns and SOLID
Dict Comprehensions
Dicts
Distributed Resilience
Distributed Tracing
Docker Containerization
Domain Modeling
Drawing the Blueprint
Dry Runs And Rule Narration
DTO Mapping
DTOs and Entities
Dunder Methods
Dynamic Class Loading
Encapsulation
Engineering Interviews
Entry Points
Enums
Environment Configuration
Environment-Based Deployment
equals and hashCode in Collections
Error Translation
Eventual Consistency (Sagas)
Exceptions
Exceptions Basics
Exceptions • Checked vs Unchecked Exceptions
Exceptions • try-with-resources
ExecutorService
Exponential Backoff Retries
Expressions and Arithmetic
f-Strings and Output Formatting
Factories
Factory Pattern
Fail Fast Validation
Failure Policy
FastAPI
Fields and State
Files and Paths
First Mini Project
Fixtures
For Loops
Function Extraction
Function Type Hints
Functional Java • Lambdas and Functional Interfaces
Functional Java • map, flatMap, and reduce
Functional Java • Parallel Streams
Functional Java • Streams Basics
Functional Pipelines (flatMap)
Functions
functools.wraps
Garbage Collection
Garbage Collection Basics
Generational GC
Generator Expressions
Getters and Setters Design
GIL Judgment
Guard Clauses
Handling Uncertainty
HTTP Integration
HTTP JSON APIs
HttpClient Basics
I/O • JDBC and Prepared Statements
I/O • NIO Files and Path
Idempotency
Immutability Basics
Import System and Caching
Import/Export Mini Project
Indexes
Indexes And Access Patterns
Inheritance Basics
Input Assumptions
Input Validation
Instance Methods
Integration Client Shape
Integration Testing
Interfaces
Interview Strategy
Invariants and Validation
Invariants In __post_init__
Inversion of Control (IoC)
Iteration and Traversal
Iterator Protocol
Iterators and Generators
Jackson ObjectMapper
Java
Java Annotations
Java Interview Questions
Java Modules (JPMS)
Java Records
Java Threading
JDBC
JOINs
JSON Mapping
JSON Parsing
JSON Serialization
JSON Web Tokens (JWT)
JVM Architecture
JVM Trivia
JVM • Class Loading and Initialization
JVM • Garbage Collection
JVM • Heap vs Stack
JWT Signatures
Kubernetes Orchestration
Language Features • Annotations
Language Features • Generics and Wildcards
Language Features • Optional
Language Features • Reflection
Language Features • Type Erasure
Language Upgrades
Layered Architecture
Lazy Pipelines
Linters And Formatters
List Comprehensions
List Interface and ArrayList
Lists
Live Coding Strategy
Log Redaction
Logging
Long-Lived Objects
Loops and Iteration
Map Interface and HashMap
Memory
Memory Management
Message Brokers (Kafka)
Metaspace
Method Overriding
Method.invoke
MethodHandles
Methods
Microbenchmarks
Microservice Architecture
Migration Strategy
Mini Domain Model
Mock Answer Quality
Mocking with Mockito
Modern Date and Time
Modern Java
Modern Java Design Choices
Module Boundaries
Monkeypatching and Mocks
Mutability Traps
Mutation and Copying
mypy Feedback
Nested Data
Networking
Non-Blocking I/O (Event Loops)
Normalization Pipelines
Numeric Types and Money Basics
Object Interaction
Object References
Object Responsibility
Observability
Observer Pattern
OOP
OOP • Abstraction
OOP • Encapsulation
OOP • Inheritance vs Composition
OOP • Interface vs Abstract Class
OOP • Polymorphism, Overloading, and Overriding
Operators and Expressions
Optimization Boundaries
Optional And Collections
OutOfMemoryErrors
OWASP Vulnerabilities
Package Layout
Pagination and Rate Limits
Parameterized Queries
Parameterized Tests
Pathlib
Pattern Abuse
Pattern Matching
Performance
Performance Interview Answers
Performance Tuning
Persistence and Validation
Plaintext Passwords
Polymorphism
PreparedStatements
Processes For CPU Work
Profiling First
Profiling Stories
Project Metadata
Project Reactor
Project Reactor: Flux
Project Reactor: Mono
Project Structure
Project Tooling
Properties and Descriptors
Properties And Encapsulation
Protocols
Proxy and Adapter
Publisher and Subscriber
Pydantic Models
Python
Python Core • Abstract Base Classes vs Protocols
Python Core • Args, Kwargs, and Parameter Kinds
Python Core • asyncio Event Loop and Tasks
Python Core • Classes and Dataclasses
Python Core • Comprehensions
Python Core • concurrent.futures
Python Core • Context Managers
Python Core • datetime and Time Zone Awareness
Python Core • Decorators
Python Core • Descriptors
Python Core • Dunder Methods and Data Model Protocols
Python Core • Exceptions and Custom Errors
Python Core • FastAPI, Pydantic, and Request Validation
Python Core • Global Interpreter Lock (GIL)
Python Core • Import System and sys.modules
Python Core • Iterators, Generators, and yield
Python Core • JSON Serialization vs pickle
Python Core • Lambda, map, and filter
Python Core • LEGB Scope and Closures
Python Core • Locks and Race Conditions
Python Core • Logging
Python Core • Modules, Packages, and Imports
Python Core • Mutable Default Arguments
Python Core • Packaging, Source Distributions, and Wheels
Python Core • pathlib and File I/O
Python Core • Profiling with cProfile and timeit
Python Core • Properties and Validation
Python Core • pytest Fixtures and monkeypatch
Python Core • Reference Counting and Garbage Collection
Python Core • Shallow vs Deep Copy
Python Core • Sorting, Key Functions, and Timsort
Python Core • staticmethod vs classmethod
Python Core • String Formatting and f-Strings
Python Core • subprocess and Shell Boundary Safety
Python Core • Threading, asyncio, and multiprocessing
Python Core • Type Hints and mypy
Python Core • Variables, References, and Mutability
Python Core • Virtual Environments, pip, and pyproject.toml
Python Core • weakref and Object Lifetime
Python Core • __name__ == '__main__' and Entry Points
Python Core • __slots__
Python Fundamentals
Python Internals
Python Interview Questions
Pythonic Data Processing
Queue and Deque Basics
Race Conditions
Raising Exceptions
Reactive Streams
Readability Tradeoffs
Reading Text
Records
Refactoring
Reference Counting and GC
Reflection API
Release Discipline
Reliability
Reliability Stories
Reliable Java Error Design
Reporting and Auditability
Repository Boundaries
Repository Pattern
Resource Cleanup
ResultSets and Mapping
Retention Policies
Return Values
Review Quality
Route Handlers
Row Mapping
Runnable Project Shape
Runtime Patching
Safe Output Writes
Safe Subprocess Calls
Salting and BCrypt
Schema Thinking
Scope and Reassignment
Script Entry Points
Sealed Classes
Secrets Management
Security
Semaphores, Timeouts, and Cancellation
Senior Tradeoffs
Serialization
Service Design
Service Layer
Set Comprehensions
Set Interface and HashSet
Sets
Simple Decorators
Socket Programming
Software Architecture
Sorting and Grouping
Spring Core
Spring Security
Spring Security Filter Chain
SQL
SQL for Java Devs
SQL Injection
SQL Injection Prevention
Stack vs Heap
Standard Library • java.time API
Static Factory Methods
Stop-The-World Pauses
Strategy Pattern
Structured Diagnostics
Switch Expressions
Synchronized and Locks
System Design
Task Coordination
Testing
Testing Explanations
Text Blocks
The STAR Framework
The Volatile Keyword
Thinking Aloud Through Code
this Keyword
Thread Dumps
Thread-Per-Request Bottleneck
Threads For Blocking I/O
throw throws and Propagation
Timeouts and Retries
Timing and Audit Scopes
tmp_path And File Tests
Token And Auth Handling
Tracebacks and Root Cause
Tracing Allocations
Tracing and Code Reading
Tradeoff Language
Transactions
Transactions and Proxies
Transitioning to Senior
Try and Except
try catch finally
Tuples
Type Hints
TypedDict And Shaped Data
Types During Refactors
Unit Testing with JUnit
Upcasting and Dynamic Dispatch
Validation
Value Objects
Variables and Data Types
Variables and Names
Virtual Environments
Virtual Threads
WebFlux vs Virtual Threads
When To Use A Class
While Loops and Retries
Wrapper Types and Autoboxing
Yield And Custom Generators

About Sharp

Sharp is a comprehensive learning app for coding interviews, NCLEX preparation, and professional development.

Features

Study Books
Quizzes
Flashcards
Code Examples

Learn

NCLEX Prep
Terms of Service
Contact Us

Download

Google Play
App Store