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 along with multi-platform support for bytecode. It means the bytecode generated in Windows system can run on linux and vice versa.

Added File Datatypes:

Added 'FileReader' and 'FileWriter' for reading and writing files with great speed, safety and accuracy.

Added new type 'LiteralString':

Added 'LiteralString' which is a immutable string type storing compile time string literal values. It restricts creating copies of strings like command line arguments and literal string which eventually leads to faster code execution and memory efficiency.

Added new exit codes:

Added new exit codes ranging 7 to 11 syndicating why your interpreter exited. Learn more about exit codes.

Added File Manipulation function:

Added `14` new functions for working on file like freader(), fwriter(), fisOpen(), fisEnd() freadChar(), freadLine(), freadWhole(), fwriteChar(), fwriteString(), fcurPos(), fsetSeek(), freset(), fgetName() and fclose().

Added new keywords for CLI-Designing:

Added `41` new keywords to design/colorize your terminal's text. You can now set text background color, text color and text design (bold, italic, underline dim, strike etc.) on the terminal.

Added more new functions:

Added 'isFileReader()', 'isFileWriter()' and 'isLiteralString' to verify the type of the value. Added 'isAlphaNum()' to check if the passed character is alpha-numeric character or not. Added 'cliTextColor()' and 'cliBgColor()' to colorize text and background of terminal.

Better Documentation:

Documentations are now more expressive and detailed. Also, some typos and minor mistakes are fixed. Read the docs from here.

Changed Bitwise Operators:

Bitwise AND, Bitwise OR and Bitwise NOT were syndicated using and, or and not respectively which was quite confusing with Logical AND, Logical OR and Logical NOT. From SRON v2.3, Bitwise operators will follow the traditional way of writing bitwise operators like this ~(bitwise NOT), &(bitwise AND) and |(bitwise OR).

Changed Cmd-Line argument's type:

Changed type of command line arguments from 'String' to 'LiteralString' leading to faster extraction of command line arguments.

Cleaner Codebase:

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

Coding Convention of function changed:

Now, all in-built functions of SRON follows camelCase instead of smallcase for standardized and beautiful codes. Existing function names are also changed to camelCase.

Colorized Output:

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

Expanded Call Stack:

The interpreter now supports a call stack size of 2000, offering double the depth Python allows (996). Now, you can perform 1999-level deep recursion for complex computation.

Enhanced Error Messages:

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

Fixed incorrect line number:

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

Fixed Math Block Bug:

Fixed the bug where compiler was not throwing error when there is an invalid Mathematical expression written in Math block ( ${ } ).

Fixed sizeof function:

Fixed sizeof() function which was giving incorrect size of values.

Fixed memory leak:

Fixed memory leaks due to SIGINT, SIGTERM and other signals.

Improved Typing Convention:

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

Interpreter Stability Fix:

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

Math block syntax changed:

Now math block syntax is ${ } instead of ~{ }~. This will lead to more precise and cleaner code.

More precise argument exceptions:

More precise exception messages by in-built function explaining what argument should have been passed.

New attributes 'linux':

Added attribute 'linux' which can be used to execute a block of code only in linux operating system.

New attributes 'windows':

Added attribute 'windows' which can be used to execute a block of code only in windows operating system.

New espace sequences:

Added \r (carriage return) and \b (backspace) in both 'String' and 'Char' types.

New exit code 6:

From version 2.3, exit code 6 is returned by the SRON's interpreter in case of call stack overflow.

Open sourced 2.3:

Version 2.1, 2.2 and 2.3 are open sourced on GitHub. Visit here. Keep note that Bytecode Writer and Execution Engine of the compiler and interpreter respectively is not open-sourced.

Precise Execution Time:

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

Returning value of Main:

Now, developer can return values from Main function to the Operating system. Keep note that only 'Int' values and 'Void' can be return from Main where 'Void' will automatically considered as zero.

Removed implicit conversion from String to List:

To allow more intuitive/predicatable output, implicit conversion from String to List is removed. However, you can still convert String to List using split() function.

Signals handled:

Handled SIGINT, SIGTERM, SIGKILL, SIGSEGV, SIGABRT and SIGBREAK to counter memory leaks and ensure safety and accuracy.

New version message:

A beautiful and more informative version message is displayed when flag --version is passed in SRON's compiler.

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