Posts on Roads Less Taken

Elrond and NEAR

Wed, 21 Apr 2021 00:00:00 +0000

Back in 2018 I got into crypto currencies. I ended up focusing on Nano and built Canoe , a cross platform (mobile and desktop) wallet for Nano. Nano is crazy fast (one or a few seconds) and has zero fees. For payments it’s superb and the architecture of Nano is clear and simple. I still have a lot of respect for Nano, but… 2020 taught me one thing - smart contracts are actually not just a gimmick.

So for me, sorry, Nano is not a project “of the future”!

I accidentally got involved in the DeFi world in the CORE project, which runs on top of Ethereum. My contribution was just making a cross Discord/Telegram chatbot, RoboCORE , and writing a bit about “floor price calculations” but the whole DeFi landscape convinced me that smart contracts are an essential ingredient in a modern crypto currency platform.

Real true scalability is also mandatory, which IMHO really has to boil down to sharding, even if novel faster consensus models are damn cool like Avalance has (the Snowflake consensus protocol).

So back to googling and reading … and there are two projects that so far stand out in my book:

Spry Error Handling

Wed, 21 Apr 2021 00:00:00 +0000

Work on Spry continues… in small spurts. :) One thing that I have pushed ahead of me for far too long is error handling. People interested in Spry have been asking about it and yes, I decided to start getting a handle on it.

In fact, I wrote this article last year but forgot to get it done and published!

Error handling is an interesting topic, earlier it wasn’t really much controversy around it but the advent of new techniques (Optionals etc) in combination with languages making… “interesting” choices (I am looking at you Go) has made this subject fairly hot. So what do we want in Spry??

CORE floor price musings

Sun, 01 Nov 2020 00:00:00 +0000

I have already written three different articles explaining how CORE floor price can be calculated. But just a day or two back the CORE team decided that using the floor price concept in communcation doesn’t work out very well. Why? Because a LOT of people just can’t seem to understand it properly and keep perpetuating wrong conclusions around it. In short - people can’t understand math :)

A list of common misconceptions are:

Floor price is the “correct value” of CORE and that the current price then must be too high
Floor price is some kind of approximation and the price can actually go lower
Floor price is a technical analysis support level
Floor price can change if another market starts trading CORE lower
Floor price can never ever go down in USD value
Floor price can never ever go down in ETH value

And a whole bucket of other misconceptions - just pile it on! Let us start with an explanation of what floor price ACTUALLY IS and then go through the above list…

CORE floor price over more pairs

Thu, 29 Oct 2020 00:00:00 +0000

In the previous article I explained the principles behind CORE’s floor price, the lowest price that CORE can reach. It’s a novel concept and a very interesting characteristic of CORE.

I showed the mechanisms involved and how to calculate the floor price, if we only have a single trading pair to worry about. I have also solved the equation for two trading pairs, that equation is currently used in RoboCORE with success.

But how to handle three pairs or more? Complexity seemed to spin out of control, but… it turns out there is a simple solution!

CORE floor price short howto

Thu, 29 Oct 2020 00:00:00 +0000

In the previous two articles I explained the principles behind CORE’s floor price, the lowest price that CORE can reach and ended it all by explaining the “q method” that works for any number of CORE pairs. For lots of people that was possibly an overdose of math, so … here is the super short and lacking any explanations on why description on how to calculate floor price of CORE using the “q method”.

Everything you wanted to know about CORE floor price but was too afraid to ask

Wed, 28 Oct 2020 00:00:00 +0000

The last month I have gotten involved in a fairly new crypto currency project called CORE , or cvault.finance . My main contribution is RoboCORE a chat bot operating on both Discord and Telegram serving the CORE community with various calculations and notifications.

A concept central to CORE is what is known as “the floor price” and in developing RoboCORE I had to learn how to calculate it properly. This concept is a bit hard to grasp, so this article tries to clear up the fog!

What is a floor price? It’s simply the lowest price CORE can ever reach. It’s not a floor in fiat, like the USD, but rather a floor measured in ETH (or BTC), the assets CORE is traded against. So if those drop to zero in worth, then there is nothing CORE can do about that!

Revisiting Spry

Fri, 05 Jun 2020 00:00:00 +0000

After a period of slower progress I got reignited regarding Spry . So far I have written a lot of articles about Spry, and during this time things have evolved and changed.

So I am now trying to “clean house” on where Spry stands today. This sweep through the old articles is a first step, then I will update the language manual to be 100% in sync with the implementation.

Let’s go through the articles from the beginning!

Writing Arduinobot in Nim

Thu, 26 Oct 2017 00:00:00 +0000

In the eCraft2Learn project which Evothings is participating in we were looking at various ways Nim is an awesome programming language and this article is a whirlwind-copy-paste-into-your-terminal-as-you-read-thing to show how you install Nim, write a small program, compile it and package it in a very short time.

To spice it up, for no specific reason at all, we are doing it all inside a Linux Container - a fast virtual environment to work in. It’s just a nice way to have a clean environment and to ensure that you as a reader see the same results as I do.

Nim crash course in LXC

Tue, 24 Oct 2017 00:00:00 +0000

Nim is an awesome programming language and this article is a whirlwind-copy-paste-into-your-terminal-as-you-read-thing to show how you install Nim, write a small program, compile it and package it in a very short time.

Benchmarking Spry vs Squeak

Fri, 26 Aug 2016 00:00:00 +0000

Spry is evolving quite nicely during my night hours. Focusing on performance is however still premature, but I do want to verify that I am not barking up the wrong tree, like … in the wrong forest even. So I make trivial benchmarks from time to time, just to see and learn.

Some background on the Spry implementation may be interesting. Spry is implemented in Nim as a direct AST interpreter, it’s not a JIT, in only about 2000 lines of code. It has a recursive classic “naive” design and uses a spaghetti stack of activation records, all allocated on the heap relying fully on Nim’s GC to do it’s work. It also relies on Nim’s method dynamic dispatch in the interpreter loop for dispatching on the different AST nodes. Blocks are true closures and control structures like timesRepeat: are implemented as primitives, normally not cheating. Suffice to say, there are LOTS of things we can do to make Spry run faster!

The philosophy of implementation is to keep Spry very small and “shallow” which means we rely as much as possible on the shoulders of others. In this case, primarily Nim and it’s superb features, performance and standard library.

Enough jibbering, let’s do some silly damn lies - ehrm, I mean silly tests!

Is Spry a Smalltalk?

Tue, 19 Jul 2016 00:00:00 +0000

I love Smalltalk and I have been in love with it since approximately 1994. I have used VisualWorks, VisualAge (IBM Smalltalk), Dolphin Smalltalk, GemStone, Squeak and Pharo quite a lot, and I was very active in the Squeak community for a long period.

But the last few years, finally, I have started to feel the “burn”… as in “Let’s burn our disk packs!” . And last year I started doing something about it - and the result is Spry . Spry is only at version 0.break-your-hd and several key parts are still missing, but its getting interesting already.

Now… is Spry a Smalltalk? And what would that even mean?

I think the reason I am writing this article is because I am feeling a slight frustration that not more people in the Smalltalk community find Spry interesting. :)

And sure, who am I to think Spry is anything remotely interesting… but I would have loved more interest. It may of course change when Spry starts being useful… or perhaps the lack of interest is because it’s not “a Smalltalk”?

Smalltalk family Link to heading

The Smalltalk family of languages has a fair bit of variation, for example Self is clearly in this family, although it doesn’t even have classes, but it maintains a similar “feel” and shares several Smalltalk “values”. There have been a lot of Smalltalks over the years, even at PARC they made different variants before releasing Smalltalk-80.

So… if we look at Spry, can it be considered a member of the Smalltalk family?

There is an ANSI standard of Smalltalk - but not many people care about it, except for some vendors perhaps. I should note however that Seaside apparently (I think) has brought around a certain focus on the ANSI standard since every Smalltalk implementation on earth wants to be able to run Seaside and Seaside tries to enforce relying on the ANSI standard (correct me if I am wrong).

Most Smalltalk implementations share a range of characteristics, and a lot of them also follow the ANSI standard, but they can still differ on pretty major points.

My personal take on things in Smalltalk that are pretty darn important and/or unique are:

Everything is an object including meta levels
A solid model for object oriented programming
The image model
100% live system
The browser based IDE with advanced cross referencing, workspaces and debuggers
The keyword syntax and message cascades
Message based execution model
Dynamic typing and polymorphism
Closures everywhere with lightweight syntax and non local return
Very capable Collections and a good standard library

Not all Smalltalks cover all 10. For example, there are several Smalltalks without the image model and without a browser based IDE. Self and Slate and other prototypical derivatives don’t have classes. Some Smalltalks have much less evolved class libraries for sure, and some are more shallow in the “turtle department”.

In Spry we are deviating on a range of these points, but we are also definitely matching some of them!

Fowltalk - a new Smalltalk

Sun, 19 Jun 2016 00:00:00 +0000

In my quest making Spry I also learned about other efforts in the Nim community to construct Smalltalk-like dynamic languages. The most ambitious one may be Fowltalk by “fowl” who typically hangs out in the #nim channel on Freenode. Fowltalk started out written in Nim but since fowl wanted to learn more C++ it’s now written in C++17.

At the moment he is rewriting the parser and code generator parts in the language itself , following a similar bootstrapping style as Ian Piumarta’s idst . For example, here is the method parsing keyword messages .

Spry Performance

Tue, 24 May 2016 00:00:00 +0000

When writing Spry I am so far mainly ignoring performance. The general execution of Spry code will be a regular interpreter (although stackless I hope) and not a JIT. But that doesn’t prevent us from playing around and learning something!

In this article I do some silly experiments around interpreter startup time and fooling around with 40 million element arrays. As usual, I am fully aware that the languages (Pharo Smalltalk, NodeJS, Python) I compare with a) have lots of other ways to do things b) may not have been used exactly as someone else would have done it. A truck load of salt required. Now… let’s go!

Spry vs Allen

Sat, 14 May 2016 00:00:00 +0000

Allen Wirfs-Brock wrote down a bullet list of what he thought actually made it possible for the Alan Kay team to create Smalltalk , and many other ground breaking things, at Xerox PARC in the 70s. Let’s take a look at his bullets one by one and see how it applies to Spry and my puny little effort around it :)

Spry Modules, part II

Tue, 03 May 2016 00:00:00 +0000

In the last article I outlined a simple model of modules and that is kinda implemented but needs a few fixes. The next step is how to find and combine modules and this is an area where I want to push the envelope a bit. Most popular package/module systems today are quite trivial in nature. Often it’s a command line tool that queries central catalog(s) and then proceeds by downloading code in the form of source files onto disk. Then the compiler or runtime environment finds and loads the code by simply looking for files on disk. There are several parts of this that are very primitive.

When I built SqueakMap waaay back I was already then tainted with the idea of shared object models and one of the primary ideas in SqueakMap was to make sure each local Smalltalk environment got a full live object model of the catalog which then could be queried, viewed and reasoned about inside the Smalltalk environment. Much more powerful than a bunch of JSON files on disk. This led to the approach of downloading the full catalog in a serialized form - and then loading it into Squeak .

With Spry I want us to create a simpler meta model - at least for starters - but with an even smarter infrastructure backing it…

Spry Modules

Sat, 16 Apr 2016 00:00:00 +0000

As discussed in the previous article I want Spry to have a trivially accessible persistence mechanism enabling something similar to the Smalltalk image model, but based on a database. The memory organisation in Spry is basically nested Maps. After dwelling a bit on the inevitable hard question about modules and namespaces I have decided on a design that I hope will turn out simple and reasonably powerful!

Smalltalk has a Dictionary holding all the globals forming “the roots” of the object memory. In Smalltalk this Dictionary is also itself a global variable accessible as Smalltalk, in other words Smalltalk == (Smalltalk at: #Smalltalk). The primary use of Smalltalk is to hold all classes by name, so they are all reachable as globals. Obviously Smalltalk can also hold any kind of object (not just classes) as a global.

Spry also has such a top level Dictionary, but in Spry we call a Dictionary a Map to be a little bit more aligned in terminology with other languages (and it’s shorter). This top level Map is the root Map and it is accessible via the word root. In Spry the root word is actually bound to a primitive function returning this Map, so in Spry we also have root == (root at: 'root).

Ok, so Spry has a Map of globals and one way of using Spry is simply by populating root with words bound to functions making these functions globally accessible, it’s how I have done it so far. Yeah, yeah, I know, but for smaller systems it probably works just fine!

But…

Spry image model

Sat, 09 Apr 2016 00:00:00 +0000

In developing Spry - renamed from Ni - I am getting closer to the Really Fun Stuff.

As a Smalltalker I dream “bigger” than just managing source code as text in files…

Smalltalk uses the “image model” in which the system is alive and running all the time, the full development environment is also live together with your application, and we are in fact modifying object structures when we develop Smalltalk programs. We can also snapshot that object memory onto disk and fire it up somewhere else. Several Lisp implementations have used a similar approach I think.

The image model has tons of really cool benefits, I don’t have time repeating all of them, but a modern implementation of the idea should take a few things into account that was not considered in the 1970s:

The “image” in Spry will be buildable from source
You should be able to use Spry without the image mechanism (you can already)
Spry code will have a readable text format and file structure
The image model does not have to be all or nothing, it can be partial
The image mechanism will be a module for the Spry VM, so you can skip it entirely

Some argue that the image model has downsides - like being an “ivory tower” incapable of interacting with the outside world. The Smalltalk environments have indeed historically suffered a bit in varying degree, but we can easily find ways around those issues while still reaping the awesomeness of a fully live programming environment, especially if we give the above items proper thought from the start.

With Spry I think I have a beginning to a novel approach… as well as taking the above into account.

Ni renamed to Spry!

Fri, 08 Apr 2016 00:00:00 +0000

When I started out implementing my own language in Nim I named it “Ni” without that much thought actually. It was a pun on “smaller than Nim” (obviously one letter shorter!) and of course with a reference to Monty Python .

But… really, the name “Ni” sucks. It’s hard to say in general and since it’s often mentioned together with Nim the confusion is obvious. And it also turned out to be less than optimal to google for.

Nim meets Arduino

Thu, 25 Feb 2016 00:00:00 +0000

I now work as the Team Lead at Evothings and our open source product is a Workbench for creating mobile HTML5 applications focused on IoT, by editing and running them live on the mobile device inside our spiced up Cordova based “Evothings Viewer”.

I am of course partial here - but the tool is really easy to use, doesn’t force you into any specific framework or editor, enables a very quick development cycle and has tons of examples, tutorials, docs and some special IoT focused libraries like for example around BLE (Bluetooth Low Energy). You can have your code running on your phone literally within 1-2 minutes and you don’t need to install XCode or the Android tools, you can even run it just fine from your trusty Linux laptop! Just go for it . Ok, enough of the sales talk…

Since we are specializing in the IoT space we have our office filled to the brink with toys… eh, I mean IoT devices of all kinds from all different vendors. Two IoT communication standards are particularly important in this space, and that’s BLE and MQTT. I have already written three blog posts around MQTT using Evothings. Now I am instead focusing on BLE and particularly the embedded device side of the story.

This led me to round up a bunch of devices at the office that are fairly technically capable and have BLE support. The one I selected was the LinkIt ONE development board from MediaTek & Seeed Studio . It’s an insanely feature packed little board (GSM/GPRS, GPS, Wifi, BLE, sound output, SD card) with decent computing power (ARM7 EJ-S, 16Mb flash, 4Mb RAM) while still remaining in the “medium” embedded space I would say, still ruling out plain Linux and regular tools. I consider the Raspberri Pi or C.H.I.P and similar machines to be in the “large” embedded space, they are real computers and you can basically use whatever you like to develop on those.

The medium and small devices can be programmed using for example Espruino or Micropython (two very interesting projects) but in many cases, for more demanding applications, C/C++ is still king simply because of size and performance advantages. And also the fact that hardware vendor SDKs are typically in C/C++. But could there be an alternative language out there?

A language that is just as fast and small that easily can use all these C/C++ SDKs?
A language with a syntax similar to Python made to be easy to write and read?
A language with soft realtime GC and a sane advanced type system with generics?
A language with a good standard library and friendlier than C++?
A language with compile time hygienic AST based macros written in the language itself?
A language offering an imperative style and not forcing OO if you don’t want to?

Yep! Read on to find out…

Evothings + Phoenix = Neato

Mon, 14 Dec 2015 00:00:00 +0000

I have just started working at Evothings !

It’s a fun gang making slick development tools and libraries for building mobile IoT apps. Evothings is pushing the envelope on really easy mobile development focused on all the new nifty IoT-devices flooding us over the next few years.

In my last article I predicted Elixir to become big and now that I am learning the Evothings tools I wanted to make an Evothings example that uses Phoenix , the Elixir web server framework, as a backend, using its channels mechanism for websocket communication.

Coinciding with the release today of Evothings Studio 2.0 beta 2 (yay!) I will show step-by-step how to:

Install Evothings Studio locally. It’s just unpacking a zip :)
Make sure we can run the “BLE Scan” example app and modify it.
Get a Phoenix server up on a Debian/Ubuntu server on the internet.
Modify the app and server to use Phoenix channels for publish/subscribe of scan data.
Verify it all works!

Since not everyone has a Linux server up on the internet you can skip step 3 and just use my public server :)

Let’s go!

Elixir Booming

Tue, 27 Oct 2015 00:00:00 +0000

It seems like the “damp cloth of Java” that has been plastered all over the programming landscape the last 20 years is finally being lifted. I admit, I do dislike Java …immensely. And not only on technical grounds, but even more based on what I perceive as it’s community worshipping complexity for it’s own sake. Of course IMHO.

These days new and truly interesting languages are all over the place. Rust and Go are two examples with a lot of momentum, although I personally choose Nim over both.

And Smalltalk is still my “super productive dynamically typed” language of choice, but I just learned about a language that I really think is going places…

Adding objects to Ni!

Fri, 25 Sep 2015 00:00:00 +0000

So… Ni has almost reached the point where I can see objects appearing. The following describes the design I currently have in mind, read it and tell me what you think so I can scrap it and start over ;)

Ni design decisions!

Wed, 23 Sep 2015 00:00:00 +0000

So… my little Ni language got some attention since it was first on Hackernews , then TheRegister , all over Twitter and also Reddit .

But I think it managed to come relatively unscathed out of it, although it REALLY is pre-alpha-not-even-complete-eats-your-harddrive early and you know, I really have no idea if it ever will go the distance since it takes quite a bit of work to get a language to actually be used. But I am going to stick with it.

Anyway, I have been experimenting with “arg words” and “lookup scoping” while thinking about how to add objects, and a few other things. This article doesn’t introduce how I want to do objects, but the next one does (I split it in two). This article however covers a bunch of loose ends and my ideas on how to tackle them in Ni. And I will try to make this understandable even if you don’t know Ni. ;)

Guts of Ni

Tue, 22 Sep 2015 00:00:00 +0000

This article describes some core parts of the current implementation of the Ni (now known as Spry ) language. It’s not a tutorial, introduction or manual. It’s in fact kinda incoherent - but so is Ni :)

Who says Ni?

Wed, 16 Sep 2015 00:00:00 +0000

Ni is my own little language heavily influenced by Smalltalk but also other sources like Rebol, Forth, Lisp, Self and Nim. Ni is a bit strange, but it’s not academic and really meant to become something useful.

So put on your helmet and let me take you to the shrubbery…

Nim and super

Wed, 06 May 2015 00:00:00 +0000

As I described in the earlier posts Nim didn’t support “super calls” when using methods instead of statically bound procs and generics. My article caused a little bit of discussion around this on IRC and Andreas decided to implement the mechanism he already had planned - but had not fully decided a good name for.

The other day Nim 0.11.2 was released and it includes this mechanism. Let’s have a look how it works in my sample code…

Nim

Thu, 26 Mar 2015 00:00:00 +0000

Having been a die hard Smalltalker since 1994 I have finally found a new language and community that I am investing myself in. All the Ruby, Python, various JVM languages, C# and Mono etc - none has managed to capture my interest. Ruby and Python always felt like pale shadows of Smalltalk and I really don’t want to be tied to the Java eco system, no matter what. And so on and on, lots of languages looking interesting but not being able to withstand my deeper look. As a Smalltalker I probably have acquired a particular taste.

Since a few months I am however deeply into Nim. I have written a slew of articles about Nim, and at our company we have decided to bet hard on it. So far I have written a little utility called blimp in Nim, and I have helped creating Urhonimo - the Nim wrapper of the Urho3D game engine.

With a deeper understanding of Nim, although I am far from good at it, what is it that makes me recommend you to try it?

Nim visits GTUG Stockholm

Thu, 26 Mar 2015 00:00:00 +0000

Yesterday I had the pleasure of presenting the programming language Nim at the Stockholm GTUG . This evening we were around 50 people, I would guess mainly developers, listening to three presentations:

Rust , by Johan Burell, EVRY
Nim , by Göran Krampe, 3DICC
Go , by Marcus Olsson, Citerus

Now, that’s a pretty fitting trio of languages! :) This article is a little followup because I failed to mention so much stuff…

Nim seq

Wed, 03 Dec 2014 00:00:00 +0000

One of the most important aspects in a language is how powerful and easy it is to use its collection/container types. At least that is my feeling coming from Smalltalk where the Collection classes and their rather rich protocols are used extensively and also cover String and Array and much more. If you peek into the current leading open source Smalltalk - Pharo - you can see Collection allSubclasses size evaluate to 78. Of course, lots of those are special subclasses and not for general use, but fact remains that a strong language needs a strong library of good collections.

In Smalltalk I can for example run this:

#(1 2 3 4 5) select: [:x | x isOdd ] thenCollect: [:x | x * 3 ]

This is actually a single method call taking two closures, one to perform a “filtering”, and one to perform a “map”. This is not a standard message in “good old” Smaltalk-80, but it has eventually been added since the usage pattern is so common. To me personally a modern language needs similar power or I would go nuts. :)

Nim and OO, Part IV

Sun, 30 Nov 2014 00:00:00 +0000

The other day this mechanism entered the devel branch which means it will be official in the next release of Nim, which I suspect will be out before the end of 2014. It should be noted that devel is mainly undergoing bug fixing, so unless you are paranoid it’s pretty usable. Now… of course I had to try out super calls in my sample code…

Squeak to Nim, come in Nim...

Mon, 03 Nov 2014 00:00:00 +0000

In my exploration of Nim the turn has come to see how we can use Nim together with Squeak .

Squeak (and Pharo) has two basic mechanisms of interfacing with the C world:

Squeak VM plugins . That pdf is old, but still fairly accurate I guess.
Squeak FFI , Foreign Function Interface.

The VM plugins are basically a controlled way to introduce new “named” primitives in Smalltalk that can be invoked from Smalltalk. A plugin can be built either linked into the VM binary (statically) or as a dynamically loaded library (dll, so, dylib etc). When “all else fails” a plugin is the way to go, but they are a bit awkward to work with.

Then we have the FFI which is a generic way to dynamically call dynamically loaded libraries. In other words, no compilation step needed - just type the correct Smalltalk line and the library will load and the calls work. Now… sure, the FFI mechanism is a bit slower, since it needs to look at arguments and make the proper type conversions for the call. But the FFI is heavily used in the commercial Terf system, in fact, all the OpenGL calls are done through it. So its quite proven, and not that slow.

NOTE: There are in fact several FFIs today, the old one, the one called Alien and Pharo is brewing a new one called UFFI.

Let’s see if we can use the good old FFI with Nim.

Nim and OO, Part II

Fri, 31 Oct 2014 00:00:00 +0000

In the previous article when I explored OO mechanisms in Nim I felt I dropped the ball a bit in my Fruit example. This is a followup.

In that article we first implemented some Fruit “classes” mixing methods and procs. Then I presented a cleaned up version using methods only, and a teeny template in order to reuse a base method. This template was needed since Nim currently doesn’t have a “call-next-method-matching” for multimethods like Dylan or CLOS have. This is being discussed and I think all agree that there needs to be some mechanism so that you can call a “next lesser match” of all matching multimethods.

But I also wrote that the example can be written perfectly well using generics and procs only, thus ensuring static binding and maximum speed. But the “super call” problem also existed for procs, and the template hack was just a hack. After more experimentation I now think I found the proper Nim way to do this so let’s take a look…

Nim and OO, Part III

Fri, 31 Oct 2014 00:00:00 +0000

So previously in Nim and OO Part II we saw how we could solve the “super call” issue using only procs and generics in Nim . This means that all code is statically bound.

But if you have read all these article you know I also tried the more appropriate mechanism for OO - so called methods. In Nim a proc is a regular statically bound function, simple and fast. A method on the other hand uses dynamic multimethod dispatch on the runtime types of all object parameters. The easy way to do objects in Nim (with inheritance of behavior) is using methods - but of course, this means dynamic lookup that has a runtime cost, but quite small as we will see.

Time for benchmarking!

Ubuntu Just Works

Thu, 30 Oct 2014 00:00:00 +0000

A friend of mine is having a less optimal experience with Linux, and I realized I could jot down my experience for the last few years.

I have been using Linux on my desktop for a long time now, about 10 years I think. Early I played “distro jumping” and used Lunar Linux for quite some time on my older Zepto laptop.

But at some point I just decided that, nah, source distros are huge time sinks. Not necessarily because they have issues, but because they are fun to tinker with. I also felt it was “smarter” to know a mainstream Linux well, so I decided to go for “least friction”, and moved to Ubuntu. When Unity hit I did contemplate using something else, at least an alternative shell, but decided to just “hang in there”, and now I tend to like it. Recently I upgraded to Ubuntu 14.04 LTS , it was pretty eventless.

Nim and OO

Wed, 29 Oct 2014 00:00:00 +0000

Nim is presented as an imperative language. And yes, it has some of its roots in the Pascal line of languages, but it also has a set of powerful abstraction mechanisms making it very suitable for object oriented programming. And when I write “object oriented” I am referring to a broader flexible sense of OO in which objects can be formulated with attached behavior, polymorphism between different objects, some kind of reuse model of code (inheritance etc) and some type of dynamic dispatch.

Since I am a long time Smalltalker that is my main reference for “good OO” and not the … monstrous OO often seen in Java or C++. Its hard to explain the differences, but let me just say that OO in Smalltalk is elegant and natural, very much like in Ruby or Python - but ever so more streamlined. Smalltalk is a dynamically strongly typed reflective language with a heavily closure based style.

In this article I will try to make “sense” out of how to do OO in Nim.

Nim Socket Server

Sat, 25 Oct 2014 00:00:00 +0000

In learning Nim I decided to implement a trivial Socket server, very small, as an example. Its not a useful HTTP server (it just returns a hard coded HTTP response so we can benchmark it using HTTP tools), and its not async - there are other such examples in the Nim examples directory and in its stdlib. No, I wanted to write a more classical threaded socket server to see how easy that is - especially with the new APIs in Nim “bigbreak” - and see how it performs.

The new “bigbreak” branch that will become Nim 0.10.0 soon-ish has a bunch of new stuff in the networking area. Its replacing the single sockets module with a low level rawsockets module, and a higher level net module. And there is a new selectors module that abstracts over different modern IO polling mechanisms. This means that a single API will use epoll on Linux, kqueue on BSD/OSX, old select on the other Unices and IO Completion ports on Windows. At the moment epoll, select on “other Unices” and IO Completion ports works. kqueue is on the todo.

So without further ado…

I missed Nim

Mon, 20 Oct 2014 00:00:00 +0000

A year ago I wrote an article trying to round up new languages since year 2000 and what I think of them by just… glancing at them, or otherwise playing with them. I ended up sifting out the 4 most interesting in my not so humble opinion - Go , Rust , Dart and Julia . Now a year has passed and…

I discover that I missed Nim(Nimrod)!

Nim was born somewhere around 2006-ish and is clearly a very serious language to consider, but is going suspiciously under the radar. Having reviewed this language more closely (and still doing so) I can safely say that for me it actually easily tops this list.

I have already posted a few articles about Nim , but this one is meant as a followup to that article trying to make amends :).

NOTE: Technically Nim is still called “Nimrod” up to and including the 0.9.6-release that was done yesterday . But for the upcoming 0.10.0 and onward its Nim. Short and sweet.

Nim wrapping C

Thu, 16 Oct 2014 00:00:00 +0000

Nim has all the language mechanisms needed to smoothly interoperate with C and C++. The rather large collection of wrapped C libraries (and that’s only those in the standard libs) is also a testament to this fact. In this article I explain my personal findings testing out the waters of wrapping a simple C library.

The basic approach to wrapping a simple C library is:

Install Nim.
Install c2nim using Babel or manually clone c2nim from github and build it.
Use c2nim to translate the C header file(s) to a so called Nim wrapper.
Make a small test showing it works.
Write a so called “impure” intermediary library that uses the wrapper (next article)
Make a test green and declare Victory (next article)

Okidoki… (roll up sleeves)

Bootstrapping Nim(rod)

Wed, 15 Oct 2014 00:00:00 +0000

Technically Nim is still called Nimrod up to and including upcoming bugfix version 0.9.6. But then with the next version 0.10.0 it will be just Nim. Currently Nimrod is at 0.9.4 . And oh, the current development version is 0.9.5 which will become 0.9.6 when released - the “odd and even” versioning scheme.

Nim can be a bit funky to get started with, typically due to a slight lack of documentation in certain areas that may be obvious to Nimmers (or Nimsters? Knights who say Nim?). This article tries to fill a few mental holes in the first steps.

Also, Nimsters like to do it in Nim - and often the reasons for this are very good, like maintaining portability or minimizing dependencies. Just don’t expect the classic autoconf dance here. As a Smalltalker I am fully versed in the NIH syndrome - which of course doesn’t always have to be a bad thing. Thankfully Nimmers also seem to balance it with a strong tradition of standing on the shoulders of giants .

So building Nim isn’t hard, but it’s also not obvious what is going on. There are of course binary installers available too, but hey, we want to hack!

Cog vs LuaJIT2

Mon, 13 Oct 2014 00:00:00 +0000

In the open source Smalltalk community we have a pretty fast VM these days - its called Cog and is written by the highly gifted and experienced Eliot Miranda who also happens to be a really nice guy! Cog is fast and its also still improving with some more developers joining recently.

Another very fast VM is LuaJIT2 for the Lua language (version 5.1), also written by a single individual with extraordinary programming talent - Mike Pall. LuaJIT2 is often mentioned as the fastest dynamically typed language (or VM) and even though Lua is similar to Smalltalk (well, its actually very similar to Javascript) its also clearly a different beast with other characteristics. If you start looking at the world of game development - then Lua appears everywhere.

Here Comes Nim!

Mon, 13 Oct 2014 00:00:00 +0000

I just posted an article comparing some silly benchmarks between Cog Smalltalk and LuaJIT2. Now… let’s take a look at one of the latest “Cool Kids” on the language front, Nimrod - or as it has been renamed - Nim .

ESUG in Annecy Day 4

Thu, 12 Sep 2013 00:00:00 +0000

It starts off with Cincom, Arden Thomas presenting their roadmap. He had a slide mentioning Jules Verne and I must ask him if he is aware of the influence from the books of Jules Verne - as Dan has explained, the ballon and the island in the classic Smalltalk logo comes from the Mysterious Island book .

ESUG in Annecy Day 3

Wed, 11 Sep 2013 00:00:00 +0000

Day three blurred a bit for me - lots of mingling and hacking intermixed with some nice presentations, but I missed quite a lot, I admit, like the presentation on new native UI stuff in VisualWorks and the tODE stuff from Dale Henrichs.

ESUG in Annecy Day 2

Tue, 10 Sep 2013 00:00:00 +0000

Another day in IAE Universite Savoie Mont-Blanc in Annecy.

Only writing about stuff I attended :)

ESUG in Annecy Day 1

Mon, 09 Sep 2013 00:00:00 +0000

Here we go! Time for a week of Smalltalking fun in IAE Universite Savoie Mont-Blanc in Annecy.

While ESUG this year is not super big, I think around 110 people or so, there were still quite a few arms raised when checking how many were here for the first time. The organisation seems impeccable, as always - thank you Stéphane Ducasse, Herve Verjus, Laurent Laffont and of course all volunteers!

Enough chit-chat, let’s get on with the talks…

New Languages After 2000

Sat, 07 Sep 2013 00:00:00 +0000

I am sitting in a gate on an airport waiting to go to ESUG so I felt I should finally get this article out the door. In a presentation earlier this year I asked what has happened in the programming language area since year 2000? Not much I felt and I couldn’t really name any interesting new language when thinking about it. But then I decided to look more closely and I can conclude I was at least partly wrong :)

So prepare for a long (too long) article digging through a whole bunch of languages trying to come up with the answer - Have any interesting programming languages appeared since year 2000?

(And at the end, how is the Smalltalk community doing?)

RethinkDB - Yet Another NoSQL?

Tue, 16 Jul 2013 00:00:00 +0000

15-18 years ago my passion was in OODBs. As a Smalltalker GemStone was one of the most fascinating to work with, but as we all know OODBs never got really popular, despite their fantastic qualities. But the new NoSQL databases in many respects offer OODB-ish characteristics, although they of course also bring a whole new menu to the table.

In my eternal quest for “database bliss” my next stop is RethinkDB , but let me tell you how I got here.

Going virtual from CLI

Mon, 21 Jan 2013 00:00:00 +0000

Recently when I automated a development process I looked deeper at managing virtual environments and ended up using two really nice tools complementing VirtualBox in a slick way - Vagrant and Veewee . A lot of us use VirtualBox of course, but getting a new Ubuntu box up is still a bit of blablablabla… What if it could be done all from the command line and easily automated?

HyperDex on Ubuntu 12.10 from source

Wed, 16 Jan 2013 00:00:00 +0000

So ok, I really like looking at new interesting NoSQL databases. Up until yesterday I felt Riak was the most interesting one (have also coauthored Phriak - a Riak binding for Pharo Smalltalk ) but after an evening of discussing choices of key/value backends for the Oak project I decided to “google a bit” and stumbled upon HyperDex .

New SSD for my Lenovo X220

Thu, 10 Jan 2013 00:00:00 +0000

After the conundrum with my Intel 320 SSD I did some googling and decided to invest a fair chunk of money in a really good SSD - the Samsung 840 Pro, 512GB . The 840 Pro seems to be the king of the hill right now and it’s only 7mm thick which is what I need for my X220 (although people have shoved 9mm drives into it with a bit of force).

Moving to SmalltalkHub

Mon, 07 Jan 2013 00:00:00 +0000

As a long time Squeak/Pharo (Smalltalk) developer I have accumulated a set of packages that I have written or co-written and that have been published open source for others to use. Since quite a few years SqueakSource has been the natural hosting place, but it has reached the end of the road and it’s high time to move on .

Never an Intel SSD again

Wed, 02 Jan 2013 00:00:00 +0000

When I bought my Lenovo X220 - which I have been extremely pleased with to date - I chose an Intel 320 160Gb SSD disk with it, in retrospect a BAD MISTAKE. No idea why I didn’t find the warnings plastered all over the net at the time, and the problem was even acknowledged by Intel as early as july 2011 . The disk has been working fine since april when I got it, until the last day of 2012…

Oak

Sat, 29 Dec 2012 00:00:00 +0000

In a customer project right now I need to be able to work and evolve code fast, with a relatively complex model. And by fast I mean that I want to cut away as much as possible of the efforts related to persistence. Generally this is what OODBs excel at.

In the Squeak world we have GemStone (commercial), GOODS and Magma as “full fledged” OODBs. Last century :) I worked with GemStone (both Gemstone/S and /J) and its a great product - but I want something lightweight and open source. And simple. And hackable. And new. :)

I also used Magma in the Gjallar project, and while I respect it highly - this time I want to try something with an “externally supported backend”. I also had a mixed performance experience, but this was “pre Cog” and Magma has also surely evolved lots since then, and I am not sure we did everything the way we should have either.

SandstoneDB could also be interesting to look more closely at, but since I have been working with Nicolas Petton on improving Phriak (Riak interface for Pharo) it was natural to take a look at one of his “under the radar” projects - Oak , an “OODBish” solution on top of Riak. At this point I have been doing much more than looking, in fact I am hacking on it! And oh, yeah, of course there are lots more persistence options available too.

Moved from Wordpress to Octopress

Thu, 27 Dec 2012 00:00:00 +0000

So… I kinda got tired of Wordpress. A bit too much for me, I want something more lightweight that “just works”. I also stumbled over some blog that had just moved over to Octopress and made it sound like “da shit” for coders. So be it! And so far so good.

In short I did an XML export from inside Wordpress admin, created an account on Disqus, added the disqus plugin for Wordpress, exported over all comments, then “git cloned” Octopress onto my laptop, used exitwp (from github) to migrate my XML file from Wordpress, used rsync deploy over to my server and adjusted config in Octopress to use disqus (and thus pick up all old comments).

Literal arrays vs JSON vs STON vs Tirade

Tue, 08 May 2012 00:11:22 +0000

Recently there were a range of threads on the pharo-dev mailinglist discussing the textual format to use for Smalltalk source code metadata. The discussion veered off from the specific use case but basically four different formats were discussed and compared, of which one I am the author. And oh, sorry for the formatting of this article - I need to change theme on this blog for better readability.

Going Lenovo...

Sat, 14 Apr 2012 01:02:06 +0000

When I started my own company about a year ago I ended up buying an ASUS G73JW gaming laptop - I took a deliberate decision to focus on raw power for decent money and totally ignoring portability. Generally it has served me well, although it does tend to make a lot of fan noise, at least under Ubuntu. It might work smoother in Windows, but I seldom boot into Windows.

Needless to say though it is a real ton of bricks (8.8 lbs = 4 kg) and including the truly fat power supply it simply weared my back down during 2011. I have been carrying this beast in a backpack every day - and my body eventually said “enough dammit!”. :)

Current Smalltalk obsessions...

Tue, 07 Feb 2012 00:15:10 +0000

These days I am, as usual, torn between several interesting technical projects.

Amber Link to heading

The new Smalltalk called Amber (by Nicolas Petton) that compiles to javascript is pretty awesome and there are tons of interesting things one can do with it. My contributions so far include the beginning of a package model, a faster simpler chunk format exporter/importer, a command line compiler, a Makefile system so that Amber can be built fully from the command line and a bunch of examples running on top of Nodejs and webOS , and a few other odds and ends.

ESUG day 4

Thu, 25 Aug 2011 16:50:52 +0000

This day started with some stress, Nicolas and I whipped up the last details of our co-presentation on Jtalk (Nicolas decided to skip Iliad ) - and my Eris demo suddenly got b0rken. But I managed to fix it and our presentation was very well received - it was great fun!

Nicolas managed to do quite a few “on the fly” demonstrations of various Jtalk snippets etc, and running the slides in Jtalk was of course a killer thing. I explained how jtalkc is being run on top of Node.js and quickly proceeded into showing the TrivialServer demo in Node.is - when Apache benchmark showed 1800 requests/second there was a spontaneous applause. :)

ESUG day 3

Wed, 24 Aug 2011 10:07:30 +0000

Suddenly it is Wednesday and we are already on day three at ESUG - a superb software developer conference focused on Smalltalk . Time flies. Yesterday I mainly hacked together with Nicolas Petton on Jtalk , really fun, unfortunately I missed a few interesting presentations, like Fuel and Bifrost etc.

This day starts with Stéphane presenting “Humane assessment”. Mmm, got distracted by my Touchpad, but Stéphane is showing some cool visualizations right now, clearly useful for large systems and organisations that need understand their own “huge legacy software”. Hehe, the browsers shows visual queues on “bad designs” like marking methods as “BrainMethod” or marking a class as “God Class” - that is indeed very slick!

Touchpad finally in my hands, first day

Tue, 23 Aug 2011 23:42:35 +0000

Sooo…. I actually managed to order a HP Touchpad 32Gb here in Edinburgh to be picked up at Comet within 48 hours. I ordered when it was still a whopping 429£, but when I went to pick it up I got it at the UK discount price of 115, and I will get the VAT back too.

The first hours were frustrating because I was in the ESUG conference and we only had a WiFi with a so called “captive portal” with a login form - and the first time you power up a Touchpad it wants to hook up to a Palm Profile, and does not want to do that using a WiFi with a captive portal.

ESUG 2011 in Edinburgh

Thu, 11 Aug 2011 11:59:57 +0000

Each year I try to attend at least one developer conference. Earlier OOPSLA was a given but it lost its appeal quite a few years back and now it is not even called OOPSLA anymore. As a die hard Smalltalker I instead attended the ESUG conference in Brest 2009 and it was easily the most rewarding conference I ever have attended! Missed last year in Barcelona but this year I am going to Edinburgh for a week of Smalltalking.

WebOS 3.0 is coming - with Enyo!

Sat, 09 Jul 2011 01:27:37 +0000

A few weeks ago I joined the Early Access program that HP/Palm has been offering for a while and I have been toying with the new WebOS 3.0 (SDK with emulator) that appeared in public on the 1st of july when the HP Touchpads hit the stores in the US. Since a week I also have a Palm Pre 2 phone running WebOS 2.1, hopefully to be upgraded later to 3.0.

Konsten att måla ett drev, del 2

Tue, 17 May 2011 13:27:34 +0000

Dags för andra delen i artikelserien om att måla ett drev. Första delen avhandlade mest teori om målningsprocessen. Nu är det dags för avmontering av drevet från skölden samt applicering av färgstripper.

Demontering Link to heading

Dags att börja meka. Min ambition är att komma åt det mesta av drevets delar utan att gå så långt som att plocka isär det i alla sina beståndsdelar. Köpte Selocs manual - “Volvo Penta Stern Drives 1992-2002 Repair Manual” - från www.drev.se (finns en från Clymer också, vet ej vilken som är bäst) och följer instruktionen för att plocka av drevet.

Konsten att måla ett drev, del 1

Sun, 01 May 2011 23:40:39 +0000

Vi som kör inombordare i våra båtar har typiskt drev från Volvo Penta eller Mercruiser. Dreven är av aluminium, eller typiskt någon sorts aluminiumlegering och att måla aluminium är en tekniskt sett mycket intressant process och de flesta som gjort detta kan säkert vittna om att det inte funkar så bra, färgen lossnar helt enkelt efter ett tag. Det verkar gått så långt att många helt enkelt inte ens bryr sig om att försöka bygga upp en korrekt målning utan istället slänger på lite primer och antifouling direkt på aluminiumet och får göra om samma visa efter nåt år!

Tirade, supporting embedded text

Fri, 15 Apr 2011 01:22:58 +0000

Two years ago I ended up creating Tirade - a new “file format” for Smalltalkers. Or rather, a way to serialize stuff into a sequence of Smalltalk messages with literals as arguments. I have written a few blog articles about Tirade so I will not go into details in this one.

One thing that has been disturbing with Tirade is that I wanted it to be the main format for serializing Deltas, the new implementation of “21st Century ChangeSets”. This means I want Tirade to handle Smalltalk source code in the best possible way. Ideally I would want the Tirade file to be editable in a text editor if I wanted, and not being broken by that.

Preaching Smalltalk inside a nuclear reactor

Fri, 08 Apr 2011 12:07:35 +0000

…is what I did yesterday. It was the Stockholm GTUG group having a loose and laid back meetup in a rather special venue - R1, Sweden’s first nuclear reactor ! 27 meters below ground, kinda… funky.

Anyway, I tried doing an ultra compact version of several of my other presentations around Smalltalk and Seaside - didn’t really go 100% since I both had some technical issues (keyboard problems and projector issues too) and ended up taking more time than was planned. Hopefully noone got upset about that.

Node.js vs Nginx/Squeak, part 1

Mon, 14 Mar 2011 16:55:58 +0000

Hmmm, after seeing the Node.js presentation at Dyncon 2011 I couldn’t help installing Nginx and Blackfoot (SimpleCGI) in a Squeak 4.2 image running on the Cog VM to make some performance tests! In fact I started doing that during the presentation. :)

My first run on Nginx/Squeak looked quite unimpressive. Well, one client doing 1300 req/s to a small helloworld was decent although Node.js handled approximately 2x that. With Nginx we have a two tier solution so a factor of 2 is not really surprising in this trivial case. Top showed similar load, both solutions only seem to consume 8-9% of my CPU power on this box, but the Nginx/Squeak solution of course spreads load between them with approximately 1/3 or 1/4 on nginx.

Dyncon 2011, retrospect

Mon, 14 Mar 2011 16:45:51 +0000

So it’s monday and I am getting started with work but thought I should try writing a retrospective of Dyncon 2011 during the day. In summary it was a nice and largish crowd (about 85), a spacious and good venue in the middle of the city (office of BWin/Ongame) with a great view from the 11th floor and a good lineup of speakers . Perhaps I am getting old though but having this many speakers doing 40 min presentations for two full days… well, I kinda like to have time to sit down and chat with people and show stuff and so on. Not much time for that, and 40 minutes means that most presentations got stressed for time even though flying on a rather high level. But still, a fun and interesting conference!

Dyncon 2011, day 2

Sun, 13 Mar 2011 14:04:11 +0000

Day one must have ended with lots of beer because people were quite late for day two. 15 minutes late Carl Lerche finally started his Ruby presentation. One thing I found interesting was Ruby Modules vs Monticello extension methods (in some ways I presume this is how Modules are often used - to extend other classes with behavior). Evidently “method extensions” to the class side in Ruby doesn’t work like extensions to the instance side, it does in Smalltalk of course :). Then Carl described ways to still do this, but it looked complex, and also explaining there are lots of “hooks” when messing with the MOP. Is that a good thing? If Rubyists use this a lot, then I presume utter hopeless confusion might occur.

Dyncon 2011, day 1

Sat, 12 Mar 2011 11:48:57 +0000

In place at Dyncon 2011 at Bwin/Ongame in Stockholm. Quite a nice crowd and the day was started with Joe Armstrong presenting Erlang . I had never seen Joe speak before and it was a fun and interesting presentation, although of course only “skimming” some areas. I found it fun that he referenced Alan Kay where he stressed that “it’s the messages”, given his earlier harsh view on OO. I couldn’t help starting to think about how some of Erlang’s concepts could easily be implemented in Smalltalk and what that could give.

No more coppar!

Fri, 26 Nov 2010 11:58:32 +0000

Our ADSL broke a week ago and the operator decided to NOT repair it, since they can’t see the economy in doing so.

After pondering the options I decided to try 3G all the way. Since I already have a Telia USB modem (Option icon 505) I just needed a good wifi router that can use it.

Ended up buying a Dovado 4GR , really simple to set up and to upgrade firmware in. It is important to try different locations in the house though, got 3x more speed near the window on the second floor.

Skype interview with Dan Ingalls

Fri, 10 Sep 2010 08:49:54 +0000

Before the summer I had the opportunity to do a Skype interview with Dan Ingalls , the “Guido/Larry/Linus” of Smalltalk.

The interview was part of a guest lecture I did at DSV for the DYPL course (dynamic programming languages) held by Beatrice Akerblom. In the end I only used a smaller quote because most of the topics in the interview ended up being more interesting to “true believers” than to Smalltalk newcomers.

Making a Skype interview...

Fri, 07 May 2010 14:00:08 +0000

I got the opportunity to make a Skype interview with Dan Ingalls , so I decided to try to record it. Had no idea it was not as easy as a “press record”-button. I am on Ubuntu, Karmic Koala. First of all I had serious trouble getting proper sound working with Skype, I ended up following the HOWTO in order to install Skype 2.1 beta - which uses PulseAudio ONLY. That took care of that issue, after a bit of fiddling in the “Preferences” dialog you get when right-clicking on your volume applet :)

Joe is wrong

Fri, 26 Jun 2009 17:12:06 +0000

I just read Joe Armstrong’s old “Why OO sucks” article , Joe Armstrong being the inventor of Erlang . Granted, the article is from year 2000 I think, so perhaps I should cut him some slack… nah! :)

First of all - no, I haven’t programmed in Erlang (yet), but quite a lot of other programming languages. My favorite language is the grand father OO language - Smalltalk . So sure, I am biased in favor of OO.

Tirade, first trivial use

Mon, 20 Apr 2009 00:43:55 +0000

Last night I started hooking Tirade into Deltas. Quick background: Deltas is “Changesets for the 21st century”, or in other words an intelligent patch system under development for Squeak. Tirade is a Smalltalk/Squeak centric “JSON”-kinda-thingy. I made Tirade in order to get a nice file format for Deltas. Just wanted to share how the first trivial code looks, and thus illustrate simple use of Tirade.

I have a DSDelta (a Delta being almost like a ChangeSet). It consists of some metadata (a UUID, a Dictionary of properties and a TimeStamp) and a DSChangeSequence (which holds the actual DSChange instances). As a first shot I only implemented the metadata bit. So step by step:

Tirade, part 2

Fri, 20 Mar 2009 00:34:07 +0000

In an article recently I described Tirade - a new generic “file format” for Smalltalk/Squeak, or actually a sub language! Since that article I have refined Tirade a bit. Tirade consists today of 4 classes (parser, reader, writer, recorder) totalling about 500 lines of code, excluding tests. Tests are green in 3.10.2, pharo-10231, 3.9, 3.8 and 3.7. It does turn red in 3.6 due to old initialize behavior, some missing methods etc, probably easily fixed if anyone cares. There are no dependencies on other packages. Compared to using the old Compiler»evaluate: it is about 5-7 times faster.

Tirade, a file format for Smalltalkers

Mon, 16 Mar 2009 00:24:07 +0000

In my revived work on Deltastreams in Squeak I ended up facing the choice of native file format for Deltas. Matthew has made an advanced format called InterleavedChangeset which manages to squeeze a binary representation of a Delta into a Changeset file (which is in Smalltalk chunk format). An impressive feat, and it has the advantage of being backwards compatible in the sense that a Delta in this format can be filed in as a plain old Changeset into an old Squeak image.

Thu, 01 Jan 2009 00:00:00 +0000

The guts of Ni Link to heading

This article describes parts of the current design and implementation of the Ni language. It’s not a tutorial, introduction or manual. It’s in fact kinda incoherent - but so is Ni :)

The parser Link to heading

The Ni parser is a straight forward hand made ~~recursive descent~~ parser. Hmmm, now that I look closer I realize its not recursive! Its just a very simple while loop character by character and maintaining some state. It should be easy to read and understand and given that the grammar is so simple, it hasn’t changed much lately. It could probably be made faster by using more procs and less methods, but it’s probably plenty fast since the grammar is so simple.