-
Notifications
You must be signed in to change notification settings - Fork 81
Glossary
- OOP - Object-oriented Design
- DOD - Data-Oriented Design
- TDD - Test-Driven Design
- RAII - Resource Acquisition Is Initialization
- RTTI - Run time type information
- AOS - Array of structures
- SOA - Structure of arrays
Evolution of the code through iterative modifications, compilation, quick testing
Modification of the code aimed to get better performance by using different algorithms. In other languages or in some code editors means contextual renaming through smart search & replace.
Type inference ->
The capability of the compiler to infer the type of a variable by its content or its assignment
Introspection ->
The capability of getting data type information at runtime.
Same as introspection used often in languages like C#, Java or JS.
Metaprogramming ->
The capability of the software to rewrite itself by the means of the compiler.
Execution in stacked reverse order at the end of the current scope.
Scope ->
It is a block of code where the association between names and entities (variables, procedures) is defined. Scopes can be nested in many levels of depth inside the general global scope of the application. The concept is used to identify potential naming collisions.
Procedure ->
A reusable block of code that has an entry point, that accepts arguments, performs a task and has an exit point.
A procedure that after the execution returns some values. In Jai a function can return multiple values.
A function that has no side effects, and performs its task operating only on its arguments, without effecting any other data from outer scopes.
The special procedure used in OOP languages for initialization of data structures (classes) and allocation of resources (see RAII).
A special procedure in OOP languages used for deletion of data structures (classes) and deallocation or release of resources.
In OOP languages it is the extension of a data structure and its method, by the creation of a derived more specialized version.
In data management is meant as the extension of a data structure by aggregation/sum of different data structures. In functional languages is used to describe the composition of simple functionalities to get more complex algorithms.
In Jai it is a special data structure that holds a reduced version of the global scope with preallocated utility data pools.
Heap ->
Is the memory that the OS gives to the application to store the dynamically allocated data.
Memory pool ->
A contiguous block of memory allocated once and used as a cache or buffer by many other smaller data structures.
Allocator ->
A specialized procedure used to allocate memory from a memory pool instead than form the heap. In Jai allocators can be associated with the execution context.
These documents were verified using Grammarly free browser plugin for Chrome. Please use some spell checker before submitting new content.
- Variables and assignments
- Language data types
- Simple user-defined data types
- Expressions and operators
- Type-casting
- Pointers
- Declarations
- Arguments / Parameters
- Return values
- Overloading / Polymorhism
- Advanced features
- Lambdas
- Arrays
- Strings
- Composition of Structs
- Metaprogramming
- Templates / Generics