Your Career, Crafted
with Intention.

Packages in Java provide namespace management, access protection, and code organization. They prevent naming conflicts, enable access modifiers for encapsulation, and make large codebases easier to navigate and maintain by grouping related classes logically.

Strings are immutable in Java for security (used in network connections, file paths), thread safety (can be shared without synchronization), memory efficiency (String pool reduces duplication), and to ensure the hashCode remains constant for use in HashMap/HashSet.

Single Responsibility: A class should have one reason to change. Open/Closed: Open for extension, closed for modification. Liskov Substitution: Subtypes must be substitutable for their base types. Interface Segregation: No client should be forced to depend on unused methods. Dependency Inversion: Depend on abstractions, not concretions.

An Abstract class can have both abstract and concrete methods, constructors, and instance variables. An Interface (pre-Java 8) could only have abstract methods; from Java 8, it can have default and static methods. A class can implement multiple interfaces but extend only one abstract class. Interfaces define "what" an object can do; abstract classes define "what" an object is.

Dependency Injection (DI) is a design pattern where dependencies are provided to a class from the outside rather than being created inside the class. This promotes loose coupling, testability, and flexibility. Common forms: constructor injection, setter injection, and field injection. Frameworks like Spring implement DI extensively.

Lambda expressions in Java 8 provide a concise way to represent anonymous functions. Key features: shorter syntax for functional interfaces, enable functional programming patterns, improve code readability, and facilitate use with Streams API for data processing operations like map, filter, reduce.

Class components use ES6 classes, have lifecycle methods, and use `this.state` and `this.setState()`. Functional components are plain JavaScript functions, use React Hooks (useState, useEffect) for state and lifecycle, are simpler to read and test, and have better performance. Modern React favors functional components with Hooks.

slice() returns a shallow copy of a portion of an array without modifying the original array. splice() changes the original array by removing, replacing, or adding elements. slice is non-mutating; splice is mutating. Example: `arr.slice(1,3)` vs `arr.splice(1,2,'new')`.

Redux provides predictable state management with a single source of truth (store), making state changes traceable via actions and reducers. Benefits: easier debugging with Redux DevTools, time-travel debugging, centralized state accessible across components, and better testability. Ideal for complex applications with shared state.

The Garbage Collector (GC) in Java automatically manages memory by identifying and removing objects that are no longer referenced by the program. It runs in the background, freeing developers from manual memory management. Common GC algorithms: Serial, Parallel, CMS, and G1. The `System.gc()` suggests GC execution but doesn't guarantee it.

Props (properties) are read-only data passed from parent to child components in React. They enable component reusability and dynamic rendering. Props are immutable within the child component — to modify behavior, pass new props from the parent. Example: ``

React's diffing algorithm compares the Virtual DOM with the previous Virtual DOM to determine the minimal set of changes needed to update the actual DOM. It uses heuristics like comparing elements by type and key to optimize performance, making React updates fast even with complex UIs.

The `pass` statement in Python is a null operation — it does nothing. It's used as a placeholder when a statement is syntactically required but no code needs to be executed. Common use: defining empty functions, classes, or loops that will be implemented later. Example: `def func(): pass`

Middleware is software that sits between an application and the operating system or between components of a distributed system. In web frameworks (Express.js, Django), middleware functions process requests/responses, handle authentication, logging, error handling, or modify data before it reaches the route handler.

Use `require()` for CommonJS modules: `const fs = require('fs');` or ES6 import syntax: `import fs from 'fs';` (requires "type": "module" in package.json). Built-in modules don't need installation; custom modules use relative paths: `require('./myModule');`

Atomicity: Transactions are all-or-nothing. Consistency: Database moves from one valid state to another. Isolation: Concurrent transactions don't interfere with each other. Durability: Committed transactions persist even after system failures. ACID ensures reliable database operations.

Normalization organizes database tables to reduce redundancy. 1NF: Atomic values, no repeating groups. 2NF: 1NF + no partial dependency on composite keys. 3NF: 2NF + no transitive dependencies. BCNF: Stricter 3NF where every determinant is a candidate key. Higher normal forms exist but 3NF is most common.

Primary key: Uniquely identifies each row in a table; cannot be NULL, must be unique. Foreign key: A column that references a primary key in another table, establishing relationships between tables. Foreign keys enforce referential integrity in relational databases.

SQL: Relational, structured schema, ACID compliance, uses tables and SQL queries (MySQL, PostgreSQL). NoSQL: Non-relational, flexible schema, scales horizontally, various data models (document, key-value, graph). Examples: MongoDB, Redis, Cassandra. SQL for structured data; NoSQL for unstructured, high-scale applications.

Joins combine rows from multiple tables based on related columns. INNER JOIN: Returns matching rows from both tables. LEFT JOIN: All rows from left table, matched rows from right. RIGHT JOIN: All rows from right table, matched rows from left. FULL OUTER JOIN: All rows from both tables with NULLs where no match exists.

Indexes are database structures that improve query speed by creating pointers to data locations, similar to a book index. They speed up SELECT queries but slow down INSERT/UPDATE/DELETE operations due to index maintenance overhead. Use indexes on frequently queried columns, foreign keys, and columns used in WHERE clauses.

DELETE: Removes specific rows based on conditions, can be rolled back, triggers fire, slower, logs each row deletion. TRUNCATE: Removes all rows quickly, cannot be rolled back (in most databases), no triggers, faster, minimal logging. TRUNCATE resets auto-increment counters; DELETE doesn't.

Operating systems manage hardware resources and provide services to applications. Key functions: Process management (scheduling, multitasking), Memory management (RAM allocation), File system management, Device management (drivers), Security and access control, User interface (CLI/GUI), and Network management.

Deadlock occurs when two or more processes wait indefinitely for resources held by each other. Four conditions: Mutual exclusion, Hold and wait, No preemption, Circular wait. Prevention: Break one of the four conditions. Avoidance: Banker's algorithm. Detection & Recovery: Detect cycles and terminate or rollback processes.

OSI (Open Systems Interconnection) has 7 layers: 1. Physical: Hardware transmission. 2. Data Link: Node-to-node transfer (MAC). 3. Network: Routing, IP addressing. 4. Transport: End-to-end communication (TCP/UDP). 5. Session: Connection management. 6. Presentation: Data formatting, encryption. 7. Application: User-facing protocols (HTTP, FTP, SMTP).

TCP (Transmission Control Protocol): Connection-oriented, reliable, ordered delivery, error checking, slower. Used for web browsing, email, file transfer. UDP (User Datagram Protocol): Connectionless, unreliable, no ordering guarantee, faster, lower overhead. Used for live streaming, gaming, DNS queries where speed matters more than reliability.

DNS (Domain Name System) translates human-readable domain names (www.example.com) into IP addresses (192.168.1.1). Process: Browser checks cache → queries local DNS server → recursive queries to root, TLD, and authoritative nameservers → returns IP → browser connects. DNS is the "phonebook of the internet".