📖 Glossary - FluxSharp
Comprehensive glossary of terms and concepts in FluxSharp programming.
A
Abstract Class
A class that cannot be instantiated directly and is meant to be subclassed. It may contain abstract methods that must be implemented by subclasses.
Async
Short for asynchronous. Operations that can run independently of the main program flow, allowing other code to execute while waiting.
Await
Keyword used to wait for an asynchronous operation to complete before proceeding. Used with
async
functions.
Array
An ordered collection of elements of the same type, accessed by numeric index (0-based).
Assignment
The process of giving a variable a value using the
=
operator.
B
Bounds Checking
A safety feature that verifies array indices are within valid range (0 to length-1) before access, preventing buffer overflows.
Bool / Boolean
A data type with two possible values:
true
or
false
.
Byte
A data type representing a single byte (8 bits), typically used for binary data.
Break
A statement that exits a loop or switch statement early.
C
Catch
A block in try/catch that handles exceptions when they occur.
Class
A blueprint for creating objects. Defines properties (variables) and methods (functions).
Comment
Text in code that is not executed. Single-line:
//
, Multi-line:
/ /
Compile / Compilation
The process of converting source code to machine-readable format (native code).
Compiler
The tool that converts FluxSharp code to executable programs.
Condition
A boolean expression that evaluates to true or false, used to make decisions in code.
Constructor
A special method called when creating a new instance of a class.
Continue
A statement that skips the rest of the current loop iteration and moves to the next one.
D
Double
A 64-bit floating-point data type with high precision.
Declaration
The act of introducing a variable, function, or class to the program.
E
Encapsulation
The bundling of data (properties) and methods into a class, hiding internal details.
Enum
A type that defines a set of named constants.
Exception
An error that occurs during program execution, which can be caught and handled.
Expression
A combination of variables, operators, and values that evaluates to a result.
F
Finally
A block in try/catch/finally that executes regardless of whether an exception occurred.
Float
A 32-bit floating-point data type (use
3.14f
syntax in FluxSharp).
For Loop
A loop that repeats a fixed number of times:
for (init; condition; update)
Function
A reusable block of code that performs a specific task. In FluxSharp, functions are methods within classes.
G
Generics
Programming technique allowing functions/classes to work with any data type (e.g.,
List
).
Getter
A method that returns the value of a property.
H
Hash
A fixed-size value computed from data, used for security and verification.
I
Immutable
Data that cannot be changed after creation.
Import
A statement that brings external code/libraries into the current program.
Inheritance
The ability of a class to inherit properties and methods from another class.
Instance
A specific object created from a class template.
Int
A 64-bit signed integer data type (-2^63 to 2^63-1).
Interface
A contract defining methods a class must implement, without providing implementation details.
J
(Reserved for future use)
K
Keyword
A reserved word with special meaning in the language (e.g.,
class
,
public
,
return
).
L
Literal
An actual value written directly in code (e.g.,
42
,
"hello"
,
true
).
Local Variable
A variable declared inside a method or block, with scope limited to that block.
Long
A large integer data type (similar to int but may be longer on some systems).
Loop
A control structure that repeats a block of code multiple times.
M
Main
The entry point of a FluxSharp program, the method that runs when the program starts.
Memory
The computer's storage used to hold program data and code.
Method
A function defined within a class.
Module
A file or collection of code organized by functionality.
Mutable
Data that can be changed after creation.
N
Namespace
A way to organize code and avoid naming conflicts.
New
A keyword used to create a new instance of a class.
Null
A value representing the absence of a value (though not commonly used in FluxSharp).
O
Object
An instance of a class, containing data (properties) and behavior (methods).
Operator
A symbol that performs an operation (e.g.,
+
,
-
,
,
/
).
Overloading
Defining multiple methods with the same name but different parameters.
Overriding
Redefining a method from a parent class in a child class.
P
Parameter
A variable in a function definition that receives a value when the function is called.
Polymorphism
The ability of objects to take different forms, typically through inheritance and method overriding.
Private
An access modifier making a method or property accessible only within the class.
Property
A variable associated with an object, often accessed through getter/setter methods.
Public
An access modifier making a method or property accessible from outside the class.
Q
(Reserved for future use)
R
Reference
A variable that refers to an object rather than containing its value directly.
Return
A statement that exits a function and optionally returns a value.
Runtime
The time when a program is executing (as opposed to compile time).
S
Scope
The region of code where a variable is accessible.
Setter
A method that sets the value of a property.
Static
A modifier indicating something belongs to the class itself rather than instances.
String
A data type representing text, a sequence of characters.
Struct
A value type grouping related data together (similar to class but with different behavior).
Switch
A control structure that executes different code based on different conditions.
T
Type
The category of a value (int, string, bool, etc.) that determines what operations are allowed.
Type Checking
Verification that values match their declared types, done at compile time.
Try
A block of code to attempt; if an exception occurs, control passes to catch block.
U
Uint
An unsigned 64-bit integer (0 to 2^64-1).
Ulong
An unsigned long integer.
V
Variable
A named storage location that holds a value of a specific type.
Void
A return type indicating a function/method doesn't return any value.
W
While Loop
A loop that continues as long as a condition is true:
while (condition) { }
X
(Reserved for future use)
Y
(Reserved for future use)
Z
Zero Initialization
Setting variables to zero/default values automatically.
Common Patterns & Concepts
Callback
A function passed to another function to be called later.
Closure
A function that captures variables from its surrounding scope.
Concurrency
Multiple operations happening simultaneously or in an interleaved manner.
Constructor Pattern
A way to initialize objects, optionally with parameters.
Factory Pattern
A design pattern for creating objects without specifying exact classes.
Lazy Evaluation
Delaying computation until the result is actually needed.
Memoization
Caching function results to avoid recomputation.
Observer Pattern
A pattern where objects notify others when something changes.
Recursive
A function that calls itself, with a base case to stop.
Singleton
A design pattern creating only one instance of a class.
Data Structure Glossary
Array
Ordered collection of fixed size accessed by index.
Dictionary / HashMap
Key-value pairs allowing fast lookup by key.
List / Vector
Ordered collection of variable size.
Queue
First-in-first-out (FIFO) data structure.
Set
Unordered collection of unique values.
Stack
Last-in-first-out (LIFO) data structure.
Tree
Hierarchical data structure with nodes and branches.
Advanced Concepts
Buffer Overflow
Accessing memory beyond array bounds (prevented by FluxSharp's bounds checking).
Deadlock
Situation where two processes wait for each other, creating a halt.
Memory Leak
Allocated memory not being released, wasting resources.
Race Condition
Unexpected behavior when multiple operations access shared data simultaneously.
Type Inference
Automatically determining the type of a value without explicit declaration.
Type Safety
Preventing operations on incompatible types at compile time.
FluxSharp Specific Terms
Bounds Checking
FluxSharp's automatic array bounds verification preventing buffer overflows.
FluxSharp
A modern, type-safe programming language for secure and efficient development.
FSH
The file extension for FluxSharp source files (
.fsh
).
Import System
FluxSharp's way of including external libraries and modules (C# style).
Main Class
The required entry point class containing the main() method.
Type-Safe
A language feature preventing invalid operations on data types at compile time.
Related Languages & Concepts
C
Microsoft's object-oriented language that influenced FluxSharp's design.
Rust
Systems programming language emphasizing safety and performance.
Static Typing
Requiring type declarations at compile time (as opposed to dynamic typing).
Type Inference
Determining types automatically in certain contexts.
Resources
For more detailed information on any term, consult the relevant documentation:
Beginner Terms: See
docs/02-language/SYNTAX.md
Data Types: See
docs/02-language/TYPES.md
Advanced Concepts: See
docs/03-advanced/
Patterns: See
docs/BEST_PRACTICES.md
(when available)
Last Updated: April 9, 2026 Total Terms: 100+ Difficulty Levels: Beginner, Intermediate, Advanced
Quick Reference by Category
Keywords
class
,
public
,
private
,
void
,
return
,
if
,
else
,
for
,
while
,
try
,
catch
,
async
,
await
,
new
,
break
,
continue
Data Types
int
,
uint
,
long
,
ulong
,
float
,
double
,
bool
,
string
,
byte
,
char
Operators
+
,
-
,
,
/
,
%
,
==
,
!=
,
<
,
>
,
<=
,
>=
,
&&
,
||
,
!
Control Flow
if
,
else if
,
else
,
for
,
while
,
do-while
,
switch
,
break
,
continue
,
return
This glossary is continuously updated with new terms as the language evolves.