## 3 Materials and Methods
### Language Concepts and Extensions
This type hierarchy is also noticeable in the class diagram of the first prototype implemented in the Java programming language shown in Figure 8. Functions, classes, and interfaces can be stored in variables, passed as arguments to methods, or be used as extensions for other classes and interfaces, allowing new forms of object-oriented programming like traits, mixins, and dynamic inheritance without relying on reflection or dynamic evaluation. When one of these types is created, a new object is added to the value stack containing the name, references to compiled function bodies (or native methods), and additional modifiers and metadata used by the virtual machine during bytecode execution. Each object inherits from the class \"Generic\", which contains overloaded methods such as \"toString\" (for converting an instance to a string) and \"hashCode\" (for returning the object's hash value). Built-in classes already have implementations for these methods, meaning users can leverage existing methods to create hash codes for more complex structures. Objects can also be instantiated as literals (a list of key-value pairs within curly braces) and used as associative arrays (maps or dictionaries). Object fields are stored in a special hash map as strings with standard dot notation (field names), but other key types can be added using index notation. This allows objects that are not bound to user-defined classes to provide the necessary hash map mechanism without sacrificing language reliability and readability. Conversely, arrays serve as heterogeneous containers for storing and iterating over multiple numerically indexed elements. Arrays implement the \"Iterable\" interface, making it easy for users to iterate through their elements [7]. This approach combines class- and prototype-based programming, allowing developers to establish class hierarchies with shared attributes and behaviours. This approach provides flexibility in defining objects, resulting in unique attributes without changing the base structure. The principles of object-oriented programming, such as abstraction, encapsulation, inheritance, and polymorphism, are supported in Stella. Encapsulation is based not only on data hiding, but also on ownership, where each instance can control the visibility of its components. Polymorphism is achieved through method overriding, while operator overloading allows the creation of new methods with modified markers and name mangling, further enriching the language's functionality [7]. Garbage collection is implemented using the mark-and-sweep algorithm. This algorithm activates after a defined memory threshold (i.e., after allocating a specific number of bytes) and consists of two main steps: marking, which, starting from the root, traverses all accessible objects and marks them as available, and sweeping, which releases all objects unmarked after the marking phase [7]. In the implemented framework for this study, most functionalities are retained, including all control structures, closures, classes, interfaces, static and instance field modifiers, and operator overloading and lambda functions. Support for variadic functions has also been added, as well as strict classes that do not allow the addition or removal of fields after constructor completion, ensuring the persistence of required fields for the native interface and greater reliability during object integrity validation. Using test-driven development for the baseline virtual machine version and auxiliary directives, most of the listed functionalities are modular and can be removed if necessary to conserve memory and improve performance. For example, when executing unary and binary operator instructions, an additional check is introduced for cases where the left operand is an object, which will lead to a search for the appropriate overloaded operator method and invocation with the right operand.