Shimlang Embeddable Scripting Language

There’s a niche of programming languages that I’m looking to fill. This is the first part of what will (hopefully) be a series of the journey of the development of my little scripting language called shimlang.

The Niche

I want a language with:

• The syntax of Rust
• The semantics of Python
• The embeddability of Lua

There’s more to this design, of course, and I’ll expand on this in future posts. The design has changed a decent amount since the first draft of this post, but I’ll leave this post intact to serve as a quaint relic of the past.

Rust-Like Syntax

“Rust-like syntax” is a wide and not very specific statement, especially when considering the monumental differences between a dynamic language like Shim and a compiled language with a great amount of static analysis like Rust. I’ll write out a few key things to start to form a picture of what it’s like:

fn print_fizzbuzz(n: int) {
    for i in 1..n {
        let out = if i % 15 == 0 {
            "fizzbuzz"
        } else if i % 3 == 0 {
            "fizz"
        } else if i % 5 == 0 {
            "buzz"
        } else {
            i
        };

        print(out);
    }
}

print_fizzbuzz(100);

More explicitly:

• C-style blocks defined with curly braces
• (Optional) type of a variable appears after the variable name n: u32
• let keyword used to define new variables within a scope
  • TODO: maybe we want Python-style scoping?
• Statements are separated by ;
• No parens for if and for statements
• If-else chains can be used as expressions
• The last expression of a block evaluates to the value of the expression (with an empty expression evaluating to the unit () type).
• Integer, string, and range literals

Python Semantics

• Floating point numbers are 64-bit wide, and are a different type than ints
  • This is in contrast to JavaScipt and Lua (prior to Lua 5.2)
• List/Dict/Set literals, along with their interfaces
  • Dict literals are {:} to distinguish them from an empty block/set
    • This is a bit inspired by Groovy
  • Set literals are {,} to distinguish them from an empty block/dict
• Positional / Keyword arguments
• Iterator interface
• Objects can provide their own implementation of operators
• Standard library based on key packages in the Python Standard Library
  • subprocess
  • pathlib
• Context managers?
  • Otherwise you basically need destructors, which should be fine if we use traditional C-style scoping rather than Python scoping.
• Tuples
• Explicit this or self in method calls
• No inheritance for now…

Embeddability

• Small binary when standalone (target is less than 350 kB)
• Small footprint when embedded in another application
• Modular standard library for strong sandboxing
• C-API for embedding
• All integers are 64-bit signed ints
  • This makes it easier to embed than using bignums (like Python)

Why not use language X?

There many languages that inspire Shim. Facets of those languages inspire the features that Shim provides.

Groovy

A JVM-based scripting language. It’s a decent language, but the influence of Java and the heavyweight JVM make it unreasonable to package Groovy scripts. It’s my own personal hangups that make me avoid the JVM. I can’t stand seeing the JVM gobble up gigs when it should be using far less, and the OOP-only approach to development is a huge turn-off for most of the sorts of things I write.

Rust

Rust is great and has an obvious influence on the synatax of the language. It’s flaw is that it’s compiled, and won’t work where scripts are needed instead.

Mun

Mun: the scripting language that looks like Rust. It’s neat, and it’s meant to be embedded, but it enforces static typing and the size of standalone binaries is too high since it depends on llvm. My ideal scripting language is gradually typed. That let’s me write quick scripts that need to be robust without sacrificing the ability to be robust when needed.

Swift

While I’ve never used Swift, I often reference it for design inspiration. Code written in Swift looks nice.

Python

Python is easy to read and write, and has many well-designed standard library packages. However, it’s difficult to embed, it’s not small, it’s oriented around statements, and you’re at this whims of the users' environment as to whether your script will work or not. I’ve also had trouble packaging Python as a standalone executable.

Lua

Lua is small, portable, and easily embedded in other systems. However, the syntax and semantics of the language are atypical. It uses base-1 indexing, arrays are sparse, it uses prototypical inheritance, and blocks are denoted with words (if, then, for, do, end, etc.). Prototypical inheritance isn’t bad per se, but always requires some sort of library to wrap it, which yields many separate OOP libraries. The proliferation of libraries to learn isn’t great for picking up a language.

Various Lisp Dialects

The Lisp way of thinking is neat. Code is data, data is code, things are expression-oriented. You can essentially build the language you want to use to solve your problem within lisp itself. However, I don’t want to solve big problems with a DSL. I want to solve little problems.

The syntax of Lisp dialects are also a turn-off for some people. I’m not trying to push a philosophy. I just want to have a language that’s acceptable for the majority of people to read and write.

The Name

The name shimlang comes from my own name: Stephen H. Molyneaux > SHM > shim. It’s also a reflection of how I want to use the language. I see it as a way to fill a gap and to create a interface to a larger work.