S.R.O.N.
{Logs & Updates}

SRON go through updates and fixes everytime, someone reports some bugs and vulnerabilities.

Sron-Logo

Latest version 2.3:

SRON for Linux:

SRON is now officially available for Linux platforms bringing its speed and efficiency beyond Windows.

Interpreter Stability Fix:

Resolved a critical bug where the interpreter terminated abruptly (without error output) when the call stack overflowed.

Expanded Call Stack:

The interpreter now supports a call stack size of 2000, offering double the depth Python allows (996).

Precise Execution Time:

get_exec_time() now returns results in milliseconds instead of seconds, enabling more precise performance measurements.

Improved Typing Convention:

Interpreter typing conventions have been standardized for better consistency, readability, and understanding.

Accurate Compiler Diagnostics:

Fixed an issue where the compiler displayed incorrect line numbers in error messages.

Enhanced Error Messages:

All exceptions and error messages are now cleaner, clearer, and more informative.

Colorized Output:

Compiler and interpreter messages now include colored text for improved visibility — from errors and exceptions to general information.

Cleaner Codebase:

Internal code structure has been reorganized for higher readability, maintainability, and extensibility.

Sron-Logo

Version 2.2:

Added 'ArgumentException':

If you detect that the arguments passed to a function is incorrect, then you can display 'ArgumentException' (denotes that the passed arguments are of wrong type) into the terminal.

Added 'OBUFFER' keyword:

OBUFFER keyword can be used to put values in a buffer which can be later displayed on terminal/console at once. It can be used to achieve greater optimization levels. Know more from here.

Added 'sron_cmd()' function:

To get the information and perform operations on internal components, sron_cmd() function can be used. Know more here.

Better Semantic Analysis:

SRON version 2.2's compiler detects syntax errors and displays accurate & easy error messages for great developer experience.

Caching of bytecode:

To achieve faster user defined function calls, the bytecode is now cached and once a function is loaded, it will not be loaded again.

Compile-time optimization:

SRON's compiler removes dead code and unimportant tokens to generate highly optimized bytecode. Also, it indexes variables, inbuilt function etc. to reduce memory and power usage during  runtime and increases speed to next level.

Deep Optimized GC:

The speed and memory usage of Garbage Collector is taken to another level with deep optimization and better efficiency. SRON's Garbage Collector manages memory automatically and avoid memory leaks, making SRON - a safe and stable language.

Developed using Clang:

For faster, efficient and optimized compiler and interpreter, the whole SRON's codebase is shifted to Clang with C++23. All previous versions( < v2.2) were developed using GCC with C++11.

Faster 'console' attribute':

'console' attribute is highly optimized for tight loops with insane speed specially when used with 'OBUFFER'.

Faster function calls:

Now, the in-built function calls are faster and user-defined function are also optimized with a whole new BytecodeReader.

Faster variable access:

Now, accessing variables is faster and efficient along with compile+run time checks.

Fixed invalid exit code:

In version 2.1 and before, after the successful or unsuccessful execution, the exit code was always 0. Now, certain exit codes will be returned for error/exception detection. Read from here

Fixed Renaming vulnerability:

SRON version 2.2 ensures that if the bytecode file is renamed then the interpreter will detect it and throw the exception.

Fixed 'rotate' bug:

"Variable not found" error is fixed for variables in 'rotate' attribute.

Fixed Segfault:

In version 2.1, if an element of a list is stored in a variable and then the list is cleared using 'clear()' function and then if you try to access that variable, the interpreter gets halted by Segmentation Fault. This Bug is fixed by optimization & correction of Memory model & Garbage Collector.

Fixed Variable Analysis:

In version 2.1, if a function is being declared within sub-scope and then it is used outside that scope, the runtime error is triggered instead of compile time error. This problem is fixed now.

Interpreter Optimization:

SRON interpreter's is optimized greatly with 48% enhancement in speed and Power usage decreased by 25%.

Mutating code support:

The bytecode is being cached by the interpreter so SRON now doesn't support mutating code.

Open source 2.1:

SRON v2.1 is now completely open sourced. Check it out from here.

Optimized print & println:

Speed of 'print()' and 'println()' is improved even long print statements even in tight loops.

Removed 'free' attribute:

As everything related to memory is managed by Garbage Collector so the 'free' attribute is removed which opened new gates for better optimizations.

Removed execution time message:

After complete execution of the code, the interpreter use to print the total time taken to execute the code. That is removed and now to get the execution time, you should call 'get_exec_code()' function which returns the time taken in value of type 'Double'.

Safe and secure bytecode:

Before version 2.2, the bytecode generated by the compiler can be modified by renaming the bytecode file and its modification cannot be detected but now SRON's interpreter will verify the integrity of the bytecode before executing its code.

Strict case-sensitivity:

Function calls and their declaration is now strictly case sensitive. If not followed, you will face both compile and runtime errors.

Mobirise Website Builder

Version 2.1:

Added Garbage Collector:

Many contributors reported that they found memory leaks and related bugs in SRON. SRON's Garbage Collector manages memory automatically and avoid any type of memory leaks making SRON, a safe and stable language.

Added new datatype 'Collective':

'Collective', a abstracted-base type of 'String' and 'List'. You cannot directly create 'Collective' variables but it works in abstracted format behind 'String' and 'List' type values.

Added Strict argument passing:

SRON provides argument checks for runtime using Int_s, Double_s, Char_s, String_s, Bool_s and List_s. These keywords checks the type of arguments passed to a function and if the passed argument is not of expected type, then throws the exception.

Added Static typing:

SRON is now a statically + dynamically typed programming language. For static typing use Int, Double, Char, Bool, String and List.

Better Semantic Analysis:

SRON version 2.1's compiler is a 3-phased vector-based compiler. It checks the source code, detects syntax errors and displays accurate error messages for great developer experience.

Bitwise operators added:

Added bitwise operators to optimize your code on a whole another level. Introducing xor, lsft(left shift), rsft(right shift), and(bitwise and) , or(bitwise or) and not(bitwise not).

Compiler optimization:

SRON's compiler is highly optimized for big codebases. Also, the memory usage of compiler is reduced by 75%.

Compile-time optimization:

SRON's compiler removes dead code and unimportant tokens to generate highly optimized bytecode. Also, it hashes variables, inbuilt function etc. to reduce memory and power usage during  runtime and increase the speed massively.

Console attribute:

For faster, efficient and optimized printing of values in command line, use 'console' attribute which will not create argument list like 'print' functions and linearly prints the values in console removing extra overheads and improved performance. Constant values written in 'console' attribute is written as it to reduce memory usage.

Fixed 54+ bugs:

SRON version 1.5 has various memory leaks, bugs and vulnerabilities. SRON version 2.1 fixed almost 54+ bugs and vulnerabilities all of them making it more stable language.

Foreach loop added:

SRON version 2.1 adds foreach loop for faster value access with easy syntax.

Interpreter Optimization:

SRON interpreter's memory usage is decreased by 72%. Power usage decreased by 50%. Speed is increased by 48% for multiple scenarios.

Removed 'comment' attribute:

Versions before 2.1 have 'comment' attribute to make comments but in this new version, 'comment' attribute is removed.

Make comments using '@':

Now make comments using '@'. You can even make multiline comments (only outside the function scope) using '@' if there is '{' and you want to make it comment line. '@' will move the compiler source code read's seek to the next line.

Math Block Syntax changed (~{ }~):

SRON's Mathematical block are now declared using '~{' instead of using '~' only.

New assignment operator (+=, -= ...):

Assignment operators are fast and quick, also it do not change the underlying type of the variable. SRON's version 2.1 provides +=, -=, *=, /=, %= and ^= assignment operators.

Numeric attributes removed:

In SRON version 1.5 and before, we use numeric attributes but the new version 2.1 removed this to make writing code more faster and readable.

Open source:

SRON is now an open source programming language. Go here and read.

Precedence changed:

Precedence of '<=' , '>=' , '>' , '<'  '==' , '!=' changed. Now, <=, >=, <, > will have higher precedence than == and !=.

Returning particular value types:

The new SRON version 2.1 provides you the feature to set the return type of the function using 'type' attribute.

Rotate attribute:

To swap values of two variables efficiently or shifting many values, then use 'rotate' attribute which will optimize the process during compile time resulting in faster performance.

Safe and secure bytecode:

Before version 2.1, the bytecode generated by the compiler is in text format which makes it easier to decompile and change. SRON's version 2.1 introduces a whole new bytecode format which is in binary so making changes and decompiling it is near to impossible.

Strict compare operator (===):

To check if the type of both values is same and so their content, then use this operator. It compares the values after their types is same.

© Copyright  Saksham Joshi - All Rights Reserved