ShockScript story

[mattqual]

2015

In 2014's eve I began involving voluntarily with PHP (mysqli, PDO), AS3 (under Flash Professional (didn't know of the Adobe AIR and Flex SDKs)), MySQL, Apache XAMPP, JavaScript (a bit of jQuery too?) and Lua... Or, programming, for the first time.

Since nothing I did this time had to do with compiler engineering, I will skip it.

2017

In the 2016's eve I was looking at the luaparse and thought "Why not make something like this for ActionScript 3", and a bit later I found out ECMAScript 4. I was having some curiosity like "compile AS3 to Lua for use in the Transformice MMO's modules". I was tempted to name that parsed language a dialect, like "VegaScript".

Like from many years ahead, I used to build a parser, discard it, and then build another parser (changing language details as well).

2018

Finally, in 2018 I was starting to get into semantics and verification. I also discovered the Rust language and got a bit curious for sometime into thinking "compile a Rusty-language to Adobe AIR", but nothing of extraordinary happened.

I think it was this year I discovered the AIR or Flex SDKs, though I still had no idea of what MXML meant.

2019

Too much trial-and-error. I couldn't give much links about my past work since they got deleted by me, but I found this organization I made in 2019: the most compiler-related thing is the "as-enhanced" repository, an AS3 highlighter for Sublime Text (3?).

2023

My best type checker has been done that year, but it had bugs (in terms of lacking of a defering of verification phases) and the language also diverged from the original (e.g. no namespaces and strip of stuff). The project is VioletScript.

From today's perspective, I see that VioletScript wouldn't do much well UI-wise.

In the even of the same year, I've also finished an AS3 parser in Rust (version 0.3). I also eventually was getting to know the MXML side better of the AS3 tooling (before I was just aware of what Flash Professional provided mostly).

2024

Made a 1.0 version of the AS3 parser in Rust and also tried to make an AS3 expression verifier.

Things were mixed: I was also working at a "Jet" language and its verifier, in Rust. They died because I realized it's too hard to implement a compiler that targets multiple infinite technologies (e.g. Haxe) while supporting a MXML-like language.

2025

Made an AS3 verifier and language server (excluding MXML and CSS temporarily due to API indecisions and also because they basically map to AS3) for a web-based engine. I gave up on it later, mostly because I got thinking "what if I want to implement a Linux's distro client-side UI?' and also because I deepened further into the React.js framework and changed my mind about MXML's class-based UI programming.

Finally, I decided my language is going to be definitely called ShockScript, but whose first implementation is more tied to Whack engine (this runtime should reuse some logic/knowledge from another canceled Rust project) and its feature WhackDS (the way that user UI components should be expressed).

Unfortunately, as you can see in the spec, ShockScript got way more complicated for an actual compiler implementation (I included multi-methods (nice due to method chaining), more structural typing (e.g. getting like ES4) and more type inference). Although, not as overloaded as ES4.

The compiler implementation for ShockScript would also substantially differ from previous ones, as I should:

• Resolve source files lazily (based on package/source path) rather than globbing files recursively
• Generate an internal header for source files that strips actual code implementation (for a more efficient IDE integration)

Like always, these things are done with a package manager in mind.

So far what is implementation-defined:

• The Embed(...) expression
• XML literals
• Certain meta-data

The goal would be to have a way more readable alternative to Haxe (to whom AS3/ES4 matters) as well as better tooling at the same time.

Conclusion

It is challenging to implement ShockScript. The language evolved with partial knowledge of ActionScript 3 technologies; at one point I even considered implementing 3 languages at the same time (although the 2 remaining languages would be simpler than ActionScript 3 itself and just analogical to it).

I don't know what I want anymore, though: if I should go play with the web, or deep in native development by resuming ShockScript.