Quorum 3.0 TBD 2015 (Beta 1 February 2nd, 2015)
Quorum 3.0 represents the most significant change to the Quorum programming
language since its inception and is a near-complete rewrite. When the Quorum project
first began, it was written in Java, was interpreted, and we were really just trying
to make programming a little easier. As of 3.0, the project has gone further than we ever imagined:
Quorum is now faster, robust, and written in itself. As is a long
tradition in programming language design, once a language is sufficiently powerful
to write the next version in itself, so-called self-hosting, it is a sign that
the language is becoming increasingly mature. On Quorum, we have finally reached
this milestone and will now be shifting our attention to improved library and
development environment support. Library requests to the team, or contributions,
We had a number of technical goals in mind for the Quorum 3.0 release. We highlight
some of the most significant alterations below:
Major language changes
- Quorum now uses an ANTLR 4 backend. Compiler phases in the language
are now considerably faster, thanks largely to Terence Parr's clever work.
- Quorum's type system has been significantly revised, removing
some inconsistencies and significantly simplifying tiling/opcode generation.
This approach is also somewhat more efficient than in previous releases and works for any
- Quorum's exception (called Errors in Quorum) system has been redesigned
from the ground up. In the new approach, users will always see
Quorum errors, never the Java/other equivalent, providing a unified approach.
More than this, Quorum is now much better at dealing with internal system
errors and in gathering better information about what happened at runtime.
We encourage users to try it out and give feedback on the new approach. We
would be especially open to feedback on what would help you (e.g., professionals, students)
best understand the error messages/feedback this new system is providing.
- Quorum can now generate Java bytecode directly using the excellent ASM
bytecode library. Others can use this library for bytecode generation as well.
The entire JDK spec is not supported, as we started with features specific
to the Quorum compiler, but this is quite a bit.
- Quorum's backend now supports a number of potential formats, not just
the Java Virtual Machine. In post 3.0, we plan to create a first additional
technology can be found at
quorumlanguage.com in our hour of code tutorial.
- Quorum now supports action chaining (e.g., a:b():c()).
- A significant optimization pass has occurred for programs generated in Quorum,
making programs have faster execution and bootup times under some
- Quorum is now fully written, and compiles in, itself. In other words,
Quorum 3.0 was compiled in Quorum 2.2 (and then 3.0).
- Quorum's compiler error messages have been redesigned using evidence gathered by
Lee and Ko
as a loose guide. More work is needed here, as the language and messages are different than Lee/Ko's,
but it's a potential improvement until more or better evidence is found.
Type system/variable changes
- Removed a number of cases where Quorum was being slightly "too flexible"
in its conversions between various types, especially in regard to auto-boxing.
- Fixed several issues where Quorum was making strange decisions in what it
was allowing users to do (e.g., action Test returns text would allow return false).
- Fixed issues with not being able to pass undefined values to text fields
under some circumstances.
- Fixed a couple bugs with how fields and variables were implemented in bytecode.
- Carefully adjusted the amount of type inference allowed on the inside of actions.
The value is somewhat conservative and needs to be evaluated in empirical studies.
Currently, we know of no randomized controlled trials on how much inference
- Made auto-boxing as transparent as possible, with the hopes that we can
eventually disallow use of capital letter types (e.g., Text vs. text).
- In almost all cases now, actions can be called, and chained, on primitive
values without any auto-boxing. In other words, calling actions on primitives
is quite efficient in Quorum, as values have low memory footprints, but yet still
"look like" calls to objects in other languages, even though they technically are not.
- Significantly redesigned the testing for the type system, with future improvements
in mind. Especially, we've been designing programs to auto-generate test cases
that ensure each part of the type system is properly exercised, where, importantly,
we can regenerate the entire suite if a change to the type system is made
(hopefully with corresponding evidence).
Exceptions (Error) system changes
- This system has been fully redesigned.
- In the new system, Quorum Error classes, must inherit from Error, and only Error.
The reason is due to a quirk in Quorum's inheritance system. This is a potential
issue that needs further study, but allows the runtime system to have
considerable flexibility in how it handles errors.
- Errors generated by the underlying backend are now caught and automatically
converted to Quorum style. This allows us flexibility in the system, so that
we can study aspects of it in future empirical studies. Previously, we could
not modify these internal aspects, giving us too little wiggle room
when designing empirical studies to study this system.
- Detect blocks can still contain multiple types (e.g., detect e is CastError),
but the compiler now guarantees these are unique. the Quorum 2.0 branch was
intended to work similarly, and was close, but this fixes a few edge cases.
- Detect blocks may now be rewritten to a new location by the bytecode generator.
This will not impact the semantics of a program, but we have it in the notes
in case it is confusing to someone that looks at the generated bytecode.
- Leaving off a type for a detect block makes it automatically of type Error,
which is now a catch-all for all possible kinds of system or Quorum errors. This
error is guaranteed to be written last in the bytecode generation. In other words,
any block of type Error is written last and catches any and all errors,
even if these errors were generated by the underlying virtual machine.
- Users that find a Java/other error that gives an error message that is
difficult to understand should get in touch. These issues are easily adjusted
now without changes to the compiler itself.
- Fixed a bug that caused Quorum to run forever and need to be killed if an
exception occurred in a generated program.
- Adjusted the API for the Error classes making them more consistent, generally,
and also making them conform to more modern naming schemes used in Quorum. For
example, previous studies showed the word "output" was more intuitive than "print,"
so this release changes PrintStackTrace to OutputStackTrace. Obviously, the difference
is pretty minor, but increases consistency.
- Considerably improved the stack trace information presented from errors.
- Exceptions do not now have a corresponding $Interface type, unlike all
other Quorum classes in bytecode. The reason is because of the way Java handles
exceptions in regard to its inheritance hierarchy (e.g., Throwable and below).
Control Structure changes
- If statements now properly short circuit. This was previously a bug.
- Included a number of optimizations at various points in the control
- Simplified the bytecode generation for various kinds of expressions.
- Fixed a bug in if statements that, under very rare circumstances, caused a bytecode verification error.
- Action chaining is now supported. This fixes a long-standing (and annoying) bug.
Technically, we know of no randomized controlled trial for or against this decision, but
have chosen to include it because we had intended it to be in the original spec to begin with.
- Added a number of helper actions to the plugins for primitive calls.
- Added preliminary support for the ASM bytecode library to Quorum. This initial
version is somewhat bare bones in this first release, but still is sufficient
to implement much of a modern compiler built on JDK 7 or 8. Teams interested
in using Quorum to generate bytecode that need additional support are encouraged
to get in touch, as generating bytecode in Quorum is relatively easy
(so far as bytecode writing goes).
- Added parsing/semantic analysis libraries for Quorum. Others can inherit
from these and garner full ANTLR 4 support for reading Quorum source
- All symbol tables, analyzers, and generators are public and easily modified for those
wanting to write support for Quorum into IDEs or tools, either online or offline.
- Bytecode generation/semantic analysis is now done in two-passes, which
simplifies finding/fixing bugs and the generation process compared to the
Quorum 2 branch.
- Added a new test suite architecture for compiling and running a large set
of cross-compiled Quorum programs. Currently, the system supports programs converted
- Fixed a host of minor bugs throughout the language.
- Considerably improved Quorum's automated test suite generally, giving us increasing
confidence that we are properly exercising each system. There's always more work
to do on testing, but it's a substantial improvement.
- Fixed a bug causing compiled Quorum programs to load very slowly.
- Input commands now work from the command line, but do not pop-up a window.
The window popping up behavior will be retained only in an IDE.
- Added a separate command called input, with no parameters, which allows
the user to request input without outputting information first.
- Quorum now requires default values for variables on the inside of actions
or in fields. The reason is because Quorum was allowing seemingly rather arbitrary
defaults to be selected, which appeared confusing to some users. For example,
"boolean a" could default to either true or false. While we could argue one
way or the other, forcing a right-hand-side makes the decision explicit.
- Because of the flexibility of the ALL-STAR algorithm in ANTLR 4, it was
relatively easy to fix an issue with negative numbers not correctly parsing
under a few (relatively unimportant) circumstances. This was never a major problem,
but does make expressions just slightly more flexible.
- Fixed a number of issues with the way parent actions or fields were called.
Quorum 2.1 December 16th, 2013
- Added a peer review system for Quorum's standard library.
- Added a submission system for the standard library.
- Added a badging system for recognizing users that contribute to Quorum.
- Added an information page on the submission system and process.
- Fixed a broken connection causing the accessibility libraries to not
properly show up in the library list.
Quorum 2.0.1 August 13th, 2013
This is a bug fix release for the Quorum 2.0 branch.
- Finished and integrated the Mac OS X version of the accessibility
libraries. While the accessibility model on Mac is very different than
on PC, the Quorum libraries should work as similarly as we could make
them on each platform.
- Fixed a bug causing the output buffer to not be cleared correctly on
shutdown of a program.
- Fixed a number of bugs in the accessibility libraries.
- This is a Sodbeans release only. We are in the process of fixing one
more important bug on the 2.0 branch before we put out a new Quorum
installer. As such, those wanting this particular version of Quorum
will need to get the updates in Sodbeans.
Quorum 2.0 June 6th, 2013
Quorum 2.0 includes a host of improvements to the type system, adds the
ability to call actions on primitives, includes minor syntactic improvements,
and enhances the code completion helper libraries.
- Type System Changes:
A number of changes have been made to the type system, finishing off
a set of long planned alterations. We hope now that Quorum conforms to
the best available empirical evidence.
- Actions that return a primitive text value can now return undefined.
- Text primitives can now be assigned as undefined.
- Added the ability to call actions on primitive values. For example, we can
now add a colon after an integer and call any action provided by the Object
version of the primitive. Generally, this makes it far less necessary to
instantiate an object for a primitive type. The solution for this is relatively
efficient, as behind the scenes, Quorum calls a static action, with only very
slightly more overhead than calling the action on the object.
- Added all of the new type system features into the code completion
APIs, meaning that integrated development environments using Quorum,
like Sodbeans, should get them for automatically and without alteration.
- Language Additions/Changes:
- The "print" keyword has been changed to "output." This change
conforms to data from our surveys with novices, in addition to conforming
to common sense. For example, getting input from Quorum required using
the word input, but getting output previously required using the word print.
This made little sense, as print could have meant printing to a printer, not
necessarily printing to a console. This way, input implies input and output
implies output, making the language more consistent. All
standard library materials, book materials, and curricular materials have
been altered for the change.
- Changed the phrase "of type" in the Error architecture to "is."
- Changed the phrase "is a" in the inheritance system to "is."
- Finished a very basic initial version of accessibility APIs for Quorum.
This version is largely a proof of concept, but provides some infrastructure
calls down to various operating systems and unifies accessibility calls
(NSAccessible, IAccessible). This first version is available only
for the Windows operating system and only works when using compiled mode. It
does not yet function in interpreted mode or on Mac or Linux.
- Fixed a bug in the compiler causing extra items to sometimes be
wrapped into an output .jar file.
- Added the -server command line flag. This flag turns Quorum into
an HTTP server, where code can be sent to it and the output is returned.
Additionally, the -server insecure can be called turn off security settings
while in this mode. This last mode is not recommended unless the user is
running the server locally.
- Added a new flag, -java. This flag allows the user to pass an existing
Java jar file to Quorum. When passed, Quorum will automatically wrap
any code into the built jar's manifest on compile. This should make it
easier for external groups to combine their existing Java code with
- Finished a significant optimization pass of the compiler. There is always
more work that can be done in this area, but a number of the bottlenecks
in the Quorum 1.7 branch and earlier have been hammered out.
- Significantly improved the -verify flag, which now gives a much
better idea as to which methods have non-compiling, missing, or otherwise
broken examples in the documentation.
- Removed the "quote" token from the language. Now, the text primitive
or object can return special character codes by calling actions, including
arbitrary unicode values. Helper methods are available for common special
characters (e.g., newline, quotes, tabs).
- Lots of bug fixes.
- New Quorum Website
We have substantially revamped the Quorum website, including adding the
ability to run some Quorum programs online and the ability to rate
the words/symbols used in the standard library, in an effort to improve
- The website now has a much improved look and feel.
- The page for finding files in the standard library is now grouped
by category, hopefully making it easier to find classes.
- The Quorum website is now easily searchable.
- Users can now login to the website through google or a custom
- Pages with documentation generated by the compiler now allow the user
to rate various attributes of a class (e.g., the class name, variable names,
action names). The user must be logged into to rate.
Quorum 1.7 February 25th, 2013
Quorum 1.7 adds in a new type inference system, upgrades the internal architecture substantially,
and fixes a number of known bugs.
- Quorum now has a type inference system that can be used on the inside of actions (but not in declarations).
In effect, this means that users can write phrases like "a = 5" and the compiler will
still statically check, but will allow the type declaration to be excluded under many circumstances.
This new system partially completes
changes to the Quorum 2.0 type system, which conforms to user studies with humans done by
our team and Stefan Hanenberg.
- Substantially altered the static analysis tools internally to Quorum. This
greatly increases the quality of the types of tools that can be built on top
of the compiler. For example, Sodbeans now has much better code completion support
due to this upgrade.
- Added new web libraries for Quorum. This initial version is in beta and will
be completed in Quorum 2.0. The current version, located in Libraries.Web supports
the HTML 5 specification (or by calling print "my page here"). There are a number of
limitations in this first release, but a basic web server can be created by
passing the -web tag to the compiler (or in Sodbeans).
- Added a hash table to the standard library under Libraries.Containers.HashTable.
- Added a class for handling bitwise operations to the standard library under
- Made more changes to the compiler errors output by Quorum as part of our
continuing mission to make Quorum easier to use.
- Updated and expanded the curriculum and documentation for Quorum.
- Added a way to pass and use command line arguments.
- Fixed a bug with the "me" keyword.
- Fixed a rare, but critical, bug in the inheritance system.
- Fixed an odd bug in the scoping system.
- Fixed a number of small edge-case bugs.
Quorum 1.6 September 9th, 2012
Quorum 1.6 contains a number of important bug fixes.
- Fixed a number of bugs with the error system (called exceptions in other languages).
These changes include a near rewrite of the bytecode generation algorithms for this system.
- In order to help identify problems in the future, we have added a considerable number of test cases
for the errors system. We think these tests offer a much more
complete automated suite for this part of the compiler.
- Fixed some bugs in the control flow analysis algorithms. These fixes will
not impact the runtime behavior of any Quorum programs, but will
make alternative control flow sequences that are illegal or impossible
a little bit more obvious.
- Improved the clarity slightly of a few compiler errors. As always, making
compiler errors easier to understand is a work in progress.
- Fixed a number of small edge-case bugs.
Quorum 1.5 June 26th, 2012
- Significantly altered the syntax for conditional statements (if). The reason for this change is because we ran an empirical study, which showed evidence that novices using this construct made consistent errors, especially in the use of the token "then" and "end" on the inside of else if constructs. There is still one more set of tests we would like to run on this construct, to reveal whether the keywords "else if" lead to higher accuracy than our current choice, "elseif." We have not yet discovered clear empirical evidence in the academic literature, so will probably end up running the tests on our own. Below we give a quick example of the change.
We previously had the following:
if a = b then
end else if c = d then
end else then
The syntax is now the following:
if a = b
elseif c = d
We may change the design of this construct again in the future if we find more, or better, evidence for against any particular design. Users, or other researchers, that have conducted formal empirical studies, with corresponding evidence, that they think might illuminate more decisions here should let us know.
- Made minor changes to check-detect syntax. Like if statements, we removed the inner "end" statements. We did not run a formal empirical study on this change, but we thought it was a likely conclusion, given the if statement results. Further, this change keeps our language consistent across language constructs.
- We now have a new Quorum Interpreter
- In internal tests, this includes a speed increase from between 1,100% and 21,000% speed improvement for simple examples. This timing data includes just the speed the interpreter runs, not compilation speed.
- This interpreter is now used by default if the -interpret flag is used. For example, "quorum -interpret Main.quorum" would use the new version.
- Added quite a few new compiler tests. These tests have helped us to identify and fix a host of bugs (mostly minor) in the compiler, including a host of edge cases.
- Quorum now has a significantly improved documentation generation system
- Changed the -document flag so that it now auto-generates HTML5 documentation for Quorum libraries.
- Added a new flag called -verify, which automatically checks that any "examples" used in the documentation compile.
- Updated the online wiki Quorum documentation to the 1.5 syntax.
- Significantly improved the quality of code examples in Quorum documentation.
- Fixed a major compiler bug that didn't allow the user to access parent variables.
- Library Changes
- Completed a total redesign of the File class. We're looking for feedback on this class, but hope that it will be easier to use.
- Minor bug fixes in the music and sound classes.
- Fixed a number of bugs in classes like Random and the Containers.
- Added a new class called Libraries.Sound.Audio, which can playback media files. In this first release, it is designed to make it easy to playback .wav files easily. Future releases will probably expand the functionality further, depending on whether we get any user requests.
- Added a new set of Robot Control Libraries for interacting with iCreate's CBC robot controller.
- Adjusted the design of Compiler error messages. Our changes here are pretty minor, but our goal was to generally make the messages more consistent and obvious to users. users that find error messages that still are not clear should please feel free to file a bug report.
- Lots of bug fixes.
Quorum 1.0 January 30th, 2012
This is the initial release of the Quorum programming language. Currently, Quorum has the following features:
- Fully compiled down to Java bytecode
- Static, but flexible, type checking
- Unique control structures, heavily tested to be easy to understand by novices and professionals
- Object-oriented language
- Standard Library (e.g., data structures, music generation, text-to-speech)
- Plugin system for extending Quorum
- Integration with the NetBeans IDE
- Talking Omniscient debugger (The debugger literally talks to you and tells you what is going on).