Why You Should Write a Context-Driven Scripting Language | by Marcus Haberling | May, 2022

Generally one of the best ways out of code complexity is to go deeper.

Picture by Arnold Francisca on Unsplash

Have you ever, Expensive Reader, ever gotten caught in a customization lure?

Instance 0: You add customized vary checking to enter fields with ranges outlined within the database. Persons are delighted. Till they need the vary of inputs conditionally outlined by one other area.

Instance 1: You create a settings web page that hundreds in numerous settings totally free and premium accounts. “Excellent, that is precisely what we needed.” Till, in fact, some settings have to be proven primarily based on the sort or forms of gadgets the person has energetic classes on.

I might go on advert infinitum. The purpose is the extra versatile you or your workforce make your entrance finish, the extra flexibility is demanded. Options beget extra options. Possibly the Kids’s E-book: “For those who Give a Mouse a Cookie” was truly about characteristic creep and software program bloat.

This picture was yanked from the writer’s web site and put right here. (haha Vim joke). In any case hyperlink to its homeowners is here.

And that is what is summoned into your as soon as easy, elegant codebase: bloat. You may perhaps write a bunch of various UI elements and change between them. Or, you would fill a single UI with such an unholy quantity of particular instances, that it turns into unworkable. No matter poison you select, it is yours to swallow.

For those who learn the title, I’m assuming you’ve deduced the thesis: A Context-Pushed Scripting Language could make your code extra versatile whereas slicing down on code bloat and complexity.

However what is a Context-Pushed Scripting Language (CDSL)? Properly, it is a time period I made up (It’s the sacred proper of all software program engineers to make up phrases). It’s outlined thusly:

A Context-Pushed Scripting Language (CDSL) is a small language, not often turning full, that’s given entry to a predefined set of values (context) so as to generate an output.

Picture by gandalfhardcore. Copyright Marcus Haberling 2022. The robotic is the scripting engine, the context that drives and binds it’s the plug. My metaphors transcend the written phrase.

So a CDSL might have entry to the values of each area on a settings web page, which it makes use of to output a spread checking error message, or an empty string if the present area is legitimate. A CDSL takes this formatting code, which was beforehand meshed into the remainder of the Consumer Interface, and places it elsewhere. In all probability a database. Let’s check out the benefits this buys you.

  1. Code Readability: By taking this validation logic out of your front-end code, you may take away numerous the particular instances that plague front-end growth.
  2. Flexibility: Bear in mind, in Instance 0 we had beforehand added code to do a spread verify validation, when our new requirement got here, we then would have needed to both rewrite the previous system or create a parallel system. With a CDSL, the one code that adjustments corresponds on to the sector conduct you’re altering.
  3. Code Reusability: As soon as the interpreter in your CDSL is in place, the code that it executes can be utilized on the a number of platforms you help. Altering the validation code for our area adjustments it throughout the totally different entrance ends we help: Cell, Internet, And so on. We will additionally use the identical code for our secondary validation on the backend. It is a frequent requirement to offer validation on the UI and API layers.
  4. Quick Deployment: As a result of the validation logic is not a part of your codebase, you may replace the conduct of functions exterior of a versioned deployment. For Telephone Apps, this implies sidestepping Apple’s and Android’s approval processes.

It’s nearly unattainable to speak about writing scripting languages normally. That is extra applicable for a Textbook than an article. Let’s then focus on one CDSL particularly. To put in writing this CDSL, we have to adhere to a couple ideas.

Prefix Notation: Generally often known as Polish Notation, Prefix notation may be very easy to course of. In prefix notation, operators come earlier than the operands.

Eg: 3+4/5 turns into +3/45.

Notice that prefix notation doesn’t have an order of operations. This is without doubt one of the nice simplifications it affords us. Prefix notation will also be considered perform notation.

No, we’re not writing a Compiler, it is a scripting language in spite of everything. However this textual content is beneficial all the identical. You may nonetheless get a used copy of the basic Compilers textbook for $11 on Amazon on the time of writing.

No Whitespace: Our script ought to be capable to be written with out whitespace and a minimal variety of management characters. This can assist us to write down small scripts, particularly when just one conditional assertion is important.

Pure Performance: Our scripts shouldn’t be modifying any state. Subsequently, we must always make the language a pure practical language.

We have to set up a syntax for our language, later we might want to parse this syntax and tokenize our script. Individuals have smeared the time period tokenization into different elements of pc science, so it could be higher to name this lexical analysis. Both manner, we’ll be carrying out each duties of defining and tokenizing utilizing common expressions. Warning: when you’ve got bother with common expressions, (Cease mendacity to your self, you do have bother with common expressions) then please take a look at Regex101. I wrote a chunk about it here.

Picture by Shubham Dhage on Unsplash


? <situation> <true return> <false return> | If-Else Assertion
= <left hand aspect> <proper hand aspect> | Equality
! <argument> | Not
> <left hand aspect> <proper hand aspect> | Better Than
< <left hand aspect> <proper hand aspect> | Much less Than
+ <left hand aspect> <proper hand aspect> | Addition
- <left hand aspect> <proper hand aspect> | Subtraction
* <left hand aspect> <proper hand aspect> | Multiplication
/ <left hand aspect> <proper hand aspect> | Division
% <left hand aspect> <proper hand aspect> | Modulus (The rest)
| <left hand aspect> <proper hand aspect> | Logical Or
& <left hand aspect> <proper hand aspect> | Logical And
Notice: Logical operators will deal with any non-zero quantity as zero, there isn't any boolean quantity sort.

Information Sorts

Integers: This CDSL will solely have integer values. For those who want floats when implementing your individual, then so be it. For now, integers will do. We’ll precede all of our integers with a # character to indicate them.


Strings: If we’re going to clear up issues like said in instance zero, we’re going to have to output string values. Easy double-quotes notation will do tremendous. We will escape double quotes with a backslash.


Interpolated Strings: If we need to use our scripts to make strings, interpolation could make the code to take action extra concise. Subsequently we’ll do string interpolation utilizing the next syntax.

"String with arguments 1, 2, 1 and three" #1 "insertMe" #-1Produces: String with arguments 1, insertMe, 1 and -1

The numbers will not need to comply with a strict pure quantity sequence however shall be taken in as arguments from least to biggest. If we add that to our regex we get this:



We don’t want the power to outline features inside a CDSL, however that doesn’t imply we can’t ever need predefined features exterior of our operators. Let’s denote them with a ‘~’ in entrance of alphabetic characters.


Context Values

We did say this was a context-driven language, didn’t we? In fact, we want a manner of accessing this context inside our script code. That is additionally essentially the most customized piece of the language.

Say you may have a settings object you need to entry fields in. I’d entry it with the notation, s.fieldName. The specifics will rely upon what your CDSL is making an attempt to perform.

We’ll preserve our definition versatile. One decrease case character, adopted by a dot and the alphabetic identify of the “context” we are attempting to entry.


There’s a downside with the regex above. It each greedily captures alphabetic characters and begins with an alphabetic character. This implies if we put two of them subsequent to one another, we’ll seize the prefix of the second context with the identify of the primary. This violates our no whitespace precept.

We have to add a detrimental lookahead to not seize a personality adopted by a interval. This have to be added to our perform regex for a similar goal.

([a-z].[a-zA-Z]+(?!.)) - Context Values
(~[A-Za-z]+(?!.)) - Features

Bringing all of it Collectively

Now we simply want to mix our regex statements from operators, worth varieties, features, and contexts. We find yourself with a really lengthy common expression, however one that may break up our script into token strings in a single move.


Now that we have now a well-defined syntax, we want a method of turning that syntax into output. Let’s name that the Scripting Engine. I don’t know if anybody else calls it that, however they need to.

Take be aware that this shall be a really bare-bones description of an engine. The very minimal to get our CDSL off the bottom. I feel you’ll see how a number of the choices we’ve made up to now make this course of far simpler than it might have been.

Picture by lee attwood on Unsplash


First, we have to rework our script into an inventory of token strings. That is easy sufficient, simply extract them utilizing the nice and horrible regex we created above.


As soon as we have now token strings, we have now to show them into tokens (Surprising, I do know). Discover that every token string truly begins with a unique character! I’ll have deliberate this upfront. Utilizing this character, we’ll flip every token string right into a token object. Here’s a little pseudocode.

perform Tokenize(string tokenString) returns token 
if tokenString[0] in listOfOperators:
return CreateOperatorToken(tokenString)
if tokenString[0] == " :
return CreateStringToken(tokenString)
if tokenString[0] == # :
return CreateIntegerToken(tokenString)
if tokenString[0] == ~ :
return CreateFunctionToken(tokenString)
if tokenString[0] in lowerCaseLetters :
return CreateContextToken(tokenString)
throw TokenizationException

Issues definitely don’t need to be damaged up exactly this manner. However no matter your technique, we have to create token objects with a number of items of information.


NumberOfArguments reveals the construction of our CDSL’s execution. Consider each token as a perform, if it takes zero arguments then it returns its worth, if it takes a number of arguments, some execution have to be finished earlier than you may get stated worth.

Stack it Up

We’ve gone from a string to an inventory of token strings, to an inventory of tokens. The following step is to arrange them for execution. To that, we have to flip our record right into a stack with the 0th component on prime. This doesn’t even imply that we essentially need to shift the tokens into one other knowledge construction. It solely signifies that any more we’ll be at minimal utilizing the record on this method. Right here is an inefficient technique, simply to reveal.

perform StackTokens(listOfTokens) returns Stack<Tokens> 
let tempStack = new Stack<Tokens>
let returnStack = new Stack<Tokens>

for every token in listOfTokens:

whereas tempStack just isn't empty:

It’s now apparent why sticking to prefix notation was vital. By placing our program right into a stack with the leftmost token on prime, we put the tokens in good order for recursive execution.

Recursive Execution

I actually am flying at midnight on the extent of rationalization I ought to be giving. Too particular and your eyes will glaze over. Too little, and a might fail to speak to some members of the viewers. However both manner, we have now reached the ultimate step; operating the script and producing an output. This may be finished iteratively however is simpler to reveal (and code) recursively.

if tokenStack is empty:
throw EmptyStackException
let token = tokenStack.Pop()
if token.NumberOfArguments is 0:
return executeWithNoArguments(token)
let args = record of sort Token measurement token.NumberOfArguments
for i in vary 0 to token.NumberOfArguments:
let arg = recursiveExec(tokenStack)
args[i] = arg
return executeWithArguments(token, args)

If this seems slightly bit too easy, it is as a result of I am dishonest. The features executeWithNoArguments and executeWithArguments are doing a little heavy lifting right here. Clearly, issues like string interpolation and performance calls will take a little bit of code.

That is additionally a really fundamental execution. We do no error checking, apart from throwing an exception after we can’t execute the script. We might do issues like ensuring the stack is empty on the finish of execution, or present a stack hint when there’s a failure.

I’ll go away these niceties to your individual implementation.

Instance Code

Let’s say you enable a person to ship themselves an alert as soon as they use a specific amount of information on their plan. They aren’t allowed to set this alert at the next quantity of information than their plan’s MaxMb. If their plan is limitless, the MaxMb is ready to zero, and so they can set the warning at any degree. We would like our script to output an error message, or an empty string if the enter is legitimate. Our context plan is denoted with a p prefix inside our CDSL. Our context settings are denoted with the prefix s.

?|=p.MaxMb#0<s.MaxMbWarnp.MaxMb"""You can't set your warning degree higher than your knowledge restrict of 1Gb(s)"/p.MaxMb#1000

Its a bit extra readable with whitespace between our tokens:

? | = p.MaxMb #0 < s.MaxMbWarn p.MaxMb 
"You can't set your warning degree higher than your knowledge restrict of 1Gb(s)" / p.MaxMb #1000

For those who put each of those into Regex101 with the common expression we created for tokenization, you’ll see they create the identical matches. Prefix notation could be a bit bizarre while you’re not adjusted to it, but it surely’s straightforward to select up.

I feel I’ve laid out a very good case as to why a CDSL might be good in your undertaking, in addition to a wonderful description of learn how to go about making one. For those who suppose I acquired something flawed, let me know within the feedback. This was a somewhat lengthy piece, however I hope you discovered it fascinating. Take into account subscribing to my medium in order for you extra articles like this.

More Posts