a .NET hosted scripting language with a focus on meta-programming and embedded DSLs
New Prexonite version: (Release v1.90 on GitHub (src+bin)) The first step on the way to Prexonite 2, which is defined by three rather large features: Shared code The Prexonite 1.90 runtime and compiler support sharing in-memory code with multiple applications. This in and itself may sound rather dull, as it...
Ever since I moved Prexonite to its mercurial repository at assembla I’ve been a bit jealous at open source projects over on GitHub. GitHub is just a nicer web site and while assembla has a very powerful issue tracking system, but as a solo developer it was maybe a bit...
Over the course of the last week, I transferred my main project, Prexonite, to GitHub. I’ll write more about this adventure of epic proportions later. For now, enjoy this hand-ported article from my personal blog: Prexonite 1.2.3 — Best Friends Forever.
I was tempted to just skip this silly version number, but here we go: I humbly present to you (No, I couldn’t resist :3 ) As always, Prexonite release 1.2.3 comes with Prexonite v1.2.3 binaries Prexonite v1.2.3 source Sadly linux-compatibility didn’t make the cut, so Prexonite still only builds on...
Mercurial For 1.2.1 I switched my version control system from Subversion over to Mercurial, still hosted as an open source project at assembla.com. Subversion is great but for me there are some benefits in using Mercurial. Easier than Subversion I personally find Mercurial easier to use than Subversion, even though...
Over a year ago I considered the implementation of meta programming facilities in Prexonite Script. In that post, I concluded that advanced meta-programming features like quotation and splicing were not realistic for a compiler architecture as convoluted as Prexonite. I, however, think that the implementation of macro functions is feasible...
Yesterday, I watched the Google TechTalk presentation of the programming language Go (see golang.org). Even though I don’t believe Go will become very popular, there was one aspect of the language that "inspired" me. One of Go’s major advantages is the fact that concurrency (and coordination thereof) is built deep...
As a small experiment on the side, I built a little toy-compiler in Haskell that takes in a program in a very simple lambda-calculus-like language and translates it into Prexonite assembly. The following program computes the factorial of 9 using only function application. In order to make this work, we...
The idea of implementing a macro system in Prexonite Script was inspired by reading an article on lambda-the-ultimate.org about Converge. I realized that with a powerful API like that of the Prexonite compiler, it might be possible to implement similar features. The basic idea would be to have a new...
Downloads1 Prexonite March 09 January 10 Sources Prexonite March 09 January 10 Binaries New this time around is the very small but useful addition of shadow ids, a feature not entirely unlike the concept of shadowing in C#, thus the name. Imagine you are working with two comparatively complex libraries,...
Downloads1 Prexonite Nov 2008 Sources Prexonite Nov 2008 Binaries While Prexonite Script does not formally provide any means of object-oriented programming (not just consuming objects but actually defining new ones) there are mechanisms in Prexonite (the runtime) that try to make up for this. What Prexonite includes so far The...
Downloads1 Prexonite Nov 2008 Sources Prexonite Nov 2008 Binaries Update There have not been any significant changes since the introduction of the CIL compiler into the Prexonite, yet the current version comes with a number of performance optimizations regarding the generated CIL byte code. The majority of the built-in commands...
In the last article, I presented the Prexonite CIL compiler and the huge performance improvements it comes with. Unfortunately, the compiled code has to be dynamically typed as the CIL compiler does not perform any data flow analysis and can therefore not possibly infer the correct types. It does not...
Just look at the two snippets below. ldloc.1 ldc.i4.5 add stloc.1Listing 1: a = a + 5 in CIL assemblerldloci 1 ldc.int 5 add stloci 1 Listing 2: a = a + 5 in Prexonite assembler Above you see one snippet with four CIL assembler op codes, and a second...
Over the last few days, I've been working on two things: the reorganization of built-in commands and the improvement of the "Functional Experience". Why do commands need reordering? Because it gets difficult to find the right file among over 40 commands. Why the sudden increase in numbers? I added proxies...
This is the second article in the "Philosophy Behind"-series, picking up a specialty of one of my projects and explaining how it came to be made. Last time I wrote about the "auto dereferencing" concept in Prexonite Script. In today's article I will explain the reasons behind the design of...
I just committed pushed the collection helper functions I call █████████ ████████ █████████ (psr) to SVN GitHub. Following is a short documentation (or rather an overview) of psr: The psr is a collection of scripts that help in day-to-day hacking with Prexonite Script. This page shortly outlines the contents of...
Yesterday I published a new version of Prexonite. It sort-of replaces the fourth beta preview I had planned to ship earlier. First, though, I have to disappoint you: There is not going to be anything like tab-completion in the near feature. Prexonite fully supports Unicode and I couldn't find a...
Hey, I have added a number of neat features to Prexonite and especially to Prexonite Script. Conditional expressions function max(a,b) = if(a> b) a else b; You can also use the 'traditional' {cond} ? {expr} : {expr} syntax but it won't be as easy to read. Loop expressions function main()...
Prexonite now comes with exception handling in the form of try-catch-finally blocks. Their implementation is a bit different from the ones in C#. An no, you cannot omit the braces this time. It looks just like C# exception handling except that you have to differentiate between different types of exceptions for yourself.The syntax for throwing exceptions is equally intuitive (from a C# programmers standpoint at least).
Like the title reads: The Prexonite Scripting language and the virtual machine now support coroutines, routines with multiple entry points. They can be used to implement iterators, generators and infinite lists. coroutine map(ref f, xs) { foreach(var x in xs) yield f(x); } As coroutines exist in parallel to other...
Here it comes, the first public distribution of Prexonite. I call it a "beta preview" as it is no longer in alpha state (all major features are working; at least all unit tests pass.) but there is little to no documentation. I'm still working on both the API and the...
Like many other developers my age, I had my first programming experiences with PHP and scripting websites. From time to time, I'm drawn back to that world. This time, I built a proof-of-concept-quality infrastructure for using Prexonite Script as a web scripting language. The Host I built an HTTP application...
I'm talking about Currying, "the technique of transforming a function that takes multiple arguments into a function that takes a single argument…" With two recent additions to Prexonite (Script), it has become very easy to implement higher-order functions, including "curry" and "uncurry". With "additions" I'm referring to Closures as a...
I'm close to reaching my first milestone: Support for all common language constructs. What do I mean by "common"? The minimum requirements for the language to be useful if you want. With the recent addition of commands, the virtual machine is now complete and waits for the compiler and type...
In the last month I have not finished anything, but implemented a lot. Currently Prexonite is a working, 20'000-lines-of-code calculator library with support for subroutines. The virtual machine correctly interprets all available instructions except for static CLR calls. The application object model represents everything except parameter type constraints and commands. The Prexonite compiler recognizes only GetSet (function calls, variable assignments) and return statements; you can however write your code in Assembler if you need to.
This is the second article in the "Philosophy behind"-series, picking up a specialty of one of my projects and explaining how it came to be made. Last time I wrote about the "GetSet" concept in Prexonite Script One major element in the design of Prexonite Script is the use of...
This time I am talking about a generalization in the Prexonite Script compiler that handles the usage of symbols in expressions and statements."There must be a way to unify variable access with function and object member calls"...is what I thought. As a result the Prexonite Script syntax can treat functions like variables and vice-versa. I decided that there are two fundamental ways of interacting with a symbol: getting a value and setting a value.
One of the reasons I never liked C/++ is it's illogical pointer syntax. The star turns the type integer into a pointer-to-integer.The second one is a bit confusing. To the readers (at least mine) eye it looks like the star belongs to the identifier, modifying it somehow. Ok, it's just the result of C/++ being a freeform language so let's go on.The star turns any data type T into a pointer-to-T. So the same must be true for values; turning values into pointers to those values, right? Bad luck. The inventor of C chose to use a different symbol for returning the address of a value. Fine with me, as long as the star has no other appearances in the indirection business.
This is a translation of the german article posted at FrozenHand.A bit more than 4 months later I may still not have a prototype I could release. What I have is a working type system, an assembler and parts of the compiler and the AST/code generator.First I had a closer...