 Advanced Computing Environment | brix-os project page |
|---|
Introduction
Why a new language?
Go read the about page so you have a basic idea of the operating system.
BRiX will not use hardware to isolate processes and all threads execute without user privileges. The user interface component allows users to login, renders an interface for them to access their data and handles job scheduling all without threads knowing what user owns them. The contact service provides widgets that may be added to the user interface to display a list of contacts or information about a specific contact. When one of these widgets is viewed the UI passes the user name to the contact service and it renders the widget without the container code ever seeing any contact details. Services may provide restrictedinterfaces that query the current user from the UI and allow code to query data but the code will not compile without authorization from the user.
This not only requires a language with compile and runtime checks but also one that prompts the user before compiling code that makes use of restricted features. The user should be able to download, compile and execute code from untrusted sources without worry of it comprimising their system or accessing their data. Users may place their trust in specific code repositories and allow all packages to be compiled without prompting to use restricted features, while the paranoid can manually approve each restricted package. The IDE can be used to jump to each restricted section of code which should be well commented.
The language also keeps track of each binary it produces and loads them into memory when needed. Code must have references to access files which prevents binaries from being tampered with since Tetra doesn't make them available to anyone. It can also track APIs across modules and detect breakage before updated modules are placed in the binary pool. Tight integration between the IDE, repository, package manager, compiler and operating system provide a cleaner experience and increased security.
Goals
Tetra must be designed to satisfy a wide range of people and attempts to do so by incorporating the best
features found in modern languages. Other languages can compile to Tetra code and interpreted languages will
work fine as long as they don't generate any executable code. The problem is that these languages are designed
to work with files and lack the features needed to properly run in a BRiX environment. The best way to use them
is with a libOS environment for an existing operating system. Therefore, Tetra is about the only option to
produce code that integrates well with the BRiX environment and must be able to replace the others.
- Clean syntax ...
- Low-level hardware access for system programmers and high-level abstractions to reduce programming time and produce better code.
- Implicit type declarations and dynamic typing allow for rapid prototyping, and static typing can later be used to optimize runtime speed and increase stability.
- Modules provide namespaces to isolate code and act as packages sent to or from repositories.
- Automatic memory management reduces errors and frees the programmer from manually managing memory. Memory is reclaimed with a system-wide garbage collector.
- Capabilities provide fine-grained protection for all resources.
- Domain-specific extensions allow mini-languages to integrate seamlessly with Tetra. The assembler and device interface language are two such extensions providing seamless access to assembler code and declaring high-level interfaces for devices.
- An integrated development environment will provide easy access to all code in the system and
automatically format code to the user's preferences. It will be tightly coupled to the compiler allowing
incremental feedback as code is typed. The editor will be able to markup expressions exactly how the
compiler sees them and display errors in realtime. The markup provided by the IDE is important because it
shows operator precedence problems that would otherwise not produce warnings, it can highlight dynamic
types, it can highlight destructive functions that modify reference parameters, and various other
visual cues that help produce safer code.
The IDE will have a REPL (Read Eval Print Loop) to experiment with expressions and run tests on the interfaces defined in the current module.
Related Links
Copyright © 1995-2017 Brand Huntsman