Forem: Ethan Onstott

StormScript: Year in Review

Ethan Onstott — Sun, 21 Apr 2019 02:39:11 +0000

It has been over a year since I created the StormScript programming language. Since then, I have not only fixed many issues with the language, but I have also introduced many new features to the language. In this post, I will go over them.

Syntax Changes

Keyword Changes

Initially, the keyword out was used to print. This was a fine keyword, but I feel that print would make more since in this setting.

do {
    out "Hello, World!";
}end;

was changed to

do {
    printl "Hello, World";
}end;

This change also allowed there to be 2 forms of print, print and printl. printl adds a newline to the end of the value that is printed.

@args was originally used to add function arguments. The problem with this is that it required the arguments to be on a separate line than the function.

The removal of `end;`

Originally, StormScript used two ways to end a code block. Many people commented on this in my first post. Not only would users have to put curly braces to end a scope, they would also have to put the end; keyword. This proved to be redundant and was removed.

Code was changed from

do {
    printl "Hello, World!";
}end;

do {
    printl "Hello, World!";
}

This not only makes long files look nicer, but it also saves time.

Static to Dynamic Type

StormScript was planned to be statically typed, but this changed after I realized how much this kills the readability of the language. As a result,

do {
    str name: "Ethan";
    printl "Hello, ", name;
}

would become

do {
    name: "Ethan";
    printl "Hello, ", name;
}

Comparisons

As with any programming language, StormScript has many different comparison operators. These have not changed much over time, although StormScript uses keywords rather than symbols. These keywords are is, not, less, greater, lesseq, and greatereq.

Website

In early March, I decided that StormScript should migrate to its own website.

The Future

Looking forward, I hope to publish version 1.0.0 by the end of the year. For now, version 0.7.0 just came out, and I am currently working on version 0.8.0. Here are some new things.

String Concatenation

For string concatenation, I am using the $ symbol followed by a variable name inside of a string literal.

do {
    int i: randomrange => min: 0, max: 100;
    printl i, " is my favorite number";
}

is now

do {
    int i: randomrange => min: 0, max: 100;
    printl "$i is my favorite number";
}

Live interpretation

Live interpretation allows code to be run and changes to be reflected live. This would save variable states, as well as location. In the current development branch, live interpretation only reruns the program when changes are made.

$ stormscript test FILENAME

I am happy to say that the file that runs live interpretation is completely written in StormScript.

Afterword

Be sure to check out the website at stormscript.dev as well as contribute to the repository.

I am happy to answer any questions you may have, so please feel free to ask.

StormScript: What's New and What's Better

Ethan Onstott — Thu, 22 Nov 2018 05:03:10 +0000

Intro

On Sunday I made a post explaining what StormScript was and why I believed it was important. Reception was mostly positive with people pointing out things they didn't like with the syntax. I changed two of them. I also changed the Repository so that it is easier to figure out where everything is. Additionally, I added class methods.

Syntax Changes

`end;`

Both people who commented on my post talked about how they didn't like the end; at the end of each code block. I agreed and had actually been thinking about changing this for a while.

Before:

do {
    int x: 3;
    int y: 4:

    if x is y {
         printl x, " is equal to ", y;
    }else{
        printl x, " is not equal to ", y;
    }end;
}end;

After:

do {
    int x: 3;
    int y: 4:

    if x is y {
         printl x, " is equal to ", y;
    }else{
        printl x, " is not equal to ", y;
    }
}

Function Arguments

The way function arguments were declared was a nightmare. Originally I thought it was ok, but now I realize that it takes up too much unnecessary space.

Before:

@args: int x;
func foo {
    printl x;
}

do{
    foo => x: 3;
}

After:

func foo => int x {
    printl x;
}

do{
    foo => x: 3;
}

Class Methods

Class methods are declared the same as normal functions, but inside of a type scope.

type person {
    int age;
    str name;

    func birthday {
        age+: 1;
    }
}

do {
    person p;
    p|age: 22;
    p|name: "Joe";

    printl p|name, " is ", p|age, " years old!";

    p|birthday;

    printl "It's ", p|name, "'s birthday. ", p|name, " is ", p|age, " years old!";
}

I think that the feedback I received is valuable and will make StormScript better. Please keep sending me suggestions.

Of course check out the repository and be sure to contribute or open a feature request if you would like to see anything added.

StormScript: My Thoughts on How Syntax Should Be

Ethan Onstott — Sun, 18 Nov 2018 19:48:33 +0000

A Brief Introduction

In most people's terms, I am new to programming. I am a high schooler with ~4 years of experience programming, one of which went into software development. I feel that to most people, it is strange that I already commit myself (no pun intended) to these kinds of projects. I do not write the neatest code. I write more functional code. With that said, I am looking for people to contribute ideas, code, and issue reports to my repository.

StormScript Repository
StormScript Docs

Why Do I Want to Make This?

For a long time, I have had very strong feelings about how programming is taught and how read. As much as I love C++ and JavaScript, I believe that syntax could be much better. What I mean is that we need more languages that read like Python, but are still very powerful. I understand that most, if not all of us here know many programming languages and are accustomed to these clunky, hard to write and read languages. Let's Face it, they could be much better.

How is this any better?

There are many reasons that I believe that StormScript fixes these issues. To show you, I will compare many languages with StormScript and why I think that it's better.

Functions

Without Arguments

C++:

#include <iostream>

std::string givehello() {
    return "Hello, World";    
}

int main() {
    std::cout << givehello() << '\n';
    return 0;
}

In C++, namespaces are out of control and pretty much the entire library of standard C++ functions and types that aren't inherited from C requires std:: in front of it.

Python:

def givehello():
    return "Hello, World"

print(givehello())

JavaScript:

function givehello() {
    return "Hello, World"
}

console.log(givehello())

Python and JavaScript are very readable and a little readable respectively, but both suffer from the same problem: They both lack a main scope, and just run code in what in other languages is usually the global scope. This kills readability because it is more difficult to sort out where you should put things and what needs to run immediately and what doesn't.

StormScript:

func givehello {
    return "Hello, World!";
}end;

do{
    printl givehello;
}end;

If you look carefully, you might notice that there is no parenthesis where arguments should go, and the reason is simple: If you don't have arguments, you shouldn't have to reserve a space for them.

With Arguments

In almost every language, running a function works the same:

functionname("arg1", &arg2, arg3);

StormScript arguments work in a completely different way. StormScript functions use the => symbol, which is usually used to declare an inline function.
E.g. in JavaScript:

return new Promise(resolve, reject) => { 
    resolve(); 
})

In StormScript, => actually is reserved for running a function with arguments. The @ symbol is used to declare a function with arguments.

@args: int x, str y;
func printxy {
    printl x, '\n', y;
}end;

do {
    printxy => x: 3, y: "hi";
}end;

Classes

Background

I could be alone in this, but it took me a long time to understand what a class is in programming. Since the start of developing StormScript, I have always wanted to change the keyword for declaring classes from class to type.

Examples

C++:

#include <iostream>

class human {
public:
    int age;
    std::string name;
    std::string gender;
};

int main() {
    human h;
    h.gender = "male";
    h.name = "Bob";
    h.age = 22;

    std::cout << h.name << " is a " << h.age << " year old " << h.gender << '\n';

    return 0; 
}

StormScript:

type human{
    int age;
    str name;
    str gender;
}end;

do{
    human h;

    h|gender: "male";
    h|name: "Bob";
    h|age: 22;

    printl h|name, " is a ", h|age, " year old ", h|gender;
}end;

StormScript doesn't differ too much from C++ in how its classes work, but the main difference is that it uses the type keyword rather than the class keyword for declaration.

If statements

StormScript has similar if statements to many other languages with one key difference, it uses is instead of == and not instead of !=. I made this change because I make the mistake of typing = instead of ==, and because it makes it more readable.

Example:

do{
    str x: "hi";

    if x is "hi"{
        printl x;
    }end;
}end;

Be sure to check out the repository and documentation.
StormScript Repository
StormScript Docs

Forem: Ethan Onstott

StormScript: Year in Review

Syntax Changes

Keyword Changes

The removal of end;

Static to Dynamic Type

Comparisons

Website

The Future

String Concatenation

Live interpretation

Afterword

StormScript: What's New and What's Better

Intro

Syntax Changes

end;

Function Arguments

Class Methods

StormScript: My Thoughts on How Syntax Should Be

A Brief Introduction

Why Do I Want to Make This?

How is this any better?

Functions

Without Arguments

With Arguments

Classes

Background

Examples

If statements

The removal of `end;`

`end;`