Moto 0.20.0 adds support for Operator Overloading in Moto! Overloaded operators may be declared in moto extensions and used inside Moto programs allowing programmers to write more compact, readable, and most importantly fun code! Perl programmers may now comfortably write foo["bar"] = "baz", while C++ purists enjoy the pleasure of intersecting sets with the * operator.

Instead of this:

You can now write this:

Object o = stab.get("foo");
vector.put(27,"foo");

Object o = stab["foo"];
vector[27] = "foo";

From the credit-where-credit-is-due department I should note that this release was developed almost entirely by Stefano Corsi! Be sure to send your thanks and rave reviews to him personally on the moto mailing lists!

To demonstrate this new feature many newly overloaded operators are included in the codex util extension.

Function lookup performance has also been dramatically improved leading to better performance in interpreted mode.

Moto 0.19.1 fixes longstanding compatibility issues with PHP4. There should now be no problem running both on the same server although problems may remain with the MySQL driver built into PHP conflicting with Moto's.

This release is also the first to be distributed in a binary as well as a source distribution! Stefano Corsi made the necessary makefile changes and put together the spec file allowing for the creation of packages on a variety of Linux / Unix platforms.

Moto 0.19.0 adds the first round of Higher Order Programming constructs to Moto. These constructs allow developers to use delegates and callbacks with ease through a syntax that 'Java always should have had' . Functions and methods may be assigned to variables. Functions and methods can take functions as arguments or return functions. New functions can even be defined on the fly by applying arguments to existing functions or methods!

A new documentation section on Higher Order Functions has been added here. New examples that demonstrate the power of this new syntax have been posted online as well. But real briefly:

Much else is new and improved with this release. MySQL and PGSQL driver configuration has been greatly enhanced with support for many more database distributions, and version dependencies. Problems with PosixFileIO have been fixed (the MidAfternoon Commander example should now work fine). A new variable DESTDIR has been added to the Makefile to facilitate building RPMs and other binary distributions. Many other features and fixes are also included. The full release notes are available on the download page

Moto 0.18.0 includes a number of important features serious programmers will find indispensable.
Most prominent among these is the ability to get stack traces from exceptions in both interpreted
and compiled moto code just like you can get in Java or when using gdb.

Exception thrown in evilTwo(1)(excp_trace_err.moto:9)
called from function evilOne(1)(excp_trace_err.moto:3)
called from function evilTwo(1)(excp_trace_err.moto:8)
called from function evilOne(1)(excp_trace_err.moto:3)
called from function evilTwo(1)(excp_trace_err.moto:8)
called from function evilOne(1)(excp_trace_err.moto:3)
called from function <main>(excp_trace_err.moto:12)

Don't worry, there has been only negligible impact on the performance of function calls.
Functions and methods in compiled moto apps still execute three times faster than they do in
Java (thats 10-30 times faster than they do in PHP,Perl, Python, or Ruby!)

Stack traces as well as other details of exceptions that get raised but not caught are now
output from the moto command line tool and written to the apache error logs from both the
interpreter module and mmc compiled modules. Also both the interpreter and mmc compiled modules
can be configured at runtime to catch signals raised during page execution and throw them as
exceptions (so you'll see a nice stack trace in your error log as opposed to a segfault message!)

New syntax constructs have been added to the Moto language with this release as well making programming in moto even more of a joy than it already was! Arrays can now be declared and defined anywhere from within moto code :

${ String[] happy = {"I'm","so","happy!"}; }$

Programmers can now declare variables in the initialization section of for loops :

${ for(int i=0;i<10;i++) print "So so happy!\n"; }$

A comma operator has been added allowing the code conciseness offered by compound expressions :

${ int i=1,j=1; while(i++,j*=10,i<5) print "I'm "+j+" times happier than I was a moment ago!\n"; }$

And calls to macros that take arguments can finally span multiple lines!

Many other enhancements and bug fixes have been made including major enhancements to the command line options available to mmc! There's something for everybody in this release!

Three new mailing lists have been created to help people talk about Moto! There is the users@projectmoto.org list for people who need help with programming in Moto, the devel@projectmoto.org list for anyone who is interesting in contributing to the language or writing an extension, and the announce@projectmoto.org for information about new releases.

The old moto@webcodex.com list has been retired, but the archive
is still available.

Well, Its a new year and I've decided to give the documentation website a bit of makeover. Nothing too drastic ... yet

Many new source code examples have been added to the examples
section.

For those of you who missed it moto 0.17.0 was released with little fanfare last week.
Its mainly a collection of small bugfixes but those of you who use client-side cookies
in your moto applications should definitely upgrade. Full release notes and the download
link are, as always, available on the download page.

Moto 0.16.0 adds full support for exception handling! Moto exceptions are now first class
Objects. The
semantics of the new try / catch / finally constructs is just as powerful as Java's. The MySQL database
driver has been re-factored and much improved by Shay Harding adding many new and powerful
methods to work with query results. A number of important bugs have also been fixed in this
release related to the allocation of zero length objects such as empty classes or
arrays.

Moto 0.15.0 adds support for connecting to a Postgres database. It also paves the way
for future database support by relocating all current database drivers into codex.db.XXX
extensions. Creating new extensions has been simplified so that all extension dependencies
may be listed within .i files. The documentation for extension authors has been
updated to explain these changes. Various other bugs have been fixed in the state
management subsystem and with Regex and String apis.

Moto 0.14.0 is the first moto release to really differentiate between bytes and characters.
It includes support for an new byte datatype. It adds several new language features
and extension functions for manipulating and converting between byte and character arrays
and Strings. It adds support for retrieving file uploads and database blobs as byte arrays
and outputting / saving them correctly.

The last week has been an exciting one for the Moto development team. Cory Wright got an
article about moto accepted on apache.slashdot.org
which instantly made the 0.12.0 release
the most downloaded release to date! There were several bursts of traffic from the
posting on slashdot but I never saw the load on webcodex go above 0.00
which was nice. I also never saw moto's memory usage go above 10 megs. These were
my qualitative results. Of course the threads on the slashdot forum quickly moved to
the subject of quantitative performance results. In the hopes answering some questions
with regards to this I've started porting tests from
The Great Computer Language Shootout
into moto. The current suite of ported tests can be downloaded
from perftests.tar.gz . If you have moto installed in
/usr/local/moto then you should
be able to run a performance test with ./compile.sh <test name> in the untarred
perftests directory. These tests and test scripts I'm using are not scientific but
interesting nonetheless. I'd be very
interested in hearing about people's results with these tests and getting additional
performance tests added. Before I can convert many more of the shootout tests however it
seems moto needs something akin to a stdio extension.

Running through some of these performance tests pointed out some obvious bugs and
performance bottlenecks having to do with arrays in moto. To address these a new version
of moto (0.13.0) has been made available for download. In addition to fixing array bugs
it adds a couple spoonfuls of syntactic sugar that make it easier to copy code from
Java into moto without having to make too many changes afterwards. The code for some
of the performance tests does rely on changes in the 0.13.0 release.