Skip to content

Commit a9534f8

Browse files
tobiutobiu
committed
learn/Glossary.md #6898 
1 parent 1569477 commit a9534f8

2 files changed

Lines changed: 259 additions & 1 deletion

File tree

‎learn/Glossary.md‎

Lines changed: 257 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,257 @@
1+
2+
This glossary provides definitions for key terms and concepts used throughout the Neo.mjs documentation. Understanding
3+
these terms is essential for grasping the framework's unique architecture and capabilities.
4+
5+
## A
6+
7+
### Actor Model
8+
9+
A programming paradigm where "actors" are the universal primitives of concurrent computation. In Neo.mjs, this concept
10+
is applied to web workers, where each worker acts as an independent actor communicating via messages, enabling robust
11+
multi-threaded applications.
12+
13+
### App Worker
14+
15+
The primary Web Worker in Neo.mjs where the majority of your application's logic, components, and business code reside.
16+
It operates off the main thread, ensuring the UI remains responsive.
17+
18+
### Application Worker being the Main Actor Paradigm
19+
20+
A core architectural principle in Neo.mjs where the App Worker is the central hub for application logic and state, rather
21+
than the main browser thread. This ensures UI responsiveness and efficient resource utilization.
22+
23+
## C
24+
25+
### Canvas Worker
26+
27+
A specialized Web Worker in Neo.mjs that can take ownership of an `OffscreenCanvas` DOM node. This allows computationally
28+
intensive graphics rendering to occur entirely off the main thread, preventing UI blocking.
29+
30+
### Class Config System
31+
32+
Neo.mjs's unified, declarative system for defining and managing properties for all classes (components, models,
33+
controllers, etc.) through a `static config` object. It provides consistency, reactivity, and powerful lifecycle hooks.
34+
35+
### Component Lifecycle
36+
37+
The series of well-defined stages an Neo.mjs class instance goes through, from its creation and initialization to its
38+
destruction. The framework provides hooks (e.g., `construct`, `initAsync`, `destroy`) to tap into these stages.
39+
40+
### Component Library
41+
42+
A comprehensive collection of pre-built, production-ready UI components provided by Neo.mjs, designed to be highly
43+
configurable and performant within the OMT architecture.
44+
45+
### Cross-worker communication
46+
47+
The mechanism by which different Web Workers (e.g., App Worker, Main Thread, VDom Worker) exchange messages and data.
48+
Neo.mjs provides an efficient RPC layer for this.
49+
50+
## D
51+
52+
### Data Store
53+
54+
A Neo.mjs class (`Neo.data.Store`) that manages collections of data records. It can be configured declaratively and is
55+
often used to provide data to UI components like grids.
56+
57+
### Data Worker
58+
59+
A specialized Web Worker in Neo.mjs primarily responsible for handling backend communication (e.g., AJAX calls, WebSocket
60+
messages) and performing data transformations off the main thread.
61+
62+
### Declarative component trees
63+
64+
A method of building user interfaces in Neo.mjs by defining the desired structure and properties of components using
65+
declarative configurations (often JSON-like objects) rather than imperative step-by-step instructions.
66+
67+
### Delta-updates
68+
69+
The minimal changes calculated by the VDom Worker (by comparing new and old Virtual DOM trees) that need to be applied
70+
to the actual browser DOM. Sending only deltas optimizes UI updates.
71+
72+
### dist/development
73+
74+
One of Neo.mjs's four environments, representing a traditional "dev mode" with bundled but unminified code and source
75+
maps. Used for debugging production-specific issues or by developers preferring TypeScript.
76+
77+
### dist/esm
78+
79+
One of Neo.mjs's four environments, designed for modern deployment. It preserves the native ES Module structure,
80+
allowing browsers to load individual module files efficiently via HTTP/2 or HTTP/3.
81+
82+
### dist/production
83+
84+
One of Neo.mjs's four environments, providing highly optimized, minified, and thread-specific bundles (using Webpack)
85+
for maximum compatibility and smallest payload, ideal for broad deployment.
86+
87+
## L
88+
89+
### Lazy-loaded Forms
90+
91+
A feature in Neo.mjs forms where form fields or sections are only loaded (but not necessarily mounted to the DOM) when
92+
they are actually needed, optimizing initial load times for complex forms.
93+
94+
### Lifecycle hooks
95+
96+
Methods provided by the Neo.mjs framework that allow developers to execute custom logic at specific points during a
97+
class instance's lifecycle (e.g., `beforeSet`, `afterSet`, `initAsync`, `destroy`).
98+
99+
## M
100+
101+
### Main Thread
102+
103+
The single browser thread responsible for rendering the user interface (DOM), handling user interactions, and executing
104+
most traditional JavaScript. Neo.mjs aims to keep this thread as idle as possible for maximum responsiveness.
105+
106+
### Main-Thread Addons
107+
108+
Libraries or functionalities that require direct access to the browser's Main Thread (e.g., for DOM manipulation or
109+
specific browser APIs). Neo.mjs provides mechanisms to integrate these while maintaining OMT benefits.
110+
111+
### MicroLoader
112+
113+
A lightweight JavaScript file that is the first part of the Neo.mjs framework loaded by the browser. It's responsible
114+
for fetching the application's configuration and dynamically importing the main thread part of the framework.
115+
116+
### Mixins
117+
118+
A mechanism in JavaScript (and utilized by Neo.mjs) to compose classes by injecting properties and methods from other
119+
classes, promoting code reuse without traditional inheritance.
120+
121+
### Multi-threaded architecture
122+
123+
The fundamental design of Neo.mjs that leverages Web Workers to distribute application logic and processing across
124+
multiple CPU cores, ensuring a highly responsive user interface.
125+
126+
### Multi-Window Applications
127+
128+
Neo.mjs's native capability to run a single application across multiple browser windows, allowing seamless data and
129+
state sharing, and enabling complex multi-screen user experiences.
130+
131+
## N
132+
133+
### Native ES modules
134+
135+
Modern JavaScript modules that can be directly loaded and executed by browsers without requiring a build step
136+
(transpilation or bundling). Neo.mjs heavily relies on these for its zero-build development.
137+
138+
### ntype
139+
140+
A string alias used in Neo.mjs to declaratively specify the type of a component or class within a configuration object
141+
(e.g., `ntype: 'button'`, `ntype: 'container'`).
142+
143+
## O
144+
145+
### Observable
146+
147+
A pattern used in state management where data changes can be "observed" or subscribed to, allowing components to react
148+
automatically to updates. Neo.mjs's state providers often utilize this.
149+
150+
### Off-Main-Thread (OMT)
151+
152+
The core architectural principle of Neo.mjs, where the majority of the application's logic and processing runs in Web
153+
Workers, separate from the browser's main thread, to ensure UI responsiveness.
154+
155+
## P
156+
157+
### Plugins
158+
159+
Extensible modules that can be added to Neo.mjs components to enhance their functionality without modifying their core
160+
code, promoting modularity and reusability.
161+
162+
### Property lifecycle hooks
163+
164+
Specific methods (e.g., `beforeGet`, `beforeSet`, `afterSet`) that are automatically invoked when a Neo.mjs config
165+
property is accessed or modified, allowing for validation, transformation, or reactive side effects.
166+
167+
## R
168+
169+
### Reactive Config
170+
171+
A feature of the Neo.mjs Class Config System where changes to config properties automatically trigger updates in the UI
172+
or other dependent parts of the application.
173+
174+
### Remote Method Access (RMA)
175+
176+
Neo.mjs's mechanism for seamlessly calling methods on objects that reside in different Web Workers (or even backend
177+
services), abstracting away the complexities of cross-worker communication.
178+
179+
### RPC Layer
180+
181+
Remote Procedure Call layer. In Neo.mjs, this refers to the framework's built-in system for enabling methods to be called
182+
on objects residing in different execution contexts (e.g., between workers, or to a backend) as if they were local.
183+
184+
### Routing
185+
186+
The process of mapping URL hash patterns to specific application states or views. Neo.mjs supports declarative routing
187+
within its class config system.
188+
189+
## S
190+
191+
### Service Worker
192+
193+
A type of Web Worker that acts as a programmable proxy between the browser and the network. In Neo.mjs, it's used for
194+
predictive caching of assets and enabling offline capabilities.
195+
196+
### Shared Web Workers
197+
198+
A type of Web Worker that can be accessed by multiple browsing contexts (e.g., multiple browser tabs or windows) from
199+
the same origin. Neo.mjs leverages these for its multi-window application capabilities.
200+
201+
### Source maps
202+
203+
Files that map transpiled or minified code back to its original source code, aiding debugging in environments where the
204+
deployed code is not directly readable.
205+
206+
### State Management
207+
208+
The process of managing and synchronizing the data (state) of an application. Neo.mjs provides elegant features for this,
209+
including state providers and observable patterns.
210+
211+
### State Provider
212+
213+
A Neo.mjs class responsible for managing and providing shared, bindable data (state) across different parts of an
214+
application. Forms can include their own state providers.
215+
216+
## T
217+
218+
### Task Worker
219+
A specialized Web Worker in Neo.mjs that can be used to offload specific, computationally expensive tasks that don't fit
220+
into the other worker categories, ensuring the main thread remains free.
221+
222+
## U
223+
224+
### Unified Config System
225+
226+
See Class Config System.
227+
228+
## V
229+
230+
### Virtual DOM (VDom)
231+
232+
An in-memory representation of the actual browser DOM. Neo.mjs uses a lightweight, JSON-like VDom to describe UI
233+
structures, enabling efficient delta calculations and updates to the real DOM.
234+
235+
### VDom Worker
236+
237+
A specialized Web Worker in Neo.mjs responsible for processing Virtual DOM trees, calculating delta updates (diffing)
238+
between the current and new UI states, and sending these minimal changes to the Main Thread for rendering.
239+
240+
## W
241+
242+
### Web Workers
243+
244+
A browser technology that allows scripts to run in background threads, separate from the main execution thread. Neo.mjs
245+
extensively uses various types of Web Workers to achieve its Off-Main-Thread architecture.
246+
247+
### Webpack
248+
249+
A popular open-source JavaScript module bundler. Neo.mjs uses Webpack in its `dist/production` and `dist/development`
250+
environments to create optimized bundles for deployment.
251+
252+
## Z
253+
254+
### Zero-Build Development
255+
256+
A core feature of Neo.mjs that allows developers to run and debug applications directly in the browser using native ES
257+
modules, without requiring a compilation or bundling step during development.

‎learn/tree.json‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -48,5 +48,6 @@
4848
{"name": "Overriding Methods", "parentId": "JavaScript", "id": "javascript.Overrides"},
4949
{"name": "Other JavaScript Class Features", "parentId": "JavaScript", "id": "javascript.ClassFeatures"},
5050
{"name": "Super", "parentId": "JavaScript", "id": "javascript.Super"},
51-
{"name": "New Node", "parentId": "JavaScript", "id": "javascript.NewNode"}
51+
{"name": "New Node", "parentId": "JavaScript", "id": "javascript.NewNode"},
52+
{"name": "Glossary", "parentId": null, "id": "Glossary"}
5253
]}

0 commit comments

Comments
 (0)