2007
May 16Begun work on destructors.
Apr 22Completed LLVM target. Passed 36,000 lines of code.
Apr 14Completed restructuring to permit multiple targets. Work on an LLVM target now commences.
Apr 1Started a major restructuring to permit multiple targets, one of which will eventually be (once again) LLVM. C++ generation will not go away, however. No foolin’.
Mar 20Virtual method calls now work, but are still unusable due to a lack of ref arguments and pointer classes.
Feb 26Constructors are largely implemented, though there’s still
a major hole or two. The in, out, and in out argument mechanisms now fully
support class types. Classes without an explicit operator:=
method now have one auto-generated. Basically, object-valued expressions
now work.
Next on my list is virtual method invocation. While vtables are already being generated, using them is another matter. That requires pointers, and as pointers are class instances it wasn’t possible to make progress on this until objects were sufficiently implemented.
2006
Dec 28Work continues on constructors. What makes this task so big is that it’s dependent on object-valued expressions, which of course are not very useful if objects cannot be constructed.
Nov 21This web site is again available 24/7 on an even faster DSL connection than before.
Nov 18Cleaned up the syntax for initializing variables and fields. I was hoping to keep some semblance of C++ syntax, but in hindsight that probably wasn’t a good idea to begin with. It’s messy enough in C++, but with types being actual expressions and the existence of named constructors it becomes way too messy to make it work.
Nov 10Fields are no longer a type of method. There were just too many problems making this scheme work. See the section on fields for further discussion.
Due to a messed up ISP switch, this web site is now running off a dial-up connection and is likely to be unavailable from time to time and certainly less than speedy. Things should be back to normal in about two weeks.
Oct 28Updated the language spec with regard to constructors. I’m beginning implementation of them.
Oct 27Generic classes now work, though their usefulness is limited by the absence of implementation of other language features. It often seems that everything is dependent on everything else, but that circle of dependency must be broken somewhere.
Oct 14Vtables are now being generated (but not yet used). Started framework for genericity. Passed 30,000 lines of code.
Sep 27Simple, non-virtual method inheritance now works.
Sep 17Language refinements continue… Added stubs for two new sections on tables (1.11) and tuples (1.12). Existing sections starting with 1.11 got renumbered. Added to sections Types (1.2.4) and Comprehensions (1.13).
Sep 10Language refinements continue… I decided that the syntax for statement labels was just too ugly and changed it. It can be difficult to come up with syntax that looks nice and still parses, given all the other syntax in the language.
Sep 9Sections on pointers (1.7), integers (1.8.1), characters (1.8.3), enums (1.8.5), and subclass-based unions (1.9.1) have been overhauled.
Sep 8Added to language spec a new form of constrained genericity that tests for presence or absence of one or more member or class attributes. Additional changes taking advantage of this new feature coming soon…
Inheritance of non-methods is now working.
Sep 4Overhauled comprehension syntax to make it more functional looking, and certainly more concise.
Aug 25Attributes build, static, and instance are working. Currently working on attributes that control inheritance.
Jul 20Started working on attributes. As is usually the case, some tweaks to the language spec turned out to be necessary.
Jul 19Passed 25,000 lines of code.
Jun 8Revised the relationship between fields and methods, now that I am working on that area and found a few problems with the original design.
May 11I have decided to go back to my original design of generating C++ instead of using LLVM. Reasons include lack of proper Windows support and the unlikelihood of ever acquiring it, ABI issues with Jolt being able to use libraries implemented in C++ on any platform—even in C on Windows—and license issues when and if LLVM is transferred over to the FSF. Nor does it help that LLVM lacks support for x86_64, on which I run Unix, with no clear timetable for implementing it.
Apr 29Started work on classes.
Mar 11Added new member attribute noinherit to fix a type
safety issue with constructors, casters, setters, and operator:=
methods (sections 1.2.1, 1.3). Also added some musings on how a
“dynamic” Jolt could function, why it would be desirable, and what
gets in the way of making it work (end of section 1.12). On the coding
front, not much has happened recently but I’m getting back into it with a
long overdue overhaul of compilation error handling.
Jan 28Simple methods are now working.
There are currently discussions underway to assign the copyright of LLVM over to FSF, a necessary precondition for it to be used by GCC (also under discussion). If this happens, LLVM might get relicensed as GPL, and if that happens I might as well do so too, because Jolt will become GPL regardless. Too soon to say what will really happen.
Jan 11Local variables are now working, as well as if, while, next, and exit statements. Methods are next. Argument handling in the language spec has been updated to reflect my recent focus on the subject. Access to the source repository is now being granted to selected individuals.
2005
Dec 22I have been focused on implementing the compiler instead of perfecting the language specification for the last few months (the changes since below have been minor corrections). Simple compile time expressions are now being passed to LLVM and correctly executed.
Sep 3Language specification updated. Added comprehensions and functional style unions.
Aug 22Language specification updated. Had a moment of sanity and ditched the catch/throw statements (no, not exception handling, for those of you who haven’t read the spec yet). No real loss of functionality; the same effect could pretty much be achieved using a labelled begin statement block with a nested proc that wrapped an exit of the block, a reference to which could be passed to other procs.
Anyone who has bookmarked a section should know that some sections have been renumbered, rendering the bookmarks incorrect. I’ve tried to avoid this, but sometimes it cannot be helped.
Aug 17Language specification updated. Clarified subtyping versus subclassing.
Jun 23Language specification updated. Added ability to curry methods, and fleshed out method pointers in general.
Jun 19Language specification updated. Added reference types to the language. Also fixed table display problem with non-IE browsers that made it look like every operator had its own unique precedence.
Jun 16Language specification updated. Added else clauses to the looping statements, shamelessly borrowing from Python. It solves the problem of defining what is the value of a looping statement that iterates to a normal conclusion.
Feb 13Language specification updated. Made major changes to the section on metaprogramming, including changing its name to Metaprogramming.
Feb 8Language specification updated. Added new section describing types, and how they are not necessarily identical to classes. Also added new argument mechanism “out ref”, which allowed me to greatly simply the syntax of proc{}.
Jan 29An IRC channel for discussing Jolt has been created. Even if I’m not around, I try to keep a client present at all times so I will eventually see any messages. I’ve also created a subversion repository hosted on this web server, moving a step closer to releasing the source. For now any access requires an SSL client certificate signed by me. Committers will always need such a certificate.
Jan 15Language specification updated. The existence of method objects is acknowledged, and their class type is documented. The syntax of proc specifiers has changed. An incorrect fact about LLVM pointed out by Chris has been corrected.
2004
Dec 7I have decided which open source license to use: MPL.
Nov 21Update finally posted.
Nov 1I’ll soon be posting an update of the language specification. The major change will be the addition of keyword arguments to methods. There will be interesting synergies with other language features, in particular statement attributes. I continue to be quite impressed with LLVM, so much so that I’ve even been doing some coding for them.
Aug 2I’ve decided to target LLVM for code generation instead of C++ or RTL. LLVM is a compiler infrastructure framework created by the University of Illinois at Urbana-Champaign and released under a BSD-style license. Not only is it much easier to use than gcc’s RTL or directly generating C++ code, it also includes an interpreter and JIT module, which will come in quite handy for compile time execution of code.