Battlesnake: the Competition

A few years ago, I learned of a programming competition in British Columbia called Battlesnake. It had been covered in the media.

Battlesnake and JRMPC share some common traits. First, they both involve creating a robotic “mind” (Battlesnake calls it an “AI snake”).

Second, they both work off a grid and, at least in later rounds, involve competing “minds” or “AI snakes” on the same grid, tournament-style.

Third, they’re both team-based events, though Battlesnake permits “teams” of one. JRMPC teams must comprise four students.

Fourth, their prize funds are very similar — $15,000 from Battlesnake and $13,000 from JRMPC (this doesn’t include $2,000 in T-shirts).

Fifth, they both involve some luck. Having the best mind or AI doesn’t necessarily guarantee a win.

Where they differ is that the main Battlesnake event is a one-day affair at a physical venue in Victoria, BC (though there are options with limited seats for remote participation). JRMPC is a national event, entirely online, and takes place over five weeks; the actual code execution occurs in our air-gapped computer.

Mission: Impossible

Also, JRMPC is only open to high school students across Canada. There is only one level, whereas Battlesnake has Beginner, Intermediate (no longer available), and Expert levels for students and non-students alike.

And, most importantly, JRMPC is all about using Smalltalk, the greatest programming language in the world. Battlesnake supports multiple languages. (Interestingly, an AI snake has been written in Smalltalk which has done well in previous Battlesnake competitions.)

I won’t say Battlesnake inspired me to start JRMPC, but it’s an interesting coincidink that the two are so similar and started roughly at the same time, 2015.

To be honest, I don’t find Battlesnake very interesting but this is a personal opinion. I think the JRMPC competition is far more imaginative. Battlesnake’s grid is dull and boring. JRMPC’s Islands of Qyzmr, Concentric Treasure, and City Quadrant are cool beyond belief.

Islands of Qyzmr
Concentric Treasure
City Quadrant

In some respects, JRMPC is more challenging than Battlesnake. The competition maps (or grids) are quite complex and robot strategies need to be very sophisticated.

The introduction of Smalltalk to young Canadian software developers is potentially groundbreaking for the IT industry in Canada. Smalltalk will help entrepreneurs and startups deliver IT solutions in a fraction of the time it would take using languages like Python, JavaScript, Java, C#, C++, and PHP.

Major enterprises like JPMorgan, Desjardins, UBS, Telecom Argentina, Siemens, BMW, Thales, Orient Overseas Container Lines, and Communications Security Establishment (Canada’s national cryptologic agency) have been using Smalltalk for years.

Lam Research is worth mentioning. This company is a vital link in the global supply chain. The electronic components in your smartphones, PCs, laptops, etc. started out as silicon wafers fabricated by Lam machines controlled by Smalltalk. You owe your digital existence to Smalltalk!

Canada has the opportunity to lead the world in software development.

Round 4 Results

I am pleased to announce the #1 leading team for Round 4 in The James Robertson Memorial Programming Competition (JRMPC). Congratulations to Team Dijkstra from Centennial Collegiate Vocational Institute in Guelph, Ontario.

This round is special because it’s the first time that competing team strategies play out on the same board simultaneously. It’s a fight to the finish! No quarter is asked and none is given.

Smalltalk Poll 1

JRMPC is The James Robertson Memorial Programming Competition. First Prize is a staggering $6,000. This poll is about the competition.

Promo videos for the competition:

T-shirt design for the competition:

Here’s how the T-shirts look from one of the teams:

The team-based competition involves finding the best strategy in a Pac-Man style game and implementing it in Pharo, a modern variant of Smalltalk. The purpose of the competition is to attract attention to Smalltalk and raise people’s awareness.

Thanks for participating in the poll.

Smalltalk: An Entrepreneur’s Secret Weapon

If you’re an entrepreneur, and especially if you’re a digital entrepreneur, one of your greatest concerns is getting to market as quickly and as easily as you can. Your business is highly dependent on computers, whether that’s in the area of web applications or mobile development or machine learning or virtual reality or robotics or whatever.

At the heart of software development is the programming language. Some languages make your job easier; others make your job much harder. We will look at one particular language that makes your job as a software developer much easier and much more productive than with any other language in existence.

But first, let’s look at a few programming languages that are frequently adopted by startups…

  1. Python — widely regarded as easy to learn and extremely versatile because of its numerous third-party libraries
  2. JavaScript — practically the only language you can use for writing web browser software
  3. Java — the chief Android programming language and the enterprise standard
  4. C# — most commonly used for Windows/.NET programming
  5. Ruby — best known for its Rails web framework
  6. PHP — the most widely used language for dynamic websites

Python has many peculiarities in its design, especially with respect to object-oriented programming. Its multithreading capability is crippled by the GIL (global interpreter lock). Its lambdas are oddly restricted to single expressions. Its half-open intervals are unintuitive. Its off-side rule syntax is offensive to many programmers.

JavaScript has even more peculiarities, especially with respect to weak typing and its myriad nonsensical type coercions. JavaScript code can fail silently. The language is riddled with traps and pitfalls, which is why so many transpiled languages exist as JavaScript alternatives.

Java is extremely verbose. It’s more awkward to use than Python. C# is Java on steroids.

Ruby and PHP have seen better days. Both are in decline.

To be clear, all of these languages can be effective for startups. However, there is one language that offers very special benefits, especially for entrepreneurs on a tight deadline. It’s called Smalltalk.

The first major benefit is Smalltalk’s simplicity and ease of use. Smalltalk is much, much easier than even Python. The syntax is ridiculously simple. It can be learned in its entirety within 15 minutes!

Smalltalk’s total syntax fits on a post card

The second major benefit is Smalltalk’s live coding capability, which practically eliminates the traditional edit-compile-test-debug cycle that has hampered programmers for over half a century. This helps to make Smalltalk the most productive programming language in the world. On average, Smalltalk is twice as productive as JavaScript, C++, Go, Java, PHP, Python, and C#. In many instances, Smalltalk can be up to 5 times more productive!

The third major benefit is Smalltalk’s purity, clarity, and consistency in its object-oriented model. Smalltalk is the easiest object-oriented language for this reason, far surpassing C++, C#, Java, Python, and Ruby.

Smalltalk’s object-oriented nature makes it supremely maintainable and scalable without the headaches imposed by other object-oriented languages.

The fourth major benefit is Smalltalk’s system image. The image is a snapshot of an application’s total execution environment. It allows you to save the execution state of your program and to resume execution later on at your convenience. This is terribly handy.

Smalltalk’s image also makes software deployment a breeze. You never have to worry about installing and configuring the numerous software components (like libraries and frameworks) that constitute your application in production.

The end result is that a startup can minimize the “time to market” for its product. It can deliver the product months, or even years, ahead of its competitors.

The good news is that Smalltalk is every bit as versatile as languages like Python and Java. For back-end web development, you have Smalltalk web frameworks like Seaside and Teapot. For front-end development, you have transpiled languages like Amber and PharoJS.

For data science, you have tools like PolyMath, Roassal, and Moose. For machine learning, you can use TensorFlow and Keras.

Roassal demo

Smalltalk is also good for things like IoT (PharoThings) and robotics (PhaROS) and virtual reality (check out this virtual reality startup).

virtual reality demo

It can even be used for scripting game engines!

game engine scripting demo

Speaking of games, here’s one for mobile devices called HexSolve written entirely in Smalltalk.

I can’t think of anything that Smalltalk hasn’t done compared to Python, JavaScript, and Java.


Smalltalk is a wonderful secret weapon because it flies under the radar of most entrepreneurs. While startups get distracted by the high profile languages, the smart ones can leverage the tremendous benefits of Smalltalk to get well ahead of competitors.

If you’re interested in checking out this magical language, visit the Resources page at my Smalltalk tech blog.

Fuzzy Thinking in Smalltalk

by Lorenzo Schiavina
EDOR Metodi Quantitativi

When I was a professor of Operation Research at the Faculty of Mathematics at the Catholic University of Brescia, I was lucky enough to contact Lofti Zadeh who was going to develop fuzzy logic and I was impressed by his work.

Subsequently I deepened the topic by reading the excellent book by Bart Kosko, Fuzzy Thinking, and I began to get interested into the approach and to convince myself that this technology could certainly be an extension of the models that I was used to implement.

As I have been dealing with computer science for more than 20 years and I was familiar with all the languages ​​and computers of the time and I was lucky enough to be the first in Italy to know Smalltalk, I presented to the ESUG (European Smalltalk User Group), held in Brescia at my University, plans for an extension of Smalltalk classes (FuzzyWorld) that would be able to deal with fuzzy logic.

The first applications that I tried to develop convinced me that the tool offered absolutely unique possibilities and therefore I deepened my research thanks to two exceptional books.

The two books are:

  • Fuzzy Systems Design Principles – by Riza C. Berkan and Sheldon L. Trubatch – ed. IEEE Press
  • Adaptive Fuzzy Systems and Control – by Li-Xin Wang – ed. Prentice Hall

I was fortunate to develop an application for a premier league athletic soccer trainer and the result was excellent: for 3 years in a row, this trainer (moreover of non-top teams) was among those who had the least injuries; his testimony on my contribution was fundamental.

Since then, I have made fuzzy applications in the most diverse fields, integrating fuzzy logic with optimizations through genetic algorithms.

Fuzzy logic is a tool that has been proven useful in dealing with and solving very complex problems; among these, forecasting problems are certainly to be included.

Since in the beginning of my activity I have had the opportunity to deal with investment problems, it seemed very interesting to do an experiment using this type of approach; the application was named FuzzyStock.

I therefore identified (in a completely random way) a stock listed on the stock exchange to verify the results that the use of this (discussed) computer technology could offer me.

The following pages show the data collected and their characteristics:

Synthesis window of the S&P title data used for the experiment

The input information of the experimentation is reported in the 3 areas:

Title (S&P)

o Number of available data (682)

o Date of training surveys (02/01/01 to 24/09/03)

o Size of training data (598)

Processing specifications

This is the fundamental point of the model: the training algorithm (a moving average implemented in fuzzy logic) which was the heart of the system, was applied to data from 1 to 598; the block (i.e. the fundamental training unit) was 9 data, starting with the first available data.

From the experience of analyzing the structure of the first 598 data, the algorithm had to “learn” how to move to evaluate the data from 599 to 682 and demonstrate whether it had “understood” or not how to make predictions; the time interval of the forecast ranged from 28/05/03 to 24/09/03 and the knowledge deriving from the analysis of data from 1 to 598 was applied to this interval

Strategy specifications (demonstration not included)

The strategy specifications identified the elements for simulating the model’s performance (that was not fuzzy oriented):

Buying filter: percentage of growth in the price of the security to make a purchase

Selling filter: percentage of decrease in the price of the security to make a sale

Stop loss filter: percentage of error to decide the abandonment of the chosen strategy (purchase or sale)

Void selling filter: percentage of variation for short selling

Wrong forecasting filter: error percentage for changing strategy (purchase or sale)

The execution of training time of the model is about 6 seconds, after which the result of the forecast is presented:

The result shows both the value of the fuzzy model and the “traditional” one of the trend (the old approach I used), the model of which is shown on the third line of the display; on the fourth, it is possible to indicate a percentage uncertainty assessment to be applied to the reported price that can be entered by a “human” expert.

The response columns are as follows:

  1. Detection date
  2. Lower value of the acceptance interval of the day chosen by the user through the value of probability (90% in the model)
  3. The prediction made by the model
  4. Upper value of the acceptance interval of the day chosen by the user; obviously the value of column 2 and column 4 identify the acceptable price or not; outside the range, the forecast is incorrect
  5. Real price of the day
  6. Forecast error due to exit from the acceptance interval
  7. Forecast provided by the use of the trend model shown on the third row above

On line 6 you can see the indication of out range error (forecast 973.27; real minimum 971.42 i.e. an over estimation).

The data can be stored for subsequent evaluations, brought to Excel or shown.

Using the Show trend button, it is possible to view and graphically analyze the result of the forecast (both fuzzy and trend numerical value in the lower part, where the trend parameters are evaluated):

At the first line the number of last period observations; in red the price of the day; green forecasts for the trend; fuzzy ones in blue

The result of the fuzzy model is particularly interesting (obtainable by disabling the Trend flag) and using a larger series, in this case 50 items):

By eye it can be seen that the maximum forecast error occurred between 20/08 and 7/09; by clicking on the point, you get the detail of the observation:

As you can see, the maximum error (Scarto percentuale) made by the fuzzy approach has a difference of less than 2% of the price.

Pleased, notice that this error was the biggest in the series, excluding a specific case I am going to point out .

It is interesting to note that a terrorist attack occurred in Madrid during the trial period.

Obviously, the result of this event has profoundly influenced the stock market price (and I suppose this was the reason for wrong forecasting).

Of course this event is known to operator, so the processing window had been modified adding the possibility for the human operator to insert his personal evaluation to the forecast, obviously dependent on the external events observed.

Extending the Smalltalk Syntax 4

by Leandro Caniglia
President of FAST (Fundación Argentina de Smalltalk)

Story 4: Hybrid Compilation

Have you ever heard of the idea the creators of Smalltalk had for allowing any class to choose its compiler? To provide support for this classes respond to the #compiler message before the actual compilation is attempted. Why then, this capability hasn’t been exploited yet? Are you willing to investigate it further? OK, bear with me.

In Story 3 of this series we discussed how to inline TaggedNodes in a Smalltalk method. We mentioned several applications of this capability and took JSON as a basic example. Today we can take a similar approach and try to see how to do our exploration with JSON in mind. From there it will become fairly clear how to proceed in other cases. So, let’s put ourselves this objective: compile the following method in our Smalltalk dialect:

      "latitude": 48.858093,
      "longitude": 2.294694

Where to start? Here is the roadmap:

  1. Discuss the introduction of pragmas for enabling foreign compilation.
  2. Introduce the HybridCompiler class.
  3. Generate the hybrid method when there are no arguments.
  4. Introduce the ParametricString class.
  5. Generate the hybrid method when there are arguments.

Task 1: Discussion

Let’s start by noticing how our example above is slightly different from what we did in Story 3. Here <json> is not a tag but a pragma (there is no closing tag). We are using this pragma to make it clear that we will be using a foreign compiler.

A similar example with JavaScript

    $scope.canSimulateCase = function(c) {
        return !$scope.isProcessingCase(c)

One difference with tagged nodes is that here the entire method body is written in a foreign language. Why this variation is interesting? Because it will allow us to pass Smalltalk arguments to foreign methods. Like this:

jsonCoordinates: lat longitue: long
      "latitude": #lat,
      "longitude": #long

meaning that the foreign source code will be generated dynamically.

Note that I’ve used # to mark what follows as an argument. We don’t want to replace every occurrence of 'lat' and 'long' with the arguments; do we?, so we need to tell where we want the replacements to happen. The reason for using # as a marker is that it presents (almost) no collision with foreign tokens.

Task 2: Hybrid Compiler

If we get back to our examples above, we will see that these methods have two parts: (1) a Smalltalk header including the pragma and (2) the foreign code. This accounts for hybrid compilation. We need to, at least, parse the beginning of the method to read the pragma that tells which compiler to pick, and then pass it the body. For doing all of this we will need the following class

    subclass: #HybridCompiler
    instanceVariableNames: 'source smalltalk foreing method'
    classVariableNames: ''
    poolDictionaries: ''

The smalltalk ivar is initialized to the Smalltalk compiler, and foreign to the parser (or compiler) associated to the method’s pragma. When the source is set, the smalltalk compiler is used to read the pragma ('json' in our example). At this point the Registry (see Story 3) will provide us with the foreign parser. If there is no pragma or there is one which is not in the Registry, the compilation is entirely on smalltalk. The method ivar will hold the compilation result.

Task 3: Hybrid method

Once an instance of HybridCompiler has been initialized, it is time to compile the method. For now we will assume that there are no arguments (unary case).

HybriCompiler >> compile
  | cm |
  foreign isNil ifTrue: [^method := smalltalk compileMethod: source].
  ast := foreign parse: self body.
  cm := smalltalk compileMethod: self template.
  method := ForeignMethod from: cm.
    sourceCode: source;
    foreignCode: ast format;
    foreignParser: foreign

There are several things to explain here:

  • The #body method, with the help of the smalltalk parser, answers with the foreign body, i.e., the part of the source code that comes after the pragma.
  • The #template method answers with the source code of the Smalltalk method that will actually be executed when the hybrid method is invoked.
  • The ForeignMethod class is a subclass of CompiledMethod that adds support to certain messages required from hybrid methods.
  • The #format message sent to the ast is optional. I would recommend including it because it is nice to have your foreign code formatted as soon as you save your method.

In the unary case we are now, the #template method has the following source code

  ^self selector , '

where #selector answers, with the help of the smalltalk compiler, the method’s selector; the following two symbols are placeholders for two slots in the literal frame that we will change below. Note that the compiled method will answer with the contents of the first literal slot.

ForeignMethod >> foreignCode: aString
  self literalAt: 1 put: aString
ForeignMethod >> foreignParser: aParser
  self literalAt: 2 put: aParser

The second literal holds the foreign parser, which may be needed for further processing (e.g., painting the source code).

Task 4: Macro Expansion

We will now address the case where the method has arguments which are inserted in the foreign code using # as the marker prefix. Let’s refer to these prefixed identifiers as hashed tokens.

What we need is to dynamically replace all hashed tokens with the corresponding arguments. For doing this we will introduce a new class named ParametricString, which will implement this transformation as a service.

Basically this new object takes aString including hashed tokens and a sequence of all possible tokens (in our case, the sequence of method arguments). Using this information the object produces a sequence of strings and indexes. The strings are the fragments between hashed tokens, the indexes refer to the sequence of hashed tokens. For instance if the inputs are:

  • 'hello #world, this is a #test'.
  • #('test' 'dummy' 'word')

the object should generate the following sequence:

#('hello ' 3 ', this is a ' 1 '.')

with the somewhat clearer Squeak-braces syntax, this would be

{'hello'. 3. ', this is a '. 1. '.'}

Later on, when the object is required to expand the tokens using actual arguments it will replace the indexes with the corresponding values, concatenating them all. The message to do this will be

aParametricString expandWith: arg1 with: arg2 ...

Task 5: Hybrid method with arguments

Since we have already worked on the unary case in Task 3, we only need to redo the #template method for the case where there are arguments.

The first change to consider is that what before was simply the selector, it is now a keyword message with the formal arguments. This can be simply accomplished with the help of the smalltalk compiler, so I will not go in detail here. We will just assume that self selector will answer with the signature of the method (i.e., 'keyword1: arg1 keyword2: arg2'…).

Since the source code will be now a bit more complex, I will use the #streamContents: constructor.

  | arguments processor |
  arguments := self arguments.
  processor := ParametricString from: self body tokens: arguments.
  ^String streamContents: [:strm |
      nextPutAll: self selector;
      nextPutAll: '| ast |';
      nextPutAll: '#code.';
      nextPutAll: '#parser.';
      nextPutAll: 'ast := #parser parse: (#code expandWith: '.
      do: [:arg | strm nextPutAll: arg]
      separatedBy: [strm nextPutAll: ' with: '].
      nextPutAll: ').';
      nextPutAll: '^ast format']

A key remark here is that in order to connect processor with: #code we need to make sure we plug the processor in the first literal slot, where #code acts as its placeholder. This is achieved by a modification to the #compile method we saw in Task 3. Instead of sending ast format as the argument of foreignCode: we need to send

ParametricString from: code tokens: self arguments

Final words

As always, the code presented here is just a sketch of the actual code, which might end up being a bit more complex (but not too much!). Also, there are lots of details in my description for which I haven’t included any code at all. The reason is two-fold. Firstly, my goal is to provide a roadmap rather loadable code. Secondly, I don’t want to capture all the fun just for myself.

Extending the Smalltalk Syntax 3

by Leandro Caniglia
President of FAST (Fundación Argentina de Smalltalk)

Story 3: Tagged Nodes

What do you do when you have to include JSON in a Smalltalk method? Something like this?

      "latitude": 48.858093,
      "longitude": 2.294694

In other words, do you represent JSON data with plain strings? Wouldn’t it be nice to improve this? What if the compiler knew that this String should conform to a specific syntax? What if the Smalltalk browser knew how to format JSON strings? Or even color them for the sake of readability?

Before jumping to JSON strings, let’s step back and think of other cases that might be similar. Have you ever represented HTML as a plain String? What about CSS or even JavaScript? I’m sure you have faced situations where you inlined foreign code as a plain String in a method, keeping that information in your head rather than in the method, where it should naturally belong? Want to change this? Ok. Let’s do it.

Where to start? Here is the roadmap:

  1. Consider the introduction of tags for inlining foreign scripts.
  2. Introduce a new subclass of LiteralNode named TaggedNode .
  3. Consider the introduction of foreign parsers such as a JsonParser.
  4. Introduce a new class of AST node named ForeignNode.
  5. Process the body of the foreign script, according to its semantics.

Task 1: Smalltalk tags?

Before making a decision for tags, let’s see which other options do we have. In order to inline foreign scripts, we must tell the Smalltalk parser how to delimit them. There are several delimiters already taken in Smalltalk:

  • White space
  • Single and double quotes
  • Parenthesis and brackets (both square and curly)

Can we think of any other? Backticks are tempting. The problem is that they would only work for a single semantics. Say we decide to delimit JSON using backticks; how would we delimit HTML or CSS or JavaScript or Assembly or C, should the future bring a need for any of them?

We want flexibility and that’s why tags are a good choice.
Using tags we will be able to inline foreign code like this:

      "latitude": 48.858093,
      "longitude": 2.294694

And how do we make sure that tags do not confuse the Smalltalk parser? To answer this question think of all the places where $< is misplaced in regards to the Smalltalk syntax:

  • On the right of assignments
  • When a message argument is expected
  • On the right of the return symbol

In other words, none of the following sequence of characters conforms to the Smalltalk syntax:

  • temp := <
  • 3 + <
  • self msg: <
  • ^<

See? Every potential syntax error is an opportunity for extending the syntax!

Of course, angle brackets <...> are already legal in the Smalltalk syntax as pragma delimiters. But pragmas are illegal when placed in assignments, arguments and returns. To be valid, they must start a Smalltalk statement. And this is precisely why we will forbid tags at the beginning of statements and restrict them to assignments, arguments and returns.

Task 2: Add the class for tagged nodes

A tagged node is a way of delimiting foreign code and as such it is a new type of literal. So, add a subclass of LiteralNode named TaggedNode. This subclass will add the tag ivar that will link its instances to their specific meaning.

As we depticted above, instances of TaggedNode need to be instantiated by the parser in the following four cases:

  • When parsing an argument of a keyword message
  • When parsing the argument of a binary message
  • When parsing the expression of an assignment
  • When parsing the expression of a return node

This means that we need to modify essentially four methods so that they now check whether the next character is $<. If it is not, the original code regains control. Otherwise, the code branches to a new method that will scan the TaggedNode or fail (if there is no closing tag, etc.).

I’ve used the verb to scan because in order to form a TaggedNode, we will need to scan the input at the character level (usually the parser deals with tokens provided by the scanner).

When scanning the opening tag we will need to read the input until $> is reached (issuing and error if it isn’t). This will give us the value for the tag ivar of the TaggedNode. At this time we will also know that the closing tag should be '/', tag. So we can read the body of the foreign code until '</', tag, '>' is found (error if not).

At this point we are ready to

Task 3: Decide how to process the foreign script

Now we have access to the body of the TaggedNode. What do we do with it? Well, this depends on the semantics we want to give it. In the case of JSON, for instance, it would be enough to parse it using a JSON parser, and then format it using a JSON writer. We could also paint it with colors and emphases, so to make it look great in our environment.

In other cases, such as the one where the foreign code is Assembly, we could decide to go a step further and compile it into machine code. This will bring two capabilities: (1) Parsing and formatting/painting the Assembly source code and (2) Making the node answer with the corresponding machine code when the method is executed.

There are many other possibilities. In the case of JavaScript or any other programming language, we could decide to execute it on top of Smalltalk (at least up to some extent, this should be feasible).

On the other end of our wide horizon of possibilities there is one that consists in doing nothing, i.e, simply keeping the body as a String with no special semantics. This is useful for experimentation. For instance, if you plan to write a parser for inlining VBA code, before embarking in such a project, you might want to see how
the tagged code would look. You will need to format it yourself and will have no coloring available. However, it will bring a secondary benefit: you will not have to worry about duplicating embedded quotes (in VBA the quote is the comment separator).

The last case is the simpler one. Still, it requires the introduction of a new kind of literal node, which we will call StringNode. So, instead of keeping the body in the TaggedNode as a String, we will create a StringNode with the body as its value and will keep this new node as the value of the TaggedNode. This indirection will provide the flexibility we need for making free use of TaggedNode.

Note also that while making these decisions you should keep in mind that sometimes it is not necessary to implement a parser of the entire specification of the foreign language. For instance, if you will only deal with CTypes and C-Structures, you don’t need to parse arbitrary C, you just need to parse these declarations. The same might be true with other languages. Usually you will only inline a limited subset of them. The key here is to create the machinery that will make further enhancements easier and consistent.

Task 4: The foreign node

So far we have discussed two new nodes: TaggedNode and StringNode, both subclasses of LiteralNode. The ivar tag in TaggedNode holds the node’s tag string. Where we have to be careful is in deciding the contents of the value ivar because this is where the semantics enters the game.

Since we are planning for support of different languages, we will need a global Registry of available parsers/compilers. For instance, the package that loads the JSON parser will be able to register the <json> tag with the corresponding parser. Similarly for <html>, <css>, <asm>, <js>, <vba>, etc.

In this way, when the TaggedNode receives the #body: message with the foreign code as the argument, it will be able to enter the Registry with its tag and get the corresponding parser from there. If there is none, the TaggedNode will resort to StringNode, passing it the body and keeping this node in its value ivar.

TaggedNode >> body: aString
  value := Registry
    at: tag
      ifPresent: [:p | ForeignNode new parser: p]
      ifAbsent: [StringNode new].
  value value: aString

The ForeignNode will have two ivars: parser and ast. The latter is computed as follows:

ForeignNode >> value: aString
  ast := parser parse: aString

Task 5: Compile/Process

Now that we have all the pieces in place we can use them to, at least, format and/or color the foreign code. This is simply achieved by asking the ForeignNode, its ast or its formatted/colored representation. You could also provide more advanced featrues such as the ones we have mentioned in Task 3, or even take advantage of yet another technique that we will discuss in the next story which is Hybrid Compilation.

Create your website at
Get started