Appendix A: Glossary of Terms in JavaScript Design Patterns

Appendix A: Glossary of Terms

In the realm of software development, especially when dealing with JavaScript design patterns, understanding the terminology is crucial for effective communication and implementation. This glossary provides definitions and explanations for key terms related to JavaScript design patterns, offering insights into their roles and applications within software architecture.

Design Pattern

A design pattern is a general, reusable solution to a commonly occurring problem within a given context in software design. It is not a finished design that can be transformed directly into code but a description or template for how to solve a problem that can be used in many different situations.

Creational Patterns

Creational patterns deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. The basic form of object creation could result in design problems or added complexity to the design. Creational design patterns solve this problem by controlling this object creation.

• Factory Pattern: A creational pattern that uses factory methods to deal with the problem of creating objects without having to specify the exact class of the object that will be created.
• Singleton Pattern: Ensures a class has only one instance and provides a global point of access to it.
• Builder Pattern: Separates the construction of a complex object from its representation, allowing the same construction process to create different representations.

Structural Patterns

Structural patterns ease the design by identifying simple ways to realize relationships among entities. They help ensure that if one part of a system changes, the entire system doesn’t need to do the same.

• Adapter Pattern: Allows the interface of an existing class to be used as another interface.
• Decorator Pattern: Allows behavior to be added to individual objects, either statically or dynamically, without affecting the behavior of other objects from the same class.
• Facade Pattern: Provides a simplified interface to a complex subsystem.

Behavioral Patterns

Behavioral patterns are concerned with algorithms and the assignment of responsibilities between objects. They help in defining the communication between objects in a system.

• Observer Pattern: Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
• Strategy Pattern: Enables selecting an algorithm’s behavior at runtime.
• Mediator Pattern: Defines an object that encapsulates how a set of objects interact.

Asynchronous Programming

Asynchronous programming is a form of programming that allows a unit of work to run separately from the primary application thread. This approach is essential in JavaScript due to its single-threaded nature, allowing for non-blocking operations.

• Promise: An object representing the eventual completion or failure of an asynchronous operation.
• Async/Await: Syntactic sugar built on promises, allowing for more readable asynchronous code.
• Callback: A function passed into another function as an argument, which is then invoked inside the outer function to complete some kind of routine or action.

Event Loop

The event loop is the mechanism that handles asynchronous callbacks in JavaScript, allowing non-blocking I/O operations. It continuously checks the call stack to see if there’s any function that needs to run.

Prototype

In JavaScript, prototypes are the mechanism by which JavaScript objects inherit features from one another. Every object in JavaScript has a prototype, and it is through this prototype that objects can share methods and properties.

Module

A module is a piece of code that is encapsulated and can be reused across different parts of an application. Modules help in maintaining a clean namespace and organizing code into manageable sections.

MV* Patterns

MV* patterns are architectural patterns used to separate concerns in applications, particularly in the context of user interfaces.

• MVC (Model-View-Controller): Separates an application into three interconnected components.
• MVP (Model-View-Presenter): Similar to MVC, but the presenter assumes the functionality of the “middle-man.”
• MVVM (Model-View-ViewModel): A pattern that facilitates a separation of development of the graphical user interface from business logic or back-end logic.

Currying

Currying is a technique of evaluating a function with multiple arguments, transforming it into a sequence of functions each with a single argument.

Memoization

Memoization is an optimization technique used primarily to speed up computer programs by storing the results of expensive function calls and returning the cached result when the same inputs occur again.

Partial Application

Partial application refers to the process of fixing a number of arguments to a function, producing another function of smaller arity.

Functional Composition

Functional composition is the process of combining two or more functions to produce a new function.

Pure Function

A pure function is a function where the return value is determined only by its input values, without observable side effects.

Immutability

Immutability refers to the inability to change an object once it has been created. In JavaScript, this is often achieved through the use of const declarations and libraries like Immutable.js.

Anti-Pattern

An anti-pattern is a common response to a recurring problem that is usually ineffective and risks being highly counterproductive.

Refactoring

Refactoring is the process of restructuring existing computer code without changing its external behavior, improving its readability and reducing its complexity.

Dependency Injection

Dependency injection is a technique in which an object receives other objects that it depends on, called dependencies. This is a form of inversion of control.

Mocking

Mocking is the practice of creating objects that simulate the behavior of real objects. This is often used in testing to isolate the behavior of the code being tested.

Continuous Integration

Continuous integration is the practice of merging all developer working copies to a shared mainline several times a day, allowing for early detection of integration bugs.

Garbage Collection

Garbage collection is the process of automatically freeing memory by deleting objects that are no longer reachable in the program.

YAGNI Principle

YAGNI stands for “You Aren’t Gonna Need It.” It is a principle of extreme programming that states a programmer should not add functionality until it is necessary.

Microservices

Microservices are a software development technique—a variant of the service-oriented architecture (SOA) architectural style that structures an application as a collection of loosely coupled services.

Serverless Architecture

Serverless architecture is a cloud-computing execution model where the cloud provider dynamically manages the allocation and provisioning of servers.

Reactive Programming

Reactive programming is a programming paradigm oriented around data flows and the propagation of change, making it easier to express dynamic behavior.

TypeScript

TypeScript is a strict syntactical superset of JavaScript that adds optional static typing to the language.

ECMAScript

ECMAScript is a standard for scripting languages, including JavaScript. It is maintained by ECMA International.

Symbols

Symbols are a new primitive type introduced in ECMAScript 6, used to create unique identifiers for object properties.

Iterators

Iterators are objects that enable a programmer to traverse a container, particularly lists.

Observables

Observables are a part of the RxJS library, used to handle asynchronous data streams in JavaScript.

Linter

A linter is a tool that analyzes source code to flag programming errors, bugs, stylistic errors, and suspicious constructs.

Static Analysis

Static analysis is the analysis of computer software that is performed without actually executing programs, in contrast with dynamic analysis, which is performed on programs during execution.

Chrome DevTools

Chrome DevTools is a set of web developer tools built directly into the Google Chrome browser, used for debugging and optimizing web applications.

Node.js Profiler

Node.js Profiler is a tool used to analyze the performance of Node.js applications, identifying bottlenecks and optimizing performance.

Jest

Jest is a delightful JavaScript testing framework with a focus on simplicity.

Mocha

Mocha is a feature-rich JavaScript test framework running on Node.js and in the browser, making asynchronous testing simple.

Jasmine

Jasmine is a behavior-driven development framework for testing JavaScript code.

Redux

Redux is a predictable state container for JavaScript apps, often used with React.

Vuex

Vuex is a state management pattern + library for Vue.js applications.

MobX

MobX is a simple, scalable state management solution for JavaScript applications.

RESTful API

A RESTful API is an application program interface that uses HTTP requests to GET, PUT, POST, and DELETE data.

Single Page Application (SPA)

A single-page application is a web application or website that interacts with the user by dynamically rewriting the current page, rather than loading entire new pages from the server.

Node.js

Node.js is an open-source, cross-platform JavaScript runtime environment that executes JavaScript code outside a web browser.

Angular

Angular is a platform for building mobile and desktop web applications.

React

React is a JavaScript library for building user interfaces.

Vue.js

Vue.js is a progressive JavaScript framework for building user interfaces.

Quiz Time!