The post has been translated automatically. Original language: Russian
C++ is one of the most powerful system programming languages (personally, I've loved it since 1994). It is used in operating systems, game engines, financial systems, application programs, embedded software, and a variety of other fields.
Sekura JS is created with a different initial purpose. It doesn't try to cover as many programming scenarios as possible. On the contrary, the language intentionally remains compact in order to maintain a predictable relationship between the source code, memory, machine instructions, and subsequent formal verification.
Therefore, it makes sense to compare Sekura JS and C++ not by the number of features, but by what tasks were set when designing these languages.
Different goals
C++ has evolved as a universal language that allows combining low-level management with high-level tools for building large programs.
Classes, inheritance, templates, operator overloading, exceptions, automatic lifetime management of objects, and many other mechanisms are available to the developer. Thanks to this, it is possible to build very different systems in C++ without changing the language.
Sekura JS goes in the opposite direction. Its task is to provide a small and fairly rigorous set of tools for system and application code in the Sekura environment.
The limitation here is a conscious architectural decision.
Why fewer features are sometimes useful
Each additional language feature increases the number of options that the compiler must consider.
For example, an expression in C++ may include overloaded operations, type conversions, constructor calls, working with objects, and other actions that are not always obvious from a single line of source code.
This is not a problem for regular development. Such features allow you to create convenient libraries and complex abstractions.
But if the task is to trace the path from the original expression to a specific machine behavior, the complexity of the language becomes an additional factor.
Sekura JS therefore tries to keep a more direct model.
Explicit memory work
Sekura JS refers to system languages and does not hide memory from the developer.
It has pointers, arrays, structures, and integer types of various sizes. Addresses and data placement are part of the programming model, while working with memory remains explicitly visible in the code.
C++ also allows for full memory control. But on top of the low-level tools, it provides a much richer object model and mechanisms for managing the lifetime of objects.
This gives the developer more options for organizing the program, but at the same time increases the complexity of analyzing its behavior.
In Sekura JS, the choice is intentionally narrower.
A simple computational model
Sekura JS is closely related to the Memora8 32-bit architecture.
The language supports signed and unsigned integer types of 8, 16, and 32 bits, but calculations are based on a common 32-bit machine model.
This simplifies the relationship between the value in the program and the behavior of the processor.
C++ must run on multiple platforms. Therefore, the language standard leaves a certain freedom of implementation, and the properties of the machine representation depend on the specific architecture and compiler.
This is a natural advantage for a universal language. For Sekura JS, another priority is to reduce the distance between the language and the machine model.
The compiler as part of the proof chain
In typical C++ development, the main result of compilation is a working program or library.
After that, testing, static analysis, debugging, and other quality control tools are applied. Formal methods can also be used if necessary, but they are not an obligatory part of the architecture of the language itself.
In Sekura JS, the possibility of formal verification is taken into account directly in the device of the entire system.
The source program is compiled into a SOBJ machine object. This object can then be checked via SJV against a given formal requirement and Memora8 command model.
Thus, it is not the abstract source text that is being checked, but the machine code that the compiler actually created.
Why does this affect the language structure?
If the ultimate goal is to verify the machine result, it is important to reduce the number of hidden transformations.
The more implicit behavior a language allows, the more difficult it is to build an accurate compilation and execution model.
Therefore, Sekura JS tries to use a simple model system, explicit memory, and a predictable modular model.
This does not mean that complex language features are bad. They're just solving another problem.
C++ allows the developer to build rich abstractions. Sekura JS tries to make the path from the source code to the machine state as clear as possible.
The modular model
In Sekura JS, one source file describes one module. Profiles and explicit ways of interaction between them are defined for modules.
Compilation creates separate artifacts: a machine object, a description of the data placement, and the interface information of the module.
This separation is convenient for formal verification. A specific machine object can be associated with a specific source module and a specific requirement.
C++ offers significantly more flexible ways to organize a program. Header files, individual translation units, templates, and a linking system allow you to build projects of almost any structure.
Here again, the difference in goals is evident: flexibility against pre-defined boundaries.
Optimization should also be verifiable.
The modern C++ compiler is capable of performing a large number of complex optimizations.
Sekura JS also supports several levels of optimization, but it is important for the project not only to get faster or more compact code. It is necessary to check that the required behavior is preserved after the transformations.
Therefore, the same formal contract can be applied to machine code created at different optimization levels.
As a result, the optimizer is not considered as a fully trusted part of the system, but as one of the stages, the result of which can be checked separately.
Where C++ is objectively stronger in terms of capabilities
C++ has decades of development, mature compilers, large standard libraries, and a huge ecosystem.
It can be used to write programs of almost any scale: from small embedded code to complex desktop applications and large server systems.
Sekura JS does not set itself such a task yet.
His area is much narrower. It is created primarily for Sekura's own hardware and software stack and the Memora8 architecture.
Therefore, comparing the number of language features in itself says little about their purpose.
Where does the meaning of Sekura JS manifest itself
The main difference becomes noticeable if you put an additional requirement before the language: the machine result should be convenient for subsequent formal verification.
Then simplicity ceases to be just a limitation.
It becomes a way to reduce the ambiguity between the source program, the compiler, the machine code, and the validating model.
Sekura JS is created with exactly this priority.
Different answers to the same question
Both C++ and Sekura JS allow you to create system programs, work with memory, and control program behavior close enough to the hardware.
But then the approaches diverge.
C++ answers the question: how can I give a developer the most powerful set of tools for creating programs of different classes?
Sekura JS answers another question.: what should be the system language if the predictability of compilation and the possibility of formal verification of the machine result are part of the system requirements?
Therefore, reducing the number of features in Sekura JS is not an attempt to compete with C++ in terms of language size.
This is a consequence of another goal: to build a software layer that can be sequentially included in a formally verifiable stack from the source code to the hardware platform.
C++ — один из самых мощных языков системного программирования (лично я его обожаю с 1994 года). Он используется в операционных системах, игровых движках, финансовых системах, прикладных программах, встраиваемом программном обеспечении и множестве других областей.
Sekura JS создаётся с другой исходной целью. Он не пытается охватить как можно больше сценариев программирования. Напротив, язык намеренно остаётся компактным, чтобы сохранить предсказуемую связь между исходным кодом, памятью, машинными инструкциями и последующей формальной проверкой.
Поэтому сравнивать Sekura JS и C++ имеет смысл не по количеству возможностей, а по тому, какие задачи ставились при проектировании этих языков.
Разные цели
C++ развивался как универсальный язык, позволяющий сочетать низкоуровневое управление с высокоуровневыми средствами построения больших программ.
Разработчику доступны классы, наследование, шаблоны, перегрузка операторов, исключения, автоматическое управление временем жизни объектов и множество других механизмов. Благодаря этому на C++ можно строить очень разные системы, не меняя язык.
Sekura JS идёт в противоположную сторону. Его задача — дать небольшой и достаточно строгий набор средств для системного и прикладного кода в среде Sekura.
Ограниченность здесь является сознательным архитектурным решением.
Почему меньше возможностей иногда полезно
Каждая дополнительная возможность языка увеличивает число вариантов, которые должен учитывать компилятор.
Например, выражение в C++ может включать перегруженные операции, преобразования типов, вызовы конструкторов, работу с объектами и другие действия, которые не всегда очевидны из одной строки исходного кода.
Для обычной разработки это не проблема. Такие возможности позволяют создавать удобные библиотеки и сложные абстракции.
Но если задача состоит в том, чтобы проследить путь от исходного выражения до конкретного машинного поведения, сложность языка становится дополнительным фактором.
Sekura JS поэтому старается сохранять более прямую модель.
Явная работа с памятью
Sekura JS относится к системным языкам и не скрывает память от разработчика.
В нём есть указатели, массивы, структуры и целочисленные типы разных размеров. Адреса и размещение данных являются частью программной модели, а работа с памятью остаётся явно видимой в коде.
C++ также позволяет полностью контролировать память. Но поверх низкоуровневых средств он предоставляет гораздо более богатую объектную модель и механизмы управления временем жизни объектов.
Это даёт разработчику больше вариантов организации программы, но одновременно увеличивает сложность анализа её поведения.
В Sekura JS выбор намеренно уже.
Простая вычислительная модель
Sekura JS тесно связан с 32-разрядной архитектурой Memora8.
Язык поддерживает знаковые и беззнаковые целочисленные типы размером 8, 16 и 32 бита, но вычисления строятся вокруг общей 32-разрядной машинной модели.
Это упрощает связь между значением в программе и поведением процессора.
C++ должен работать на множестве платформ. Поэтому стандарт языка оставляет определённую свободу реализации, а свойства машинного представления зависят от конкретной архитектуры и компилятора.
Для универсального языка это естественное преимущество. Для Sekura JS приоритетом является другая задача — уменьшить расстояние между языковой и машинной моделью.
Компилятор как часть доказательной цепочки
В обычной разработке на C++ основной результат компиляции — рабочая программа или библиотека.
После этого применяются тестирование, статический анализ, отладка и другие средства контроля качества. При необходимости можно использовать и формальные методы, но они не являются обязательной частью архитектуры самого языка.
В Sekura JS возможность формальной проверки учитывается непосредственно в устройстве всей системы.
Исходная программа компилируется в машинный объект SOBJ. Затем этот объект можно проверить через SJV относительно заданного формального требования и модели команд Memora8.
Таким образом, проверяется не абстрактный исходный текст, а машинный код, который фактически создал компилятор.
Почему это влияет на устройство языка
Если конечной целью является проверка машинного результата, важно уменьшать количество скрытых преобразований.
Чем больше неявного поведения допускает язык, тем сложнее построить точную модель компиляции и исполнения.
Поэтому Sekura JS старается использовать простую типовую систему, явную память и предсказуемую модульную модель.
Это не означает, что сложные языковые возможности плохи. Они просто решают другую задачу.
C++ позволяет разработчику строить богатые абстракции. Sekura JS старается сделать путь от исходного кода до состояния машины максимально понятным.
Модульная модель
В Sekura JS один исходный файл описывает один модуль. Для модулей определяются профили и явные способы взаимодействия между ними.
Компиляция создаёт отдельные артефакты: машинный объект, описание размещения данных и интерфейсные сведения модуля.
Такое разделение удобно для формальной проверки. Конкретный машинный объект можно связать с конкретным исходным модулем и конкретным требованием.
C++ предлагает значительно более гибкие способы организации программы. Заголовочные файлы, отдельные единицы трансляции, шаблоны и система связывания позволяют строить проекты практически любой структуры.
Здесь снова проявляется разница целей: гибкость против заранее определённых границ.
Оптимизация тоже должна быть проверяемой
Современный компилятор C++ способен выполнять большое количество сложных оптимизаций.
Sekura JS также поддерживает несколько уровней оптимизации, но для проекта важно не только получить более быстрый или компактный код. Необходимо проверять, что после преобразований сохраняется требуемое поведение.
Поэтому один и тот же формальный контракт может применяться к машинному коду, созданному при разных уровнях оптимизации.
В результате оптимизатор рассматривается не как полностью доверенная часть системы, а как один из этапов, результат которого можно проверить отдельно.
Где C++ объективно сильнее по возможностям
C++ имеет десятилетия развития, зрелые компиляторы, большие стандартные библиотеки и огромную экосистему.
На нём можно писать программы практически любого масштаба: от небольшого встроенного кода до сложных настольных приложений и крупных серверных систем.
Sekura JS пока не ставит перед собой такой задачи.
Его область значительно уже. Он создаётся прежде всего для собственного программно-аппаратного стека Sekura и архитектуры Memora8.
Поэтому сравнение количества возможностей языков само по себе мало что говорит об их назначении.
Где проявляется смысл Sekura JS
Главное отличие становится заметно, если поставить перед языком дополнительное требование: машинный результат должен быть удобен для последующей формальной проверки.
Тогда простота перестаёт быть только ограничением.
Она становится способом сократить количество неоднозначностей между исходной программой, компилятором, машинным кодом и проверяющей моделью.
Sekura JS создаётся именно с таким приоритетом.
Разные ответы на один вопрос
И C++, и Sekura JS позволяют создавать системные программы, работать с памятью и управлять поведением программы достаточно близко к аппаратуре.
Но дальше подходы расходятся.
C++ отвечает на вопрос: как дать разработчику как можно более мощный набор средств для создания программ разных классов?
Sekura JS отвечает на другой вопрос: каким должен быть системный язык, если предсказуемость компиляции и возможность формальной проверки машинного результата являются частью требований к системе?
Поэтому уменьшение количества возможностей в Sekura JS — не попытка конкурировать с C++ по размеру языка.
Это следствие другой цели: построить программный слой, который можно последовательно включать в формально проверяемый стек от исходного кода до аппаратной платформы.
Share
