The Necessary IT Jargon Buster
ECMA International - An organization that creates standards for technologies.
The specification defined in ECMA-262 for creating a general purpose scripting language.
Synonym - ECMAScript specification
ECMA-262 - This is a standard published by Ecma International. It contains the specification for a general purpose scripting language. While ECMA-262 is the name of the standard, it represents the scripting language specification ECMAScript. ECMAScript provides the rules, details, and guidelines that a scripting language must observe to be considered ECMAScript compliant.
JavaScript - A general purpose scripting language that conforms to the ECMAScript specification.
By reading the ECMAScript specification, you learn how to create a scripting language.
By reading the JavaScript documentation, you learn how to use a scripting language.
JavaScript engine - A program or interpreter that understands and executes JavaScript code.
JavaScript runtime - The environment in which the JavaScript code runs and is interpreted by a JavaScript engine. The runtime provides the host objects that JavaScript can operate on and work with.
Synonym - Host environment
ECMAScript 6 - It is the sixth edition of the ECMA-262 standard, and features major changes and improvements to the ECMAScript specification.
Synonym - ES6, ES2015, and ECMAScript 2015
Babel - A transpiler that can convert ES6 code to ES5 code.
A confusing bit of history is that JavaScript was created in 1996. It was then submitted to Ecma International in 1997 for standardization, which resulted in ECMAScript. At the same time, because JavaScript conformed to the ECMAScript specification, JavaScript is an example of an ECMAScript implementation.
That leaves us with this fun fact: ECMAScript is based on JavaScript, and JavaScript is based on ECMAScript.
Meta data - Metadata is data about data - it provides information that describes, explains, or gives context about other data without being the actual data itself.
- Simple Definition:
Metadata describes the characteristics, properties, and structure of data, helping you understand what the data is, how it's organized, and how to use it.
Meta framework - It is a higher-level framework built on top of an existing web framework that provides additional structure, conventions, and optimizations. Meta frameworks extend base frameworks with features like server-side rendering, file-based routing, and deployment optimizations.
| Meta Framework | Base Framework | Key Features |
|---|---|---|
| Next.js | React | Server components, app router, SSR/SSG |
| Nuxt | Vue | Auto-imports, Nitro server, SSR/SSG |
| SvelteKit | Svelte | Filesystem routing, adapter-based deployment |
| Remix | React | Nested routing, server functions, error boundaries |
| Astro | Multiple (React, Vue, Svelte) | Content-focused, partial hydration |
| Analog | Angular | File-based routing, SSR/SSG, Vite-powered builds |
JAMstack - It is a modern web development architecture pattern that focuses on delivering faster, more secure websites with improved developer experience.
The "JAM" in JAMstack stands for:
- JavaScript: Dynamic functionality runs client-side
- APIs: Server-side operations are abstracted into reusable APIs
- Markup: Pre-rendered HTML content generated at build time
| Category | Examples |
|---|---|
| Static Site Generators | Next.js, Gatsby, Nuxt, Astro, Hugo, Eleventy |
| Headless CMS | Contentful, Sanity, Strapi, WordPress API |
| Deployment Platforms | Netlify, Vercel, GitHub Pages, Cloudflare Pages |
| Build Tools | Webpack, Vite, Parcel |
JAMstack represents a shift from traditional server-rendered applications to pre-built sites enhanced with client-side functionality and APIs.
ORM (Object-Relational Mapping) - It bridges the gap between object-oriented programming and relational databases .
- Purpose: Maps application objects to relational database tables
- Database Type: SQL/Relational databases (MySQL, PostgreSQL, Oracle, SQL Server)
- Data Structure: Tables with rows and columns, strict schema
- Relationships: Foreign keys, joins, many-to-many tables
- Popular Examples:
- Sequelize (JavaScript)
- TypeORM (TypeScript)
- Hibernate (Java)
- Entity Framework (C#)
- SQLAlchemy (Python)
ODM (Object-Document Mapping) - It provides a structured way to define data models for document databases , creating a bridge between your application code and the database.
- Schema Validation: Define expected fields, types, and validation rules
- Type Safety: Ensure data consistency with type definitions
- Default Values: Set automatic values for fields when not provided
- Database Type: NoSQL/Document databases (MongoDB, CouchDB)
- Middleware Hooks: Add pre/post-save logic (validation, transformation)
- Instance Methods: Define reusable functions on model instances
- Static Methods: Create utility functions at the model level
- Consistency: Ensures all documents follow the defined structure
- Popular Examples:
- Mongoose (JavaScript for MongoDB)
- Morphia (Java for MongoDB)
- MongoEngine (Python for MongoDB)
| Aspect | ORM | ODM |
|---|---|---|
| Schema | Strict, predefined tables | Flexible, schema-optional |
| Performance | May have overhead due to joins | Often faster for simple operations |
| Scalability | Vertical scaling is common | Horizontal scaling is easier |
| Query Language | Generates SQL | Uses database-specific queries |
| Data Integrity | Strong ACID compliance | Typically BASE compliance |
| Relations | Well-defined with constraints | Looser with embedded docs or references |
ACID - It is a set of properties that guarantee reliable transaction processing in relational databases.
-
Atomicity: Transactions are all-or-nothing. Either all operations succeed or the entire transaction is rolled back.
- If any part fails, the entire transaction is rolled back
- Example: In a bank transfer, both debit and credit must succeed together
-
Consistency: Every transaction brings the database from one valid state to another, maintaining all defined rules and constraints.
- All data written must follow defined rules, constraints, and triggers
- Referential integrity and data validation rules are maintained
- Example: If a rule states account balances cannot be negative, no transaction can violate this
-
Isolation: Concurrent transactions operate independently without interference.
- Changes made by one transaction aren't visible to others until committed
- Prevents issues like dirty reads, non-repeatable reads, and phantom reads
- Example: Two users modifying the same record won't interfere with each other
-
Durability: Once a transaction is committed, the changes persist permanently, even during system failures or crashes.
- Example: Confirmed payment records remain even if the system crashes seconds later
These properties ensure data integrity and reliability in critical applications like financial systems and business operations.
Direct Database Connectivity - Low-level approach that uses drivers to connect and execute SQL queries against a database . This method requires manual query writing and connection management without the abstraction layers provided by ORMs
- Characteristics:
- Low-level APIs, like JDBC in Java or similar database-specific APIs, provide direct access to the database using SQL, allowing fine-grained control over queries and transactions.
- Raw SQL queries written manually
- Direct use of connection pools and database drivers
- Fine-grained control over database interactions
- Examples: JDBC (Java), ADO.NET (.NET), node-postgres, PyMySQL
| Aspect | Database Connectivity | ORM |
|---|---|---|
| Code Focus | SQL-centric | Object-centric |
| Learning Curve | Requires SQL knowledge | Framework-specific concepts |
| Performance | Optimized for specific queries | May have overhead |
| Database Changes | Manual schema updates | Often includes migrations |
| Complexity | Simple for basic queries, complex for relationships | Handles relationships elegantly |
Database Management System (DBMS) - It is a software that manages the storage, organization, retrieval, security, and integrity of data in a database.
-
Data Storage: Efficiently stores large volumes of structured data
-
Data Retrieval: Provides query mechanisms to access stored information
-
Data Manipulation: Allows inserting, updating, and deleting records
-
Data Security: Controls user access and permissions
-
Data Integrity: Enforces rules to maintain accuracy and consistency
-
Transaction Management: Ensures operations complete correctly
-
Types of DBMS
- Relational DBMS (RDBMS): Stores data in tables with rows and columns
- Examples: MySQL, PostgreSQL, Oracle, SQL Server
- NoSQL DBMS: Stores data in flexible formats beyond tabular relations
- Examples: MongoDB, Cassandra, Redis, Couchbase
- NewSQL: Combines relational guarantees with NoSQL scalability
- Examples: Google Spanner, CockroachDB
- Object-Oriented DBMS: Stores data as objects
- Examples: ObjectDB, db4o
-
Key Components
- Query Processor: Interprets and executes database queries
- Storage Engine: Manages how data is stored and retrieved
- Transaction Manager: Ensures ACID compliance in operations
- Schema Manager: Maintains database structure definitions
- Connection Manager: Handles client connections and sessions
A DBMS serves as the critical intermediary between users and their data, providing tools for developers, interfaces for end users, and ensuring data remains accessible, secure, and consistent.
Island Architecture - It is a modern web development approach that combines server-rendered HTML with isolated interactive components.
-
Core Concept
Island Architecture divides a webpage into two distinct parts:
- Islands: Interactive components that are hydrated with JavaScript
- Ocean: Static, non-interactive HTML content that requires no JavaScript
-
Key Principles
- Partial Hydration: Only interactive components receive JavaScript, not the entire page
- Independent Components: Each "island" hydrates independently and can use different frameworks
- Progressive Enhancement: Pages are functional before any JavaScript loads
- Minimal JavaScript: Reduces overall bundle size by limiting client-side code
- Framework Flexibility: Different islands can use different technologies
| Framework | Description |
|---|---|
| Astro | Built specifically around Islands Architecture |
| Qwik | Uses resumability instead of hydration |
| Fresh | Deno-based framework with built-in Islands support |
| Marko | Automatic partial hydration capabilities |
Meta programming - Metaprogramming is a programming technique that treats code as data, allowing programs to analyze, generate, and transform other code without modifying the real underlying source .
-
Key Techniques
-
Dynamic Proxies and Interception Intercepts method calls without modifying real class definitions, redirecting or augmenting behavior at runtime.
-
Aspect-Oriented Programming Injects cross-cutting concerns (logging, security) without modifying real business logic.
-
Reflection Inspects and manipulates classes and objects at runtime without modifying real type definitions.
-
Decorators and Wrappers Enhances existing functionality without modifying real underlying implementations
-
| Language | Technique | Example |
|---|---|---|
| Java | Proxies | Proxy.newProxyInstance(loader, interfaces, handler) surrounds real objects |
| Python | Decorators | @transaction adds behavior without modifying real functions |
| JavaScript | Monkey patching | oldMethod = obj.method; obj.method = function() { oldMethod.call(this); additionalBehavior(); } |
| Ruby | Method aliasing | alias_method :original_method, :method preserves real method |
| Angular & TypeScript | Decorators | @Component({selector: 'app-root', template: '...'}) adds metadata without modifying real class implementation |
| Ruby | Method aliasing | alias_method :original_method, :method preserves real method |
| C++ | Templates, constexpr | template<typename T> auto add(T a, T b) { return a + b; } |
| Lisp | Macros, homoiconicity | (defmacro when (condition &body body) ...) |
React: Library, Not Framework - React is officially a JavaScript library rather than a framework. This distinction is important in understanding React's design philosophy and how it's used in development.
-
Why React is a Library
- Focus on UI rendering: React concentrates specifically on the view layer
- Minimal opinion: Doesn't dictate application architecture (built-in routing, state management, or form handling)
- Inversion of control: You call React (with libraries, you control when to use them)
- Bring your own tools: No built-in solutions for routing, HTTP, forms, etc.
- It can be incrementally adopted in existing projects.
-
Frameworks vs. Libraries
- Libraries: Provide specific functionality you call when needed
- Frameworks: Provide comprehensive structure where your code fits into their patterns