Quorum Studio 4.6 and Quorum 10.6: January 9th, 2023

We have created a small maintenance release for Quorum Studio. This release was made because in Quorum 10.5, there was a change to the way shaders and batching worked in the graphics engine, which was causing several interface components to render a bit funny. We like funny as much as the next folk, but this was not intended. While working on those systems, we noticed a number of performance and memory issues that we have now fixed. In internal testing, the performance improvements compared to Quorum 4.0.3 are quite substantial. Notes follow:

Fixed an issue with checkboxes and radio boxes in terms of rendering, which was causing them to look visually like they were not responding. Accessibility was not impacted and they still worked under the hood.
Fixed several small graphical and unmemorable glitches in Quorum Studio. We say unmemorable because we cannot really remember what they were, but they annoyed us so we fixed them.
Significantly reduced the memory footprint of the Matrix class. The difference is quite large. In internal testing, it is in the ballpark of a 90% reduction, although the actual number depends on the size of the matrix.
Removed instantiating Object from the multiple inheritance architecture, rewriting the semantics of what it means in Quorum. Assuming we did not make a mistake, users will not observe any difference in how they use the language, however the memory footprint of Quorum has been significantly reduced because of this change. In Quorum Studio, for example, we are clocking a reduction of about 150 million unneeded objects no longer being created. The objects were small in size, but there were a lot of them, which means that in our internal tests, the memory footprint dropped by about 5%. Other tests, like charts, were more dramatic, with nearly a 35% reduction achievable only by recompiling the same program.
Because of the change to the multiple inheritance system, Quorum throws away less useless objects and no longer has to create them, reducing garbage collection. In internal tests, we are noticing about a 25% reduction in the amount of memory reported by the operating system after bootup
Completed the multiple inheritance change in JavaScript mode as well. This shrinks the overall rather large uncompressed standard library file by about 1.5%, due to cutting out a series of operations that were no longer needed in this version. The memory optimization impact was not carefully evaluated, but it should have theoretically similar impacts to bytecode modes.
On ARM processors for Mac, after all of the optimizations and comparing the Intel version of 4.0.3 to ARM, we are noticing a 57% decrease in bootup time and a 9% drop in CPU usage.
Significantly reduced memory consumption of scatter plots. While it depends on what you pass, in our test, which used an approximately 1200 x 15 sized data frame, this reduced memory consumption by 88.5% and dramatically sped up rendering and loading speeds. While this is nice in general, it also improves screen reader accessibility speed significantly.
Because of the inheritance changes, Quorum Studio 4.6 is not binary compatible with previous versions. We have added a double bootstrapping function to Quorum to auto-build Quorum Studio using both an overridden standard library and a source compiler. We recognize this is barely English, but are really just saying that we added some code to make it easier to make breaking changes to the backend compiler in the future and to integrate those automatically in Quorum Studio for usage in our tests.
Replaced the table implementation in matrix with the newer DataFrame class behind the scenes
Added a VectorColumn for more optimized numerical operations in DataFrames. This removes auto-boxing inside of a frame, which means if this column is used, no undefined values can be allowed. It is a speed trade-off and optional
Added an optimization to the Comparison class for default primitive sorting
Added support for Comparisons inside of the Vector class
Fixed a memory leak in ShaderProgram causing a considerable number of Text objects to be auto-boxed accidentally
Changed the Item and Control classes to not instantiate all of its arrays by default, which saves memory
By default, the Regression class no longer retains matrices related to the computations it made. This passes all of our internal unit tests and on code inspection, seems ok. The purpose is to reduce memory consumption after the regression is done calculating and this is significant for large files. That said, if for some reason we cannot think of, a user needs that object retained after computation, a flag may be needed to support it, even if the default is to destroy it.
Fixed a bug with ChartComparison where it was creating and throwing away extra objects
Lowered the default number of vertices used in the Polygon class, as it was not using the vertices for the common case.
Fixed a bug in Polygon that was creating an extra vector that was being thrown away.
Fixed a bug where HTML reserved characters were not properly handled when processing SVG images.
Fixed an issue where if you were on an ARM chip on Mac, the updater would grab the Intel based version of Quorum Studio. Users need to re-download from the website to fix this, but it should be easier to update from here on
Migrated file downloads to github releases. We will be using this system from here forward to reduce server load and just generally more conventional.
Removed the final PHP file from the server backend. Quorum now uses only Quorum for hosting Quorum on the Quorum server.
Fixed a bug in Quorum Studio where in the code completion, if you had an empty set returned, it would be too aggressive on showing you an empty window
Changed the auto-update scripts to account for the change to github
Fixed a bug in text fields where double click was not working
Fixed a view in text fields where the view was not correctly updating visually with the cursor in some situations
Fixed a bug in text fields where triple click was not working

Quorum Studio 4.5 and Quorum 10.5: December 7th, 2022

Quorum Studio 4.5 is the next major version of Quorum Studio and contains a series of enhancements and changes. As our current focus is on especially our move toward adding accessible blocks to the language, in addition to accessible data science, this is an intermediary release along that path. This is also the first release to officially support the M1 mac, as we slowly move toward improving our Mac support. For this first release supporting this chip, those on M1 chips need a separate download on the website and should not use the auto-updater.

Accessible Data Science

We have added support for a considerable number of statistical tests and procedures, along with many bug fixes. We did a considerable amount of refactoring along the way, which means we should be ready by next summer to have users try the statistical aspects of the system

Fixed a host of issues related to charts across the board
Added support for a variety of parametric tests, including repeated measures anova, sphericity tests, chi-squared, shapiro-wilk, and others
Added support for a variety of non-parametric tests, including Mann-Whitney, Kruskal-Wallis, Friedman, and others
Adjusted, improved, and implemented various corrections, like Bonferroni, Tukey, Huynh-Feldt, Games-Howell,and Greenhouse-Geisser
Added a set of convenience actions related to obtaining the results of statistical tests
Added convenience actions for various kinds of statistical actions, like obtaining correlation matrices
Added a helper action for generating scree plots for factor analysis
Added a set of tests for factor analysis, including Bartlett, Kaiser-Meyer-Olkin, and others
Adjusted and improved Accessibility across many chart types
Added a feature for live captioning of charts as you navigate them
Fixed many bugs related to statistical actions, which now have much more rigorous testing related to what they output

Planning for Accessible Blocks

The Quorum team is targeting adding a block mode to Quorum online and Quorum Studio by approximately Quorum Studio 5 and Quorum 11. Along the way, we have been developing a custom accessible rendering pipeline related to such systems and this includes at least the following features:

Expanded the shader system to account for the design of blocks. This way, you do not need images or SVGs for rendering and it can be done in hardware.
Created a hardware batched rendering system generally, with especially an eye out for blocks. This significantly improves performance for graphics across many systems, but is especially useful for charts and blocks. User interfaces do not yet take advantage of this approach, but may also benefit in the future from it
Migrated the code for the scene editing system from Quorum Studio to the Quorum Standard Library. The purpose in this was to have accessible scene editing offline and online, available both inside and outside of Quorum Studio. We hope this technology could make it possible for curriculum like Computer Science Discovery to be fully accessible
Integrated a number of fixes to Quorum's shaders, including those impacting Pie Charts on Android

Database and Web Services

The Quorum Database library has been a work in progress since publishing our paper on polyglot programming. We are now feature complete with this work and are pushing the system live across our stack. Finishing this system has significantly improved the ability of Quorum to be used in a common docker container for backend web services. Now that it is finally going live, the most current features include:

We implemented a series of minor bug fixes in the database system.
Pushed the database stack live and replaced any database related code with Quorum
Added a series of web service libraries necessary for server side scripting in Quorum
Replaced the Quorum live server's PHP system with Quorum, with the exception of the download page, which we didn't bother with this release
We have added a considerable amount of documentation for the database system onto the Quorum reference page
Because PHP has been replaced with Quorum, Quorum's live server can now service compilation requests an order of magnitude faster than before
Added a way to send raw network requests from TCP in the SocketConnection class in Quorum

General Features

We made a number of improvements to the system broadly. Big picture, these included:

Added support on mac for the M1 processor to Quorum-language and integrated it additionally into Quorum Studio. This significantly improves speed on this platform. Machines on Intel based chips are still supported
Rewrote the native libraries on Mac to considerably clean it up for future development
Added preliminary support for the Talkback screen reader on Android. This is a preliminary proof of concept release targeting charts and is not yet feature complete. It is, however, a start and now that we have successfully tapped in, it can be adjusted over time if there is interest from the community
Fixed a number of minor issues in the Quorum compiler

Quorum Studio 4.0 and Quorum 10.0: June 15th, 2022

Quorum 10.0 and Quorum Studio 4.0 is the 2022 release for the programming language and corresponding development environment. We focused considerably for 10.0 on improvements to the language in regard to making it better for data science. This includes significant improvements to charts, many data science actions, and the database system. Besides this, Quorum 10 includes a significant change to the look and feel of any user interfaces built into the system, including Quorum Studio. There are many new colors across everything and are swappable as light or dark modes. As always, we have continued to tweak and improve accessibility. With this release, we focused on getting the ground work in place for a future Quorum Blocks mode, which involved a great deal of refactoring behind the scenes.

Data Science Improvements

We made a number of improvements to how Data Science is done in Quorum for this release. This includes a myriad of changes to the DataFrame class, focusing on creating a set of helper actions and inspired by similar actions in the R programming language. We created these on recommendation from a statistical consultant (thanks, Amelia McNamara!) and plan to continue adding helper actions in the future. Big picture, the idea is, while we can always traverse and adjust a DataFrame manually, we are trying to make using DataFrames less of a hassle.

For this release, there are several big changes. First, we have continued on our limited polyglot integration by adding actions similar to R's mutate. This allows for the user to create new columns, calculated on the fly, using Quorum's normal syntax. Second, we added/refactored convenience actions for outputting to the screen limited versions of frames and additionally added actions to remove or replace undefined values, in addition to column and row splitting. This does not cover all the transformations we want to add, but it is a start and these are potentially useful.

Finally, we added a considerable amount of documentation for this release. This includes details on how you make DataFrames, control them, manage charts, and other factors. Detailed notes follow:

Added a GetHeaders action to DataFrame to find all the headers of the columns without traversing them
Added a new AddColumn action to DataFrame, which allows you to run a script to calculate the new column. For example, x1 + x2 * 3 would multiply all values in x2, add the values in the row for x1, then make a new column with this value
Added a new action to DataFrame called CalculateColumn(text) that also uses a script, but instead of adding it, returns it
Added a convenience action to DataFrame called CalculateMaximumRows. It, perhaps not surprisingly, calculates the maximum number of rows across the columns in the DataFrame
Added a way for DataFrameColumn objects to understand the results from the runtime interpreter. This allows various kinds of mutation and filtering actions by letting sub-classes of the column interpret the results during execution
Added two actions to DataFrame to allow for outputting only a portion of a DataFrame. They are ToText(integer) to get a number of rows and ToText(integer, boolean) to output a number of rows with or without a header
Added two convenience actions for removing undefined values from a DataFrame. This includes RemoveUndefinedRows and RemoveUndefinedRowsFromSelectedColumns, which remove undefined values either from the entire frame or taking into account selected columns
Added two convenience actions for replacing undefined values in DataFrame, similar to the removal actions
Added the ability in each column type to replace all its undefined values with a separate value. If the value is not valid for a particular column type, it is ignored
Added in the ability to split a column up with a delimiter from the DataFrame
Added in the ability to split a data frame by rows, including random splits for selecting random sub-selections of the entire frame
Added in a ColumnSplitter class that lets us override how column splitting is handled, while letting the base class handle all the traversals.
Added in a way to select rows in a DataFrame. This currently does not impact chart creation or other operations
Added in a way to select arbitrary cells in the DataFrame. This currently does not impact chart creation or other operations

Database Changes

Quorum 9.5 introduced a new Database system for Quorum and we have continued this work in Quorum 10. While we are using this new system internally for projects, we would argue it is still in beta. That said, we did make a number of improvements to it, including continued work to make that system feel seamless when used across Quorum. In terms of documentation, we have not yet written any, because again we still consider this version a public beta. Ultimately, we are planning on switching the Quorum live and beta servers to this system entirely and once we do, that is the flag for the team that it is ready for production. We will likely write documentation at that point. Notes for the changes and improvements follow:

CreateTable can now add text columns with no size specified. These text columns can store a string with a max length of 65,535
Added auto increment to integer columns in a CreateTable query
Number, Boolean, DateTime, Date, and Timestamp columns can be added to a CreateTable query
The CreateTable query class now has constraints to a column. Examples of constraints are unique, not null, and default values
The CreateTable query class now supports setting a column to be the Primary Key. The primary key is a column in the table that has to be unique and cannot be null
Added an ignore flag to the Insert query. When the ignore flag is true, if there is an error the insert will not stop execution
Insert queries now allow for adding booleans and undefined values
Fixed issue causing sorts to be added to Find queries
Added HasTable and GetLastInsertedID actions to the Database class. GetLastInsertedID will only work if an insert query has been executed before calling that action
QueryResult now supports returning values as a boolean, number, and a DateTime object

User Interface Library Changes

The user interface library in Quorum has undergone major changes for Quorum 10. Notably, while the team has put in considerable effort on accessibility in screen readers, visual look and feel of the library has historically lagged behind. In this release, we have re-imagined the colors, borders, backgrounds, and many other small visual changes. Individually, many of these features are small, but overall they make a difference, we think, in terms of readability, usability, and accessibility. Further, because we want to ultimately have different versions for people with different visual needs and wants, we now include by default a light and dark mode in the system, which can be used in any Quorum generated user interface. Users can also create their own theme, with any visual properties and colors they wish, and apply them across the entire user interface system all at once. Detailed notes follow:

Added a new shader for rendering controls in the user interface
Refactored across many of the controls, providing some consistency across the rendering pipeline
Added an InterfaceOptions class, which allows all user interface controls to reference standard colors and options
Changed all of the major controls to coordinate with the InterfaceOptions class, allowing custom properties and colors to be more uniform everywhere
Added Dark and Light modes for all user interface controls into the standard library
Fixed a series of small bugs in the user controls where colors and options were hardcoded
Added support for rounded corners to many controls
Changed the default setting in tabs to use rounded corners
Fixed a bug causing borders to look inconsistent in many controls
Added a drop-shadow to modal dialogs so that that they look visually more like dialogs
Re-imagined all of the default colors inside of the standard user interface controls. They should now be slightly easier to read and identify
Adjusted colors and highlights to make the component that has the focus or the selection more visually obvious
Added a screen reader feature equivalent to what is called roledescription on the web. This allows us to customize screen reader information in specific ways online. We observe not all screen readers read out the property by default
Fixed a bug in tabbed panes where closing the last one on the left-most side would cause the rendered item to retain its rendering if a new item was auto-selected
Added a drop-shadow feature to menus, pop-up menus, and dialogs

Mobile Changes

For this release, we added a series of default gesture detectors into all supported mobile platforms. These platforms do work slightly differently in regard to how they manage gestures, which ones they support, and other attributes, but Quorum now uses a system that standardizes these. For this release, while gestures are now available, they are not included in the default input sets for each control, as this would take some design work across the systems that is not yet complete. For example, charts, buttons, textboxes, trees, or other controls would likely benefit by having default gestures, but we need to figure out what those should be and write them consistently everywhere. Detailed notes follow:

Added support for gestures to both Android and IOS devices
Added gesture support into the InputSets, allowing any user interface control to add default gestures
Gestures added:
1. Single Tap
2. Double Tap
3. Long Press
4. Pinch (Zooming)
5. Pan
6. Swipe
Added vibration control into iOS mode

Quorum Studio Changes

Piggybacking on the new user interface changes in Quorum 10, Quorum Studio 4 incorporates these changes and makes a series of visual improvements. At a high-level, this includes a number of long-standing rasterization issues. Examples include issues with fonts, borders, and background colors, which sometimes were hard-coded around various interface controls in the standard library and in Quorum Studio. This significantly improves the look and feel of Quorum Studio, provides some user options, and slightly raises contrast in both modes. Detailed notes follow:

Added light and dark mode
Changed all of the icons in Quorum Studio to account for color modes
Changed all of the icons and icon colors in the toolbar. They now can render at any resolution without obvious rasterization
Added a new user preference for color mode in the Quorum Studio Properties dialog
Fixed the splash screen so that it renders more sensibly at more zoom levels
Conducted an accessibility pass and changed all of the colors for all modes. Broadly, the contrast is now higher and everything should be more readable
Added in the most recent version of Awesome Font, which is used for rendering the toolbar
Updated the project system to use the JSON reader in Quorum 10, which has slightly different rules for processing of arrays
Keymaps are now versioned, due to changes in the InputSet system to account for gestures
By default, if Quorum Studio loads with a keymap version less than 2, it destroys the file and resets to the default. The reason for this, while mildly annoying if the file is overridden, is that the codes are now calculated differently and not doing this would be much more confusing
Fixed a bug in the about box causing it to not be accessible. Special thanks to Amanda Rodda for noticing this problem
Significantly improved the check for updates window so that it, oh ... I don't know, actually tells you useful information about what it is doing. Previously, while it did technically update, if anything went wrong it twiddled its thumbs in unhelpful ways
Removed the requirement to login to get updates from the update server
Added a pop-up window when you try to close a number of tabs that were dirty, warning you that you may lose work
Changed all of the colors and icons in the code completion window
Fixed a bug in code completion causing the window to close with certain keypresses if there was no code completion options
Made the code completion window generally less finicky as you type
Added a new entry to code completion that tells you if there are no available options
As always, changed some of the splash screen messages for no reason other than Stefik's personal amusement

Web Changes

For the web, we continued to work on making Quorum's web library more accessible and usable overall. We also updated the web library to include all of the features in Quorum 10, including shaders, light and dark mode, and other features. Detailed notes follow:

Improved Shadow DOM support in the web libraries
Changed the way focus is managed inside of the online development environments
Changed Quorum's File class to more sensibly manage data from the web
Added multiple file support to the development environment back-end. Technically, you cannot yet use multiple files in the environments, but all of the server side and database work is now completed
Significantly optimized and updated Quorum's database backend on the live server
Fixed several issues with font loading on the web
Fixed the embedded development environments so they embed properly

Charts

For charts, our primary goal right now is in making the charting system more mature. Charts are quite complex visually and what methods make them as accessible as possible on each platform is a tricky question. At a high-level, we significantly improved the visuals, interactions, and flexibility of charts overall. We also squashed a considerable number of bugs in the chart system and improved how it renders itself to scalable vector graphics (SVG) files. Detailed notes follow:

Added a regression line to scatter and line plots
Added a trendline to the histograms
Added the ability to use subtitles on charts
Added use of 2 factors/1 column in box and violin plots
Added annotations to bar/pie/scatter/and line charts. By default, the pie chart will show a (%) annotation, the other charts’ annotations can be shown using ShowAnnotations(true)
Created a system for what is sometimes called a 'facet grid' in languages like R. This included separation by series, which separates the charts into subcharts by color/legend entry, and separate by factor, which separates the charts into subcharts by the factor used.
Fixed a variety of issues in the SVG rendering of charts
- Added viewbox settings to allow for scaling image size dynamically on the web
- Update the LineChartWriter to use the ChartWriter parent class and updated accessible navigation
- Added some basic XML escaping to the ToText actions in the SVG classes to fix issues with special characters (e.g., &, <, >, “)
Reimagined accessibility in charts. We think there are quite a few more improvements that can be made, but also find the system much easier to use in a screen reader now
Added borders and visual updates on many aspects of the charts to make them look visually nicer
Fixed a number of small layout issues in charts
Changed the selection of an item in bar charts and histograms to have a small arrow pointing at a bar instead of an outline.

Other Changes

Fixed a bug in the compiler causing casting a value from text to a boolean to fail under some circumstances in JavaScript mode. It now correctly throws an error under these circumstances and a test case has been added
Fixed a small bug in the compiler causing errors to be thrown as you type in Quorum Studio
Fixed a bug in a JavaScript plugin that was incorrectly identifying a not a number as not a not a number. We have concluded that this line in our release notes is confusing, but fun to say and technically accurate, so we're keeping it
Fixed an esoteric bug in the font system causing it to only accept font values in ASCII. Look, we were accidentally casting down in low level C to an 8-bit integer, ok?
Fixed a nasty bug in JSON processing related to nested arrays. Unfortunately, this change is not backwards compatible and programs using JSON in Quorum 10 that make use of this feature will need to be updated
Added a test case for a mildly complicated nested array in JSON

Quorum Studio 3.5 February 4, 2022

The overall technical architecture for Quorum Studio 4.0 and Quorum 10.0 is significantly different than in previous software releases on the project. In order to get adequate testing before the official release in the summer of 2022, we are putting up a middle of the road version of the technologies to make it easier for our team, and the community, to test everything. As this version of Quorum and Quorum Studio is about half-way between the next version, we are calling these versions Quorum Studio 3.5 and Quorum 9.5.

Graphics Shaders and Updates

For some time, Quorum has used OpenGL for rendering its content. Historically, because Quorum Studio was used across many school systems, we kept the OpenGL version rather old, as some schools use older hardware. Notably, we were using OpenGL 2.1, from 2006. While this system worked well enough to invent much of the accessible graphics pipeline in the language, OpenGL 2.1 used a particular kind of graphics pipeline that is now outdated. Further, OpenGL is having challenges today. Apple has deprecated this system, limits it to OpenGL 4.1 (about 2011 or so), and is quite slow compared to Windows in our testing. Further, OpenGL itself is sometimes being replaced by third parties (e.g., Apple's metal, Vulkan), while others still are maintaining it (e.g., WebGL, Android). The future of OpenGL is thus uncertain and we are preparing for the potential reality where its creators abandon it.

To try and fix this issue, we have redesigned Quorum's backend for Quorum 9.5. This includes the following changes:

Upgrading to OpenGL 4.1 (desktop), OpenGLES 3.0 (mobile), or WebGL 2.0 (web). Despite the varying version numbers, these are all approximately the same OpenGL version for different platforms.
Completed a near rewrite of the graphics system, exposing the raw shader system from within Quorum code.
Added a set of raw graphics calls, which gives considerably more control of the graphics pipeline from within Quorum. These calls do largely map to OpenGL, but we have done our best to make them neutral across graphics pipelines. This will change in the future and we hope will become even more neutral over time.
Added support for mapping calls into the graphics system, changing, and creating shaders. The idea is that you can set shaders on individual items or control them in a number of other ways.
Added support for geometry and tesselation shaders from within Quorum.
Currently, the shader code itself is written in GLSL. We strongly suspect this will change over time, because different platforms have different requirements. Further, even with these changes, writing shaders is difficult, and highly mathematical, so we suspect the team will be thinking of plans related to ease of use in the future as well. Point being, while users can use shaders now, we urge the community not to go nuts in creating GLSL specific dependencies.
Adjusted and improved the graphics primitives that can be used on the system, including in the creation of a new polygon function from Drawable, which allows more sophisticated shapes to be drawn and also allows those shapes to be drawn with less pixelation.

Database Support (Beta)

Based on the work of Drews et al., we have implemented a new database system for Quorum. In this version, we consider this system to be in beta. The core approach behind this is described in the paper (the hybrid system, which happened to do best in the experiment) and allows users to write code to connect to, get data from, and send data to, a database system. In the first version, we support MySQL. For those needing different architectures (e.g., postgres), there is an architecture in place where it can be added, but such systems are not yet supported. Here are some of the core features of the system.

Support for creating, adjusting, and dropping tables
Support for logging into databases and closing them
Support for many kinds of queries, written through typical Quorum syntax.
Integration of database support into the data science systems, like charts, statistics, and DataFrames. This allows users to query databases and then run calculations on any results without needing custom programming languages or syntax.

Charts

As our work continues on Data Science for Quorum, we have made significant improvements to charts. There is a lot more work to do and how to tackle it is a balance. For example, charts need to look correct visually and, as those looks change, each piece needs to be made available in the accessibility system. Further, the charts need to be accessible online and offline and this means we need different modes for different purposes. Each of these features requires careful thinking and time. We expect many releases over the next few years on these features. Recent changes follow:

Added a series of color templates that can be used. Many of the choices made by the team come from evidence in the academic literature [1,2,3], although so far as we can tell, there really is no perfect choice for the defaults. Thus, we have also given the user the ability to change between them, or set their own, as color needs are both partially subjective and vary, at least to a degree, by personal preference.
Added the ability to split charts into facets, meaning separate them by factors from a DataFrame. Another way to say this might be to say that we can now automatically separate charts out by variables of interest.
Adjusted a host of minor graphical changes to the charts to make them look visually nicer
Added customization options for axes, legend position, font size, gridlines, group brackets, and point/line density.
Added accessible navigation to charts exported as SVGs (bar chart, histogram, scatterplot, pie chart, violin plot). This work is complicated and a work in progress.
Added support for additional Chart customization features in the SVG export process (visual update, gridlines, vertical/horizontal orientation, stacked/unstacked bars)
Added pie charts and donut charts.
Added a first step way to embed these charts into other systems accessibly.

Quorum Backend Changes

Quorum 9.5 introduces a rewritten backend for managing Quorum Plugins, through the integration of Gradle. For most users, this will not matter, but the key change is that when a user clicks build in Quorum Studio, what the language generates has changed a great deal. Thus, Quorum programs written in version 9.5 are source compatible with previous versions, and technically also generate the same bytecode from the compiler, but they interact with plugins differently. This change greatly simplifies how we connect into third party systems, including the iPhone, Android, and other features. Features include:

Quorum now uses Gradle 7.1 from within the primary build system. Users overriding the standard library (rare for users to do), will now see different messages from the system.
Changed QuorumStudio to use JDK 11 by default. The reason for this is, especially, because dependence on JDK 8 on Mac was preventing us from conducting experiments with accessibility on this operating system. Changing this was thus necessary to even begin work on Mac accessibility
All plugin and Quorum code remains set to JDK 8 bytecode, not JDK 11, because otherwise it would break compatibility with LEGO mindstorms
From Quorum, all plugins are now generated using projects in IntelliJ or the console. This allows users with accessibility needs to write the code in any accessible format they wish, then run the full build from within Quorum Studio or from the console, removing an additional accessibility barrier. This also removes our previous reliance on NetBeans.
Fixed a number of small bugs in the compiler, especially related to the new parser architecture introduced in Quorum 9
Fixed an extremely annoying bug in the compiler where parameters would not properly propagate their location information, which caused use hints to break and compiler errors to give the wrong location for essentially any error related to parameters
Adjusted the standard library scripts to adjust how dependencies are managed, including how JavaScript is generated
Quorum's test suite now uses NodeJS to execute

Code Completion

One major improvement in Quorum Studio 3.5 is code completion. While Quorum has had code completion for a while, it has generally been pretty buggy. With the advent of Quorum 9's hand parsing architecture, however, it became much easier for us to control what information can be sent to the code completion system, which in turn made it easier to rewrite it and clean it up. For this reason, code completion in this version is now much more reliable across the board. Some general changes include:

Fixed a bug in code completion causing the return type to not show up properly
Fixed a bug in code completion causing many kinds of expressions to not parse correctly and thus give you no information
Added chaining to code completion. Not all permutations are yet supported, but the feature covers a significant number of common cases
Significantly improved Quorum's ability to understand what would be useful to a user based upon context in the source
Improved suggestions, including being able to provide hints for basic primitives, in addition to classes in the standard library, and action calls

iPhone Changes

Quorum has several changes to the iPhone architecture, including:

The addition of Core Haptics to the supported APIs. The implementation is in beta and has not been well tested, but we are including it specifically so we can run experiments on it and improve it. The tricky part here is that we want calls on android for haptics to largely feel similar to those on iPhone, but we need to evaluate this using funky devices called laser doppler vibrometers. Also, laser doppler vibrometer is a fun thing to say. Go ahead. Say it 10 times fast. It's fun.
Updated iPhone to the latest MobiVM release through Gradle
Updated the Gradle support on iPhone to version 6.9. This is different than standard Quorum, but MobiVM does not yet support 7.1 and this version is sufficient for our needs
Our iPhone support has historically had an extremely slow build process, due to the way we are building the native files and converting using MobiVM. This is still true, but we have introduced some primitive caching, which makes repeated builds faster. More work is needed on this system to speed up iPhone support in various contexts, but it is an improvement.
Updated the graphics system to use the new shader architecture. We should note that due to inconsistencies in Apple's GLSL implementation on such devices, there are some continued challenges in graphics on such devices

Other Features

Added a Serial class to Quorum for Serial port connections or bluetooth. Special thanks to Alex Chavez for the Pull Request for this feature
Added a SerialPort class to allow communication on individual, but separate, ports.
Added a way to query for available serial ports
Made a host of improvements to the DateTime class, which badly needed the attention.
Added support for dates into the DataFrame class

Quorum Website Upgrade

We have completed our long-planned upgrade to the Quorum website. This included a rewrite of a whole host of systems and an upgrade from Quorum 6 online to Quorum 9.5. Quorum can now be embedded into third party websites and run from anywhere. Finally, we have begun our experiments with making accessible graphics work in a web browser. This feature will take quite some time to get right, but we have been updating and tweaking the pieces since the initial update in December.

Significantly changed the way you program on the website. This adds syntax highlighting, more hotkeys, and buttons.
Added code regions that are still accessible, but visually look better
Added code regions automatically in the generated documentation
Changed to a new server infrastructure that should be much faster for most users
Made the compiler an order of magnitude faster online
Placed many of the compilation dependencies behind cloudflare, which should speed things up especially for international users
Upgraded the online compiler to Quorum 9.5
Made it so when you compile a program, you get immediate feedback, instead of jumping to a new page
Integrated a graphics region in the online development environments so you can conduct graphics on the same page
Upgraded the graphics system online to WebGL 2.0
Fixed a host of small bugs in the online version of Quorum

Known Issues

Xcode 13 removed xtrace from the xcrun utility, which means our ability to detect iOS devices is currently broken in that version. This is true for older and newer versions of Quorum Studio
Certain graphics applications seem to be throwing an error on M1 mac processors. The error does not appear to impact runtime behavior

References

Gramazio, C. C., Laidlaw, D. H., & Schloss, K. B. (2017). Colorgorical: Creating discriminable and preferable color palettes for information visualization. IEEE Transactions on Visualization and Computer Graphics, 23(1), 521-530. https://doi.org/10.1109/TVCG.2016.2598918
Lyn Bartram, Abhisekh Patra, and Maureen Stone. 2017. Affective Color in Visualization. In Proceedings of the 2017 CHI Conference on Human Factors in Computing Systems (CHI '17). Association for Computing Machinery, New York, NY, USA, 1364-1374. DOI:https://doi.org/10.1145/3025453.3026041
Luz Rello and Jeffrey P. Bigham. 2017. Good Background Colors for Readers: A Study of People with and without Dyslexia. In Proceedings of the 19th International ACM SIGACCESS Conference on Computers and Accessibility (ASSETS '17). Association for Computing Machinery, New York, NY, USA, 72-80. DOI:https://doi.org/10.1145/3132525.3132546

Quorum Studio 3.0.1 September 10th, 2021

This is a small bug fix release. Notes follow:

Fixed a bug causing the 2D palette in Quorum Studio to break. Special thanks to Ko Inamura for the bug report.
Fixed an infuriating bug that caused the toolbar to disappear sometimes when a scrollable table was active.
Fixed a bug causing the layout of a table to twitch and wrap incorrectly on even small resizing changes.
Fixed a bug causing tables to crash when using screen readers in certain circumstances.
Fixed an issue which could cause textboxes to crash with a screen reader active when deleting text near the end of a file.
Fixed a bug causing Quorum Studio to not properly update the icon in the tree when you set a file as the main file. It now correctly changes the color.

Quorum Studio 3.0 and Quorum 9.0 July 9th, 2021

Quorum Studio 3.0 and Quorum 9.0 are the next major upgrades for developing in the Quorum Programming Language. Unlike previous years, we rolled out many crucial additions and features throughout the year. The changes here focus on those made since the last minor update, which was in Quorum Studio 2.3. Note that some of these notes are duplicative of the notes that were emailed to the community, but not put on the website, for Quorum Studio 2.5. We wanted to get beta versions of this material out to the broader community early for feedback and review, given how extensive they are. Thus these notes here include changes from Quorum Studio 2.5 through 3.0.

Android and iOS support

Following the revival of Android Support to Quorum in Quorum Studio 2.3, we have additionally added support for iOS devices. Quorum originally had primitive iOS support in an older version, but this was dropped because the product, RoboVM, that Quorum depended on was discontinued. One group, MobiVM, created an alternative and really knocked it out of the park. We have adapted our content to use MobiVM, starting nearly from scratch on how this system is put together. We would especially like to thank Nicholas Vancise for his contribution to the iOS system in Quorum, which we largely copied from his Github repository. That is available on github: https://github.com/thenick775/Quorum_iOS_Transpiliation/. Note that we included this support in the Quorum Studio 2.5 release. This feature is unchanged in 3.0.

3D Support in the Quorum Studio Scene Editor

New in Quorum Studio 3.0, we now have support for 3D in the scene editor. This system, which is accessible, allows us to create 3D items, like models, primitive cubes, and other shapes, when creating games. Like 2D, it uses a very similar system for accessibility, with similar property windows, and other attributes. These changes are now integrated into scene files, so it is backward compatible. However, note that Quorum Studio 3.0 scene files, because they add 3D, require 3.0 or above. We have attempted to make keypresses, navigation, and interaction mimic the 2D system as much as we can, but as always would appreciate feedback as we decide on how to expand the scene system for future releases. Note that a beta version of this feature was placed into Quorum Studio 2.5. Changes since this release include:

Fixes to a series of hotkeys
Adjustments to the auditory cues made inside screen readers
Added a function to the Matrix4 class to simplify transforms, TransformWorldCoordinate. The TransformWorldCoordinate action takes a 3D point in space (e.g., the location of an Item3D) and applies any movement, rotation, or scaling that's stored in the Matrix4 to that point.
Simplified scaling and rotation by storing values for them instead of shoving them in a transform. This was a significant usability issue that made the scene editor hard and the programming hard to use.
Changed the palette to include lighting
Added a way to add your own models and sounds into the 3d scene editor

New Quorum Parser

Quorum 9.0 includes a brand new parser technology, which replaces our beloved Antlr as a parsing stack. While we love Antlr and it has made Quorum possible for many years, recent evidence from Becker et. alamongst others, has shown strong evidence that the design of compiler error messages needs improvement. This problem is not unique to Quorum, but neither is Quorum exempt from this evidence.

This technology provides three big advantages. First, we can control every compiler error message directly, without needing to go through Antlr. Second, this technology can cross-compile itself to the web, which should allow us to improve our web-stack for Quorum over time. Finally, this new technology has been integrated into the standard library and allows us considerably more control over parsing in the language. We suspect that these error messages, and this technology, will be iterated on for several years as we talk to users and collaborate with the research community.

While we conducted an edit pass on error messages in Quorum Studio 2.5, we did a second pass for 3.0 through all aspects of the compiler. Thus, users will observe new messages across the board. Further, since Quorum Studio 2.5, we have additionally conducted the following changes to our new parser's beta phase:

Using the Flesh-Kincaid metric, we examined every compiler error message in the parser, bringing many of them down from college reading level to approximately 8th grade reading level. Many of these messages could not easily be lowered further without making the meaning of the error message incorrect.
Evidence from Daleidens's dissertation showed approximately 70% of compiler errors for Quorum online come from the parser. As such, we've heavily modified the compiler error messages for these errors a second pass. We suspect, as more evidence is gathered, they will be changed further.
Did a general edit pass on all error messages, including old ones and rare ones that might occur during semantic analysis.
Fixed a bug in the compiler that could, on rare circumstances, cause it to enter an infinite loop if there was exactly the right kind of compiler error in exactly the right kind of spot.
Fixed a bug in the compiler that would sometimes cause an exception to be thrown in certain kinds of solo action calls.
Fixed a bug in the parser that would cause the system to ignore certain kinds of errors related to incorrect expressions. These kinds of errors now correctly state the problem and provide correct locality.
Fixed several files in the compiler that were not in the correct folder. Quorum doesn't actually care, but the standard library generator was angry about it.
Fixed a nasty bug in the new parser, which was allowing solo action or parent action calls to be triggered in field blocks. This was intended to be a compiler error and was one in Quorum 8. It has been put back into a compiler error.

Scientific Notation

Given the Quorum 9 change to a new parser, we took the opportunity to make a few minor adjustments to the programming language that are long-standing. The most significant is in the addition of scientific notation. Notably, while we normally like to collect evidence on changes before making syntax changes, we observed that our data science system was excruciatingly frustrating to use without scientific notation. This notation is largely standardized internationally, so we decided to adopt it. Thus, we designed a system that looks like so:

2.0e10

In the current design, we use standard symbols for scientific notation, with the exception that the e must be lowercase. The reason for this is because of Bonita Sharif's excellent work on readability of code with eye trackers. In discussions, the lower-case e provides a natural separation point compared to the upper case, which we suspect matches her results better than allowing the capital E. Note that scientific notation is allowed only for numbers, but not integers. Future evidence may cause us to alter this design, but given this is a standard that is often taught in schools and used on calculators, we think it is reasonable.

Quorum Online Changes

In Quorum 9, we have made major changes to how Quorum outputs JavaScript when it compiles. This feature, likely not well known in the community, is how Quorum allows itself to run online. Notably, we now pre-compile the Quorum 9 standard library and cache it online, sending back only the minimal set of code for each request. This dramatically, and we mean dramatically, increases the speed at which Quorum can issue requests online.

The broad approach here, given that a number of partners use Quorum online in different ways, will take time to push online, as for it to go live we need to work with our partners and ensure we don't break their work. As such, while these changes are available today, they will not be on the live server until a later date. These changes broadly include the following:

Quorum's standard library is now pre-compiled, like it is on desktop, and this is cached in the browser.
Quorum's online development environments no longer need to go to a separate page.
The speed at which the compiler can issue requests has been dramatically increased.
Quorum now includes a web server mode, replacing our old tomcat server, which allows it to send JavaScript conversion requests over the wire. While this server is general and can technically be used for anything, the implementation is primitive and we urge caution in using it in production environments.
Adjusted how Quorum outputs JavaScript to account for a myriad of changes between Quorum 6 and 9. These changes are not backwards compatible, but should require minimal change to get working.
Quorum's online development environments now include an embedded graphics canvas.
Included font support into the default graphics canvas.
Updated the website in most locations to use the new development environment.
Added development environments to pages previously without one. This expands what can be done online considerably.
Split up the drawing 2D tutorial into 3 separate tutorials. They now have development environments in them as well.
Split up the events tutorial into 4 separate tutorials.
Reorganized the reference page and split up the games tutorials into a larger series of tracks for particular sub-topics.

Tooling Changes

To account for changes to Quorum 9, the debugger and the code completion system have been significantly changed. Major highlights include speed increases in both systems, improvements to readability, and a series of general bug fixes. Stepping over code is now much faster and code completion, at least on our test systems, pops up near instantly. The full list includes:

Fixed a bug in the debugger where the variables window would not properly indent when resized
Fixed a bug causing the debugger to execute slowly if any of the stepping keys were pressed, using any input modality
Fixed a bug causing breakpoints to not be properly sent to the debugger if it was already running
Fixed a bug causing the debugger line to not show up properly if other highlight lines were at the same position
Fixed a bug causing the debugger line to disappear in certain circumstances
Fixed a bug causing the debugger line to disappear in the standard library in certain circumstances
Added a way to prioritize highlight lines into the textbox renderer. This ensures certain lines are always "on top" visually when rendered. Any Quorum application can now set these priorities in a textbox.
Updated the tools dependency in the debugger to a more modern version.
Replaced the code completion system with one generated by the new parser architecture. In this first version, it is limited, but this approach provides us a much more powerful way to estimate the likely request being sent by the user. The current version is primitive, but still seems to work better than the old system.
Significantly improved the speed in which code completion finishes collecting information
Added a new parse listener architecture for code completion, based on Quorum 9's infrastructure. This greatly simplifies changing the code completion system in the future.
Fixed a bug causing COMMAND or CTRL + J to not work correctly in standard library files.
Fixed a bug causing git annotations to not show up in standard library files
Fixed a bug causing spurious editor hints and compiler errors to show up in standard library files
Quorum Studio now generates a log file for technical errors. This information now records errors thrown by the system as you code. This information is stored locally only and is not sent to the Quorum team, but provides us much more information about what happens in the field with Quorum Studio if a user runs into trouble.
Fixed a bug in code completion causing it to crash under certain circumstances.
Fixed a bug in the compiler error window that made it difficult to read the errors, as they were cropped.
Fixed a bug where tabbed interfaces would require the user to click on the tab, click off the tab, then click back onto it for it to show up correctly. We did not like this bug. It was not very nice.
Fixed a bug where tables could not word wrap properly. This made compiler errors in Quorum Studio very difficult to read.
Fixed a bug in trees, radio buttons, and the spreadsheet, where the selection would not show up visually until user interaction had happened. Ironically, this was always working for screen reader users, just not people that can see.
Fixed a bug on Windows where if you did an auto-update on a version of Quorum Studio where the standard library had a name or package change on a file, and installed over the system, it would double up on the refactored portions of the standard library.

Data Science Changes

Quorum Studio 3.0 and Quorum 9.0 includes a considerable number of improvements to the new Data Science libraries in Quorum. Many minor changes are listed below, but overall we have significantly improved the naming conventions, talked to users of the API on their needs and how they use it, and re-tooled the entire system. Additionally, we conducted a randomized controlled trial on how to do operations like filtering, which ultimately showed that we can serve user's needs by embedding a small domain specific language inside of Quorum, which is for filtering. The rules are the same as Quorum, but the broad idea is that we can conduct simple filtering operations in DataFrame objects without using the Transform system.

Changed the name of TDistribution to HeavyTailNormalDistribution
Changed the name of FDistribution to VarianceRatioDistribution
Changed the name of CompareColumnToMean to CompareGroupToMean.
Updated CompareColumnToMean to naming conventions that have been adopted consistently across all statistical tests
Added a few Univariate actions for inverse computations and a parent class.
Removed the CompareTwoColumns class, which has been replaced with the more general CompareGroups class.
Added a RootFinder class, equivalent to a Brent function.
Added a Continued Fraction for Gamma distributions
Added a class for calculating the mathematical ErrorFunction, called ErrorAction in quorum.
Added several helpers to the Gamma class from Apache Commons
Added a class for Normal distributions
Fixed a bug in the T Distribution (now HeavyTailNormalDistribution), which caused it to make incorrect calculations as the degrees of freedom approaches infinity. Alternative algorithms need to be investigated for exact values, but it is very close as it is and matches the bug fix in Apache Commons.
Added a result called CompareGroupsResult, which gets information back from anova calculations and pairwise calculations.
Added pairwise tests and optional Bonferroni calculations into the default CompareGroups class.
Added a CompareVariances class, which is equivalent to a Levene's test
Added a CorrelateGroups class, which is equivalent to a Pearson correlation
Added a CorrelateRanks class, which is equivalent to a Spearman correlation. Note that Spearman correlations are really just a rank transform followed by a Pearson. Because Kendall's tau gives a similar result, only this approach is supported in the standard library in the current version.
Modified the regression and other classes to the new naming conventions for distributions.
Renamed a number of actions inside the classes for consistency. This includes renaming some of the probability functions to CumulativeDistribution, which matches more common statistical terminology.
Added survival, inverse survival, and inverse cumulative distribution actions to the distributions
Added a NumberDistribution class to standardize actions across subclasses. We suspect these will grow over time as we flesh out the library, and as such, we want to keep them consistent. While the design comes from Apache Commons, we imagine it will diverge over time as we better learn what naming conventions and designs make sense for people in practice.
Fixed a bug causing line feed/new line combinations to fail in reading csv files.
Fixed a bug causing the last character of csv files to not be properly read
Improved the efficiency of the CSV file reader, significantly boosting its speed for large data sets (tested in the 100MB range).
Fixed a bug in charts causing the last row to crash
Added line charts with multiple lines and violin plots. Special thanks to Gabriel Contreras, Cody Molisee, and David Van Hack for doing this work
Added Scalable Vector Graphic support to charts, so they can be stored to disk.
Added a series of windowing functions (kernel functions) for use in Violin Charts
Modified DataFrame to account for line charts and violin charts as part of the selection system.
Added extra Copy operations to the DataFrameColumns to make it easier to Copy and Sort unique items
Added a CrossTab action to DataFrame, which creates a CrossTab DataFrame from two column selections
Added a CrossTab Transform class that can calculate the CrossTab Transform to a copy of the DataFrame.
Fixed an issue with ScatterPlot to cause it to not respect the ColumnInput selections commonly used amongst all charts and graphs
Updated documentation for ScatterPlot to indicate the changes.
Fixed an issue with several files in the standard library having incorrect packages.
Fixed an issue where CumulativeDistributionAction was misspelled CulumativeDistributionAction in the class name. The standard library scanner was displeased.
Moved StatisticsFormatting to the Libraries.Compute.Statistics.Reporting package.
Added a multi-column sort function to DataFrame
Fixed some of the usability and visuals of Legends
Added input options for multiple columns, one factor and two factors in bar charts and histograms
Added Bar and BarGroups to allow for unstacked BarCharts
Updated the accessibility navigation and text in bar charts and histograms
Added input options for multiple columns, one factor or no factors in line charts
Added text or numerical factor data in line charts
Made some introductory improvements to line density in line charts, although this needs more work.
Added input options for multiple columns, first column defaults to x-axis in scatterplots
Added text or numerical for all data in scatterplots

Accessibility Changes

Fixed a bug where selecting to the beginning of the line would select white space when it wasn't supposed to using SHIFT + HOME
Added first letter navigation for several components, includings trees, lists, and tree tables
Added a property in Quorum Studio to adjust the type ahead speed
Added the ability to adjust the first letter navigation speed inside of the game class. This allows people with disabilities a way to control the speed of type ahead in controls
Added menu mnemonics and the ability to change them in the standard library
Added Mnemonics to Quorum Studio's menus
Added the numpad enter key for certain operations

General Bug Fixes/Changes

Fixed a strange bug in file writing where if you tried to append to a file, it would append to the wrong location under certain circumstances.
While we had a temporary hotfix previously, we have officially added support for Big Sur into Quorum and Quorum Studio.
Refactored Font loading to remove a strange loading procedure that was causing operating system compatibility problems.
Changed Labels so they do not try to load a font in their constructor. Now, if GetFont is called, and no font has been loaded, Label chooses a sensible default. This change allows you to change the default Font loading directories for custom operating system or application installs.
Fixed a bug in code completion that caused a crash under strange circumstances
Fixed a bug causing Quorum Studio to not properly log a crash under various circumstances
Fixed a bug in Quorum Studio causing it to set a main file to a non-quorum file. This was, uh, bad, and not at all what it was supposed to be doing. Children were sad and garden gnomes took over. It's fixed now, Rory and Michael. Special thanks to Amanda too.
Reduced the size of the standard plugins in the standard library by 20.7% by removing dependencies related to Antlr.
Added a new action called GetSecondsSinceStart, which allows the user to request how long it has been since the game was created.
Fixed a long-standing bug in the graphics system causing interface components in a 2D layer to sometimes appear "blurry." This rather annoying bug would show up especially on non-high res monitors or under certain kinds of screen and zoom resolutions and was especially common on Windows. Any component should now be slightly crisper, but font rendering especially has been considerably improved.

Quorum Studio 2.3 October 16th, 2020

Quorum Studio 2.3 is a significant bug fix release and we highly recommend upgrading. Many systems have been worked on. Specifically, this release includes improvements to Android support, code completion, the text editor, and the data science libraries.

Fixed a bug in code completion where lines with use statements or package files, but no class yet defined, would incorrectly fail early.
Fixed a bug in code completion where certain classes would not show up in detecting what actions can be called (e.g., Drawable).
Fixed a bug in code completion where if you had an action with a particular name, plus a left paren, it would double up and embed the name a second time when you pressed enter.
Fixed a crash bug in code completion when you have certain characters in the character stream.
Fixed a bug in filtering where the compiler could get in an intermediate state, due to threading, and the user interface would incorrectly ignore the request.
Fixed a bug in code completion where the standard library was being incorrectly ignored in certain parse configurations.
Changed the default functionality in code completion when creating a use statement. It now adds a dot and re-pops the window back up.
Added context awareness to popup completion in package and use statements. If a completion is at the end, code completion will not add the dot, both for class values and 'all' statements.
Fixed a bug in code completion where certain classes were not showing up in use and package statements
Fixed a bug where the root package, Libraries, in Quorum would not show up in code completion.
Changed the graphics for packages in the code completion interface. They are now orange squares.
Changed the color of private actions to be magenta and reversed the direction of the arrow.
Changed the color of actions to be blue in code completion.
Changed the sorting behavior of code completion for classes and packages. By default, packages now show up before classes and are sorted separately.
Changed the sorting order in code completion for primitive values, which have been pushed below actions.
Fixed a bug in code completion where private actions and variables would show up even in situations where they were not supposed to.
Fixed a bug in code completion where filtering as you type would, all of a sudden, stop providing correct values.
Fixed a bug in the code completion menu where the system would incorrectly close the window as you are typing and reset the focus.
Added a feature internally to code completion making it easier to detect the parse configuration currently in the compiler. This makes it easier to detect when the system is managing information in another thread.
Fixed a bug in code completion where the system would sometimes default to a previously known parse configuration too aggressively.
Fixed a bug in code completion where parent variables would show more information than they are supposed to. Now, when you type parent: it will show you each parent and any field that is available.
Fixed a bug in code completion where parents would not filter properly.
Fixed a bug in code completion where sometimes parents would override standard filters, causing the user to see only parent variables
Pressing the help keys for items in code completion now reads out any description from the Quorum documentation about the action or field. If that action or field has no description, nothing is read. For many actions, this gives a screen reader user more information on what an action or field can be used for.
Fixed a bug in the text box where you could not navigate to the defining class for fields
Fixed a bug in the text box where use locations for variables would not allow you to jump to the definition location
Fixed a bug in the text box where constructors were being ignored in regard to their jumping behavior
Added a way to create a folder from the project tree in Quorum Studio.
Changed the basic ideas behind DataFrameColumn objects. Previously, we were trying to avoid directly iterating over these items, thinking we could avoid it in other ways. In practice, however, it was impractical, and as such these structures have been provided a series of new actions for manipulating them. All previous actions are still supported and we imagine more changes are coming as the broader data science libraries are fleshed out.
Fixed a bug causing Quorum Studio to fail to send an APK file to android devices on Mac.
Fixed a bug causing Quorum Studio to issue the wrong Android translation command on Windows.
Significantly improved the error reporting and console output for Android translation. It now gives you much more information as to what you are doing and tells you whether it succeeded or failed.
Added a log file for any build from Android. The location is placed in the console after a build.
Fixed a bug causing applications built in Quorum 8 latest to crash on Android.
Changed the default Font system to use FreeType on Android. This allows a much wider variety of Quorum's standard library to be used on the platform.
Fixed a bug causing File IO to sometimes report incorrect information if the files were placed in Android's asset manager folders.
Added a series of new plugins related to File IO on Android
Cleaned up the default Android Gradle materials.
Fixed several bugs in the properties dialog related to asset files on android.
Fixed a bug causing font colors in buttons to not show up correctly.
Labels now set their description field for accessibility by default. This way, if a label is told to accept focus events, screen readers have more information.
Added missing functions to the button class to set the label directly without using the name field.
Added an action to buttons that allows you to load an image more easily. The action is named LoadImage.
Fixed several bugs in textbox selection, which were causing a crash under weird conditions related to the home and end keys.
Fixed an issue where physics objects didn't update the position of children items
Added a calculation for Skew
Added a calculation for Kurtosis
Added a way to gather z-scores for an entire column.
Added a test for the Pearson Correlation.
Added a test for the Spearman correlation.
Added a transform to convert to ranks.
Added a calculation for Inter-quartile ranges.
Began changing naming conventions across test classes so that all of them have a consistent format. In this version, this changes the regression class and will impact others over time. These changes do break backward compatibility with the library. Given this library is experimental and documentation will not be written for it until it has gone through more rounds of review, we are pushing up these changes now.
Changed the variance calculation to automatically calculate a mean if the mean was not set. It is slightly less efficient if calculated this way, but is optional and feels more intuitive. This was requested by a user.
Added a class for calculating the standard deviation. Technically, you can calculate this from the variance, but having a class by this explicit name was a user request.
Added custom input classes, ColumnInput and FactorInput, which standardize the way you send information to the various transforms, calculations, and other operations. Not all classes have been converted, but as we continue refining these classes, we suspect they will be.

Quorum Studio 2.2 September 8th, 2020

This release adds in some new features related to data science. Notably, we have added some charting procedures and made some quality of life improvements to the data science libraries as they are developed internally.

Added Bar charts, Histograms, and Scatter Plots. Each of these plots generates graphs that are both accessible and visual. This is an initial release for feedback as our data science libraries are created.
Added several helper classes for creating plots from a data frame, with names like BarChartCreator, HistogramCreator, and ScatterPlotCreator.
Added an InterquartileRange class in the statistics packages
Added a Summarize class in the statistics packages
Added the ability to save into the DataFrame using a saving architecture.
Added a ToText action to the DataFrame, which by default outputs any dataframe as CSV format
Added a way to convert and adjust columns in data frames more easily. The purpose of this was to make it easier to create better transforms
Fixed a bug in Git support not allowing cloning on Windows
Fixed a bug in Git support that could cause a crash on certain kinds of diffs.

Quorum Studio 2.1 August 4th, 2020

This is a sum up release for a wide variety of changes to Quorum Studio. Note that we did not produce release notes for Quorum Studio 2.0.1 and 2.0.2 and these notes only reflect a summary of changes between that version and 2.1. All of these changes were made during the Microsoft Hack for Good Hackathon in 2020. We focused exclusively on accessibility and based decisions on what to work on on interviews with users at EPIQ 2020 and broad community feedback since the release of Quorum Studio 1.0. There is still more to do, but we feel as if these changes were a huge success. Notably, we were able to conquer most of the major remaining stability issues in the accessibility system. On our end at least, the major components are working much more smoothly, and consistently, with screen readers. Here is the list of changes:

Rewrote the textbox accessibility components. It should now be much faster across the board, in addition to being far easier to maintain.
Fixed a bug causing textboxes to sometimes get out of sync between the accessibility and graphics system
Consolidated the native components for text fields and textboxes
Fixed several bugs in keyboard affordances with the textbox
Fixed a bug causing several keystrokes to not work properly in text fields
Made adjustments to the way text fields work in the accessibility system
Fixed a bug causing Narrator to not work with textboxes
Fixed bugs related to braille displays and textboxes
Fixed a bug that could potentially cause screen readers to not recognize Quorum interfaces as a UIA component, forcing you to ALT tab or restart a screen reader
Fixed a bug in the bootup sequence of Quorum, which was causing a black screen to appear for a short moment
Fixed a bug in the startup sequence of Quorum causing accessibility to trigger at just slightly the wrong time
Fixed a bug causing events to fire through the accessibility system before it is ready to process events
Fixed several bugs in the shutdown of the accessibility system. These could sometimes cause Quorum Studio to hang when it was closed
Fixed a bug in the scene editor causing items to read inconsistently in screen readers.
Fixed a bug causing the scene editor to not work correctly in Narrator
Changed the read properties in the scene editor to try and make it easier to use in a screen reader
Fixed a bug in the splash screen causing the super adorable phrases to come out at the wrong time or inconsistently
Changed the loading screen messages to follow semantic prioritization. They are now shorter and easier to understand
Fixed a bug in the splash screen system that was causing it to send update requests on the wrong thread
Fixed a bug in the splash screen screen causing the progress bar to read in an irregular fashion. Note that while the properties of the progress bar are correct, screen readers individually choose the exact phrases they read
Fixed a bug causing cells to state the wrong phrase in tables
Improved semantic prioritization of cells by changing the read order
Fixed table keys in tables. Note that each screen reader implements these differently and not all may equally respond to UIA tables or even support table keys
Fixed a bug causing tree tables to just say "Cell"
Fixed a bug causing the compiler error table to sometimes crash or send you to the wrong spot
Removed several providers from tables, which were causing them to read slightly strangely
Changed the default providers for tree table.
Rewrote from scratch the dialog properties in UIA
Change the providers and properties dialog boxes sent. Note that these properties are now correct and while all screen readers should properly read them, not all do. We are confident this is a bug in some screen readers, not others. For example, while Narrator does correctly read the box and is compliant with the properties, NVDA 2020.2 appears to connect to the top-most HWND window pointer, thereby incorrectly reading the entire window
Fixed a bug causing Accessibility notify events to not properly be read. Note that now, for important reasons, any accessibility Notify calls will be ignored in the CreateGame action in a Quorum Game. All calls to this action need to be done after CreateGame has completed.
Fixed a bug causing NVDA to throw exceptions sometimes in the bootup sequence

All of us on the Quorum team want to give our extra special thanks to Microsoft for hosting us in their Hack For Good Hackathon this year. We would especially like to thank Matt Campbell, who besides being a wonderful person to hack on accessibility with, really helped this patch knock it out of the park. All of us hope you all enjoy the changes as much as we enjoyed hacking on them!

Quorum Studio 2.0 July 10th, 2020

Quorum Studio 2.0 is the first major upgrade to our new development environment for Quorum. It includes major changes and upgrades across the board, which we outline below.

Scene Editor

Quorum Studio 2.0 includes a way to create accessible 2D games. How to make 2D games accessible is a major challenge and we suspect we could iterate on this design for decades. In the first version, we have focused on a scene and Palette tabs, which live in the project tree, and that allow you to either drag and drop or, with the keyboard, create maps, place characters, and set properties in a scene. Physics and many other things are controllable from a game and Quorum 8 natively understands these scenes in the game engine. These scenes can then be loaded in a native Quorum game. We find it to be much easier to create games in this new version.

Besides the features, we have included some default art in the Palette for creating games and have created a series of tutorials on how to use the system. More information about how to use it is located on the scene editing tutorial page. Finally, while 2.0 is adding only 2D support into the grid, 3D support is almost finished and already accessible. We have a few more features to finish there before release and users can expect that 3D support will be added in a few months.

Git support

We have added basic support for the Git version control system. This includes being able to push and pull repositories from Github or Bitbucket, annotations in the file editor showing file differences, and other operations. We have updated the documentation for Git support on the tutorial page.

Editor Upgrades

We have significantly improved the editor experience for Quorum Studio 2.0. There are now keyboard navigable annotations that show up in the editor, which indicate information like hints or Git file differences. In addition, we've improved performance and squashed a bunch of bugs in the editor. We have also included some accessibility hotkeys to give screen reader users more information about where they are in the editor. These keys are hooked up to a few other components as well and provide summaries or location info. This is especially useful, we think, in the accessible scene editor.

Auto-update

By popular request, we have created an auto-update system for Quorum Studio. In 2.0, you'll need to uninstall/reinstall 1.1 because of changes behind the scenes, but after that, Quorum Studio can update itself from the Quorum Servers. This also includes a 'live on the edge' track. If you are in the beta program, you can always grab the latest build from the Quorum team. This lets you grab exactly the same version our dev team uses when building Quorum Studio and Quorum. To get it, you can set the beta flag in your quorum studio preferences file. So far, this is intentionally not exposed in the user interface so users don't do it accidentally.

Optimizations

We have made considerable progress on optimization of Quorum Studio. On our end, small projects end up with a memory footprint in the range of 1 gigabyte for the system. For instances of Quorum Studio with multiple large projects open, like reading multiple versions of Quorum's entire standard library, we are getting in the range of 4.5 gigabytes after a day of continual use. CPU usage at idle is now down on our end to values we see that are comparable to Firefox, Slack, or other utilities. Compared to our older Sodbeans, we have calculated that for small projects we have ballpark a 50% reduction in memory usage overall. These numbers vary by operating system and usage, but the point is that we have made big strides this year and this should help the user experience, especially for those of us without access to high-powered machines.

Quorum 8.0

While we will not put out separate notes for Quorum this year, Quorum Studio 2.0 includes Quorum 8. Quorum 8 is largely a bug fix and optimization release. We have continued making the standard library faster, more robust, and more flexible. In addition, we have included integration with scenes right in. Besides this, we have made a considerable number of small changes to the libraries, adding extra actions here and there where we think it makes coding in Quorum just a little bit easier. For optimization, we have integrated a great deal of the improvements on memory and processor consumption into the standard library itself so that all users in the open source community can benefit.

Bug fixes

At a high level, we have made significant improvements across a number of systems. This includes, since our beta in the summer of 2019, more than 300 bug fixes either that we found or that were sent to us by members of the community.

Sodbeans End of Life

The team has made the executive decision to call 2020 the end of life for Sodbeans. We all enjoyed working on Sodbeans and, while it certainly had plenty of flaws and these are why we built Quorum Studio in the first place, it helped us build a community and changed the way we program in many ways. Notably, we could not realistically have built Quorum without it. We also want to thank the members of the NetBeans community, especially colleagues at Sun/Oracle, the old NetBeans Dream Team, or others like Geertjan Wielenga or Tim Boudreau that helped support us so much over the years. While we are super excited about our new direction and having our own toolchain to directly control accessibility has been a dream for years, we would not be here without that community's help and support and so we wanted to say thank you one last time!

Quorum Studio 1.0 December 13th, 2019

The Quorum team has been hard at work on a new development environment for the programming language, which we have code named Quorum Studio. In these notes, we have outlined some of the initial features. Quorum Studio is large and we do not pretend to document all of the features here, but we hope this will give readers the big picture of the first version. As this project has been in development for several years now, we are incredibly excited to get this to the community.

Quorum Studio Projects

Quorum Studio has its own project system. Like its predecessor, Sodbeans, we can create, load, close, build, debug, and take other actions on projects. Projects contain properties and preferences, which can be adjusted and customized. This includes simple things, like a project automatically loading into a Mindstorms LEGO robot, to complex things like loading custom plugins. All major actions that can be done in Sodbeans have been ported over to Quorum Studio.

Quorum Studio Preferences

Like many development environments, Quorum Studio remembers the way you setup the environment and automatically stores, loads, and adjusts these preferences as you use it. Generally, most major systems in Quorum Studio are automatically plugged into this preferences system and users do not need to do anything to use it.

Quorum Studio Installer

In NetBeans, we had to require behind the scenes and somewhat custom installation of Java and other dependencies, which became complicated as Oracle tightened their license agreements. Eventually, this forced us to recommend users switch to OpenJDK, which made installation even more complicated. Over time, this felt to the development team like this process was getting harder and harder for teachers and students. In Quorum Studio, we bundle the minimal subset of additional dependencies in with the installer on Mac and Windows automatically. Generally, if the installer is used, everything required by Quorum Studio should be included without altering system settings and without any complex additional steps.

Development

Quorum Studio offers many industry standard features for software development. This includes user interface elements like tabbed panes, syntax and semantics highlighting editors, console output windows, breakpoints, compiling, and debugging. We have remapped many of the default hotkeys away from the defaults in NetBeans to make them more intuitive. Normally, we are now using the first letter of an operation as a mnemonic. For example, running a program would be COMMAND + R on Mac or CTRL + R on Windows. Many other hotkeys have been default remapped similarly.

Editing

Editing source code in Quorum Studio has many common features, like syntax highlighting, semantics highlighting, editor hints, code completion, and other features. There are new editor hints compared to Sodbeans, like automatically generating getters and setters, and old ones are retained, like automatically generating use statements. Some of the color choices are now slightly different, like the use of purple to imply constructs that have a matching component (e.g., if and end).

Accessibility

As always, the Quorum team cares deeply about accessibility. Quorum Studio is built on the hardware accelerated graphics platform in Quorum itself, which automatically connects down for accessibility (e.g., to screen readers). Besides screen reader connections, we have smart zooming features, keyboard shortcuts for a great deal of operations, and have worked hard to make navigating around the environment accessible and intuitive. In our first release, we only support screen readers on the Windows 10 platform. If we are lucky, we'll be able to raise enough capital to add other platforms over time.

Quorum 7.5

While we normally put out new versions of Quorum once per year, this year we are making an exception and putting out Quorum 7.5. By far, the biggest changes are significant additions to the user interface libraries, which form the foundation of Quorum Studio. This includes, especially, a near complete rewrite of the accessibility backend. Some of the major changes include altering how the graphics system connects to the accessibility systems and adding a variety of helper actions for providing context to the accessibility system. For example, it is possible to now directly ask a user interface component to send an accessibility event, even if the on-screen graphics is doing something different. This, and many other features, is incredibly useful for a wide variety of potential applications.

A Quorum environment written in Quorum

Quorum Studio is written in Quorum 7.5 from the ground up. The development environment we are using to build Quorum studio is also, you guessed it, Quorum Studio. This means that at this point we are eating our own dog food for the full pipeline, including for evolving the pipeline. To put this in perspective, Quorum's compiler is written in Quorum, our standard library is in Quorum, and now our development environment is too. As we have slowly built up and built out our environments, this has made it easier for us long-term to make progress on the project as a whole and to cut our reliance on third party tools, which cannot always be relied on for accessibility.

Sodbeans deprecation

While we are excited about the release of Quorum Studio, with it comes just a tiny bit of sadness with the official deprecation of Sodbeans. While Sodbeans was always just a NetBeans derivative, with some accessibility enhancements and Quorum support, it was never as accessible as we wanted. It helped us start a community, but over time NetBeans was showing its age and was actively standing in the way of the innovations we wanted to make. As such, with the release of Quorum Studio, our development team has made the switch internally and we now use it exclusively for Quorum development. Further, NetBeans is no longer supported for the Quorum programming language and we do not plan to maintain it further. Schools and community partners can continue using it as they see fit, of course, but we suspect many partners will also make the change as Quorum Studio gets off the ground and matures over time.

Thank you

As a final note, we want to provide a thank you to the community. Building this technology was a long, multi-year process. It took way longer to invent than we imagined and there were considerable technical and human challenges along the way. A ton of community members participated in our beta programs, many of you before Quorum Studio was really ready for prime time. Especially, we would like to thank Sina Bahram (Prime Access Consulting), Matt Campbell (Microsoft), Ameer Armaly (Google), and all of the amazing teachers at the 2019 Experience Programming in Quorum workshop. Crucially, we also want to thank the National Science Foundation, which made it possible to fund this crazy adventure in the first place. Your feedback and support, whether through financing or feedback, was essential and we truly cannot thank you all enough.

Quorum 7.0 July 12th, 2019

Quorum 7.0, and its corresponding sister release, Quorum Studio 1.0 Beta, is a far-reaching and massive update to the programming language. Many systems have been adjusted and changed with many new libraries being added as well. At a high level, this includes: 1) significant changes to how accessibility is handled internally, 2) finishing off and in some cases rewriting many aspects of the user interface libraries, and 3) significant optimization efforts across the board. Many of these changes were created in order to make Quorum Studio work effectively and be accessible. We will not outline all of the changes, as there are too many, but these notes will provide a high level overview.

Accessibility Changes: Across the board, accessibility has received a major rewrite this release, in part to support Quorum Studio, but also to make games more accessible. Some changes will be discussed in the user interface section, but we highlight others here. Like previous releases, as of now we only have funding to support writing native operating system calls for accessibility on Windows.
- Significantly improved delays in the accessibility system. These were caused in part because of a bug in Windows (confirmed to us privately by Microsoft), which the team found a workaround for. Notably, in Quorum, vsync must be off for proper accessibility support, including any games written by users of Quorum. We realize this makes no sense, but it works and appears to be a bug in Microsoft's opengl implementation.
- Significantly improved the speed of many components in an attempt to make interface components (e.g., buttons, 3D models) smooth to use with a screen reader. This is tricky because the animation and the operating must 'sync up' in how they connect. This means newer computers with faster frame rates, while counterintuitive, could be more accessible.
- Significantly improved the UIA implementation of many components. This causes them to read more effectively in various screen readers. Not all components are perfect and we are still working on some of them, but it is a significant improvement across the board.
- Fully bypassed the Java Access Bridge. It is no longer used, in any capacity, in Quorum and has been replaced with our own accessibility architecture. This system is what makes it possible for us to create Quorum Studio.
- Improved how we connect with specifically NVDA. Other screen readers do not work as well and are harder to test with because they are not open source.
- Created a new system to automatically organize graphical components semantically. Items can now declare to be an 'accessible parent' which organizes them internally for a screen reader. This provides the programmer a good deal of control in organizing components for a screen reader.
User Interface Changes: The changes to the user interface system in Quorum 7 are so large that we cannot possibly list them all here. We will try to balance giving the big picture of the changes, while also mentioning some low level features. Overall, many components were added to accessibility and a great deal of graphical changes have been added as well.
- TextBox: Textboxes have been significantly improved across the board.
- TabPane: Added focus targets so that when the panes or the tabs get focus, keyboard users are placed someplace sensible by default, chosen by the component. We also added a hotkey to kill a tab by default, which is CTRL + W or APPLE + W. Finally, we added Accessibility support for tab panes, which were missing last release
- Buttons: We made a number of minor improvements to buttons, including in layout, accessibility, and graphics
- Layout: We rewrote the layout system from scratch to make it easier to use. By default, most components now use a flow layout, like the web
- Checkboxes have been added as a new component
- Radio Buttons have been added as a new component
- Lists have also been added
- Tree: Trees now have icons and improved accessibility support
- Text Fields are now in the build as well. By default they have one line and move focus when tab is pressed.
- Menu: Menus in Quorum were buggy and they have been significantly improved in general. This includes improved accessibility support and a wide variety of other issues related to keyboard navigation, clicking, shortcuts, and other features
- ScrollPane: This component was rewritten to account for changes throughout the rest of the system. It should now do a better job of controlling and clipping items within it.
- Dialog: There are now dialogs, both modal and non-modal in Quorum, including accessibility support and default behaviors.
- File Chooser: Added a component for choosing files and folders
- Spreadsheet: This is a new component that acts as a table
- Tree Table: This component is similar to a properties window
- Smart Zoom: Added an interface scaling system to zoom in and out without pixelation
- Keyboard support: We have spent considerable time on keyboard support in the primary components. This is to make sure that if you are building a user interface that a keyboard user can get around.
Optimizations: In initial testing of Quorum Studio, we observed it was far too slow and we thus spent considerable time optimizing the graphics engine. This takes several forms:
- Significant improvements to memory usage, which considerably, and in some cases massively, reduces the amount of garbage collection Quorum does behind the scenes
- Significant improvements to physics and its memory optimizations
- Significant improvements to memory optimization in certain components, especially the textbox
- Significant improvements to render speed for the textbox. Internally, we are seeing an approximate 10x improvement to render speed
- Significant improvements to memory optimization across the graphics engine in general
- Significant speed improvements in the game engine broadly.
- Change the default font system to use image sheets on a per font level. This speeds up textboxes significantly.
Documentation changes: We made a wide variety of changes across the board to our documentation. We highlight some of the biggest changes that went onto the site below:
- Per request of the College Board, we made a number of accessibility improvements on the site. This included quite a few changes to the Computer Science Principles web pages
- Added quite a few new tutorials on the interface system
- Did an edit pass on all of the existing user interface tutorials, updating them to Quorum 7 and simplifying them quite a bit.
- Added in some accessibility relevant information into the interface tutorials, accounting for the new accessibility system in Quorum 7
- Rewrote the android setup tutorial and updated it to the new version
- Added a tutorial on vibration in android
Android: We did not change a lot on Android this year, but we did make some improvements.
- Significantly improved the Android vibration libraries to account for measurements on human perception taken with a Laser Doppler Vibrometer
- After analysis and code reviews, we significantly changed the Android vibration library's interfaces. This breaks backward compatibility, but the team thinks it will make it easier to use in practice. Part of the reason is that it was previously easy to create vibration patterns that humans cannot perceive, which we evaluated in formal studies. This is now harder to do accidentally.
- Added a variety of default vibration patterns to the library that can be used out of the box. We think this will make it easier to create vibration patterns that are known to be perceptually distinct
Quorum language changes: While we avoid breaking backward compatibility broadly, as those familiar with the project are aware, since Quorum is an evidence-based language, we are up front that we may choose to break it once per year. This year, we made a number of changes that are not compatible with Quorum 6 and these changes were made because of critical performance improvements that were needed for Quorum Studio. Other minor language changes are listed below.
- The object class has removed the CompareResult class and been replaced with an integer. We are unclear from a human factors perspective which was easier to use, but creating CompareResult objects was a major bottleneck on various operations in the game engine. We did not really want to change it, but we felt like we had to. Users now just have to 'know' that a 1, 0, or -1 indicates the relationship between objects given in a compare.
- Made a variety of memory optimizations. This included making some specialized arrays that handle memory differently. Unfortunately, this temporarily breaks the JavaScript side of the game engine, which means online support will remain at Quorum 6 until we can complete the work. This, again, was crucial for performance in Quorum Studio and dramatically reduces the memory footprint in the game engine. We mention it here because these changes were core to the compiler.
- Added specialized arrays for particular types. We think a better solution would include changes to Quorum's type system, but this removes the performance bottlenecks we've encountered and may be re-evaluated in Quorum 8 or 9.
- Fixed a number of minor compiler bugs.
- Updated the bootstrapping process for Quorum 7, which has also been fully automated in Quorum Studio 1. This is incompatible with bootstrapping in Quorum 6 and earlier and we highly recommend anyone bootstrapping to use Quorum 7 to bootstrap Quorum 7, as switching between the two is highly non-trivial.

Quorum 6.0.5 - 6.0.7 July 21st, 2018

Fixed an extraordinarily rare, but nasty, compiler bug triggered by hash resizing in transitive dependencies.
Fixed a bug in the 3D camera related to mouse and touch input.
Improved performance of the array class.
Fixed a variety of bugs in the JSON classes.
Added binary file downloads into the network reader.
Set the default network request to chunk mode.

Quorum 6.0.1 - 6.0.4 July 14th, 2018

Fixed a bug in Quorum 6 where we accidentally turned off the speech engine both offline and online.
Fixed a few bugs in the new accessibility system for Windows 10 64 bit on the native level.
Fixed a crash bug in the new accessibility manager class.
Removed debug output from the accessibility manager.

Quorum 6.0 July 2nd, 2018

Quorum 6 is part of a two-year release cycle for the language, adding a great deal of new backend materials, a new user interface library, significantly improved accessibility support, android support, basic network services support, and other features. Because many of the feature requests for our usual yearly cycle were so large, some we implemented about half in the first year. This is especially true for user interface support, with a good chunk of important interface elements included now, including the backend, with the rest planned for Quorum 7.

Further, as part of Quorum 6, we are hard at work on a new Integrated Development Environment (IDE) for the language, which we have code named Quorum Studio. The reason we did this is several-fold. First, by building our own interface libraries, we can directly control the accessibility pipeline, providing us far more freedom in research than was ever possible using NetBeans and Swing. Second, we also want to provide a way for the 'output' of the code people write to be natively accessible, even for highly graphical 2D or 3D content. Finally, NetBeans itself was moved to the Apache Foundation from Oracle. From a licensing and governance perspective, that's reasonable, but whether the environment will be financially supported, and for how long, is uncertain. As such, while NetBeans will not be supported in Quorum 7 and beyond, we expect all future releases of Quorum to be available in the console, on the web, and on the desktop in Quorum Studio.

Below is a list of all major features in Quorum 6. As usual, the list abridged to provide the highlights:

Android Support: We have added support for Android devices. In order to use it, you must accept the license agreement from Google and download their development libraries. Once this is complete, Quorum can convert itself to an Android compatible binary and run on a device. Primary features are:
- Game and graphics support: Normal game events, including all of the new features, are now support on Android
- Vibration controller support: This is a custom Vibration library designed to allow for various kinds of vibration events and patterns.
- Soft Keyboard Support: This includes basic support for opening a keyboard and letting a user type into it
- Font system: We have our own internal Font system for Android, as part of our goal to remove the FreeType library, which cannot be used across all our supported platforms.
- Sound: Android devices only support Stereo sound, so far as we can tell, but sound is supported on these devices as well.
User Interface Library: We have developed a custom user interface library for Quorum, based on our own toolkit. The broad purpose of this was, besides it being a top request, that it allows to create our own accessibility libraries inside of Quorum's game engine, which bypasses Java's accessibility libraries on desktop and gives us considerably more control.
- A wide variety of widgets are supported in this release, with the rest scheduled for Quorum 7. For Quorum 6, this includes:
  - Libraries.Interface.Controls components, like Textboxes, Scrollpanes, Menus, Buttons, Tab Panes, and Trees
  - Libraries.Interface.Events, for knowing when the selection, focus, events, or other properties change in a user interface
  - Libraries.Interface.Selections contains a variety of classes for getting the current selection from components. For example, this might tell you what node in a tree is selected or what part of a text editor is selected.
  - Libraries.Interface.Vibration can be used on supported mobile platforms to cause the device to vibrate
  - Libraries.Interface.Behaviors is a package for many of the default behaviors seen in user interface components
  - Libraries.Interface.Layouts lays out the components into sensible configurations. It attempts to be screen size responsive, but more work is needed in this package.
  - Libraries.Interface.Mobile currently only contains one class, for the soft keyboard, but is a placeholder in case the community wants to add more in the future for other sensors.
  - Libraries.Interface.View allows you to make different looks for components without them being part of the event infrastructure
  - Besides these packages, we have added a significant number of support classes for routing events, actions for components, and other things. The InputSet and InputTable classes are relevant for these.
- Custom accessibility engine for the widgets. This allows the user to customize their games with accessibility support, allowing out of the box screen reader support.
  - Currently, this is routed through UI Automation control on Windows. We hope to add other platforms for accessibility in the future.
  - Most interface elements are supported
  - Users can create custom components in games, like 3D models, and make them accessible by declaring them to be 'custom' graphics objects.
Quorum Compiler Improvements: Significant improvements have been made to the Quorum programming language itself, focusing on performance.
- Build times inside of NetBeans or Quorum Studio are significantly improved, sometimes by 20x or more. This is caused by a new build caching system in the compiler and improvements to a variety of algorithms.
- Clean and Build, even though it rebuilds everything, is still faster than before
- Several improvements to code completion in the development environment
- Significant performance improvements to parsing performance inside of NetBeans or Quorum Studio
- Quorum now outputs the jar file and cached versions of the standard libraries and standard plugins files. These must be included in any distribution of the binaries
- The console compiler has also seen performance improvements, although they are less drastic then inside the development environment. The reason is because the console cannot cache in quite the same way.
Networking Support: This release offers the beginning of Networking support for Quorum. As a first step, we have added a library somewhat like AJAX, with the intent of letting the user consume online services (e.g., google maps, spreadsheets) and using them in their applications. We built this as part of a separate National Science Foundation grant called IDATA.
- Build times inside of NetBeans or Quorum Studio are significantly improved, sometimes by 20x or more. This is caused by a new build caching system in the compiler and improvements to a variety of algorithms.
- Clean and Build, even though it rebuilds everything, is still faster than before
- Several improvements to code completion in the development environment
- Significant performance improvements to parsing performance inside of NetBeans or Quorum Studio
- Quorum now outputs the jar file and cached versions of the standard libraries and standard plugins files. These must be included in any distribution of the binaries
- The console compiler has also seen performance improvements, although they are less drastic then inside the development environment. The reason is because the console cannot cache in quite the same way.
Lessons, Tutorials, and Documentation: We've improved documentation again.
- We added a variety of new tutorials for the user interface library. These include:
  - Overview
  - Behaviors
  - Buttons
  - Trees
  - Text Boxes
  - Tab Panes
  - Menus
  - Scroll Panes
  - Focus
  - InputSets
  - Layouts
- Added new tutorials for the networking systems
  - Overview
  - GET Method
  - POST Method
  - Request Message
  - Skynet
- New JSON data tutorials
  - Overview
  - Primitives
  - Arrays
  - Nesting
  - Reading
  - Writing
- Added documentation for the Physics and Collision systems. This was previously missing in Quorum 5. Over time, we hope to go back and correct missing documentation issues for more systems in Quorum.
- Began working on a computer science principles course modeled after the one by Code.org.
Miscellaneous additional changes: These changes include general additions that have had an impact in various ways.
- Build times inside of NetBeans or Quorum Studio are significantly improved, sometimes by 20x or more. This is caused by a new build caching system in the compiler and improvements to a variety of algorithms.
- Clean and Build, even though it rebuilds everything, is still faster than before
- Several improvements to code completion in the development environment
- Significant performance improvements to parsing performance inside of NetBeans or Quorum Studio
- Quorum now outputs the jar file and cached versions of the standard libraries and standard plugins files. These must be included in any distribution of the binaries
- The console compiler has also seen performance improvements, although they are less drastic then inside the development environment. The reason is because the console cannot cache in quite the same way.

Finally, because our release cycle this year is unusual and we are at the halfway point for parts of the project, there are several known issues. This list this thus includes a few known bugs that will be fixed in a patch as well as some features that are being worked on currently.

Android: Debugging support is available for Android, but the code for uploading Android apps to the app store, through what is called a signed APK, is not yet complete. We are nearly finished with this and expect it will come out in a patch.
User interfaces: Several commonly used user interface features are not finished yet. In some cases, the backend for these features is finished, but not the user-facing or accessibility code. These include Lists, Checkboxes, Radio Buttons, and Tables
Accessibility: Out of the box accessibility support is only available on Windows in Quorum 6. Self-voicing apps can be made quite easily by listening to the events on the backend, but accessibility systems on Mac, Linux, and elsewhere are not compatible with each other in their native programming languages/environments and will require significantly more labor. We welcome external teams interested in collaboration for their particular platform to get in touch.
Android Tutorials: We are still finishing up the tutorials on how to use Android Devices with Quorum. We suspect they will come out before our National Conference (Experience Programming in Quorum).
iPhone support has been disabled for now and the tutorial is off the website. Unfortunately, the tool we were using, called RoboVM, was purchased by a third party and made closed source. Alternative versions are appearing, but we do not support them at this time. Given Apple's recent announcement of deprecating OpenGL, iPhone support for Quorum in the future is unclear.
Android devices do not support 3D audio by default, including distance attenuation, doppler, or listener positioning. Android only supports panning between the left and right channels.

Quorum Patches

This is a list of patches pushed to live. For small patches pushed by the team, we sometimes write notes for the last several. This should be considered an abridged list of changes.

Quorum 5.0.13 September 15th, 2017

We made a small patch to Quorum this week and additionally upgraded the website. These changes included:

Added a module dependency system to Quorum, so that we can reference other Quorum projects from within a project.
Fixed a bug on Mac OS X causing working directories in file types to give an incorrect folder while using Quorum in the debugger.
Added an online project system to the website.
The save and load buttons on the website now work differently. Specifically, they now load or save a project that can be shared with others, made public or private, or deleted from the profile page.
Projects built in an online environment can now be embedded on other websites using the embed button.
Added a forgot password link in the login page.
Add a profile page for storing and referencing all of your online Quorum projects.
Fixed a few other minor issues on the website (e.g., broken links, typos).

We would like especially thank Sarah Judd at Girls Who Code for helping us in the design of the new project system.

Quorum 5.0.11 June 2nd, 2017

We fixed a bug on Desktop that caused the IsPlaying action in Audio to crash if used while streaming AudioSamples.

Quorum 5.0 June 1st, 2017

Quorum 5 is the next significant update to the programming language. Notable enhancements include a new physics system for 2D and 3D games and a new digital signal processing engine. Finally, we have significantly improved web support and now much of the language can be run in a browser, on iPhone, or on Desktop.

Embedded Physics: We now include a physics system that allows more control over real-time games. This system, inspired in part by the open source projects Box2D and Bullet, is unified to be similar across different kinds of games, using our own architecture. It allows the developer to use common physics properties such as force, restitution (bounciness), and friction to move objects in more realistic ways. Further, the system includes a system of joints to represent complex physical interactions (e.g., ropes, springs).
- Games may use built-in physics simulation for both 2D and 3D games.
- The new physics engine allows for consistent physical behavior to be applied across all items on a layer, such as gravity and realistic collision behavior.
- Using physics does not require understanding the related mathematics and is intended to be used even by high-school aged people.
- A series of tutorials on how to use the physics system has been added.
Digital Sound Improvements: We now include a digital signal processing engine with real-time support for manipulating audio on the web or desktop. This system provides low level access to sound samples and a variety of support actions.
- Added the AudioSamples class, which can be used to manually interact with low level audio data.
- Added a queued audio system that allows users to supply and adjust audio data while it is in use in real time.
- Added microphone support to the audio system.
- Added controls to the Audio class, which allow the programmer to adjust how far sound can be heard from an audio source’s position and how quickly its volume decreases over distance.
Quorum on the Web: We have finished a major initiative to allow Quorum to convert itself to JavaScript. The broad purpose is to allow people using Quorum to create applications and put them up on their personal websites, in addition to making more of Quorum runnable online.
- Finished a Quorum to JavaScript converter that allows a vast majority of the specification to be run online. One exception is that errors do not provide quite the same information as they do on desktop platforms.
- Games written in Quorum can now be deployed to the web.
- Most audio features, including the new digital signal processing libraries, are now supported on the web. A small number of Sound libraries (i.e. the MIDI libraries) are still only available on Desktop.
- Some of the online development environments now support running games from within the browser. Online environments that support the feature contain an OpenGL canvas (basically a big box) below the environment. We only include the box for environments where it is relevant to the tutorial or lesson.
- There are a few differences with programs compiled to the web, which we have minimized as much as we can. For example, Labels are not yet supported in games and the files are loaded differently in some cases due to JavaScript's loading mechanism within a browser.
Website Changes: We have finished a major overhaul of the website. Notably, all content is now organized into a set of organized tracks. We made this decision both from community feedback and analytics data on how people are using the website.
- While remaining accessible, we have significantly improved the 'look' of the Quorum website to be more modern.
- There are now four tracks for curriculum:
  - Core: This track includes foundational information about computer science.
  - Visual: This track focuses on creating highly visual applications.
  - Audio: This track focuses on creating auditory or musical applications.
  - Robotics: This track, which gears somewhat younger than the others, is based around LEGO robotics using the Mindstorms toolkit.
- The site has been significantly reorganized, based in large part from looking at analytics data on how users are engaging with the material
- The reference page has been re-organized to make material easier to find.
- Improved the online development environment to better support games and audio.
Lesson Improvements: We have made significant improvements to the online lessons and tutorials used for learning or teaching Quorum. This includes:
- The addition of online development environments embedded into many lessons.
- Making the overall mapping to Computer Science Principles more obvious as a whole.
- Added a mapping to common core.
- Improvements to the text and content of many lessons. Some were modified and improved, while others were rewritten from scratch.
- Made it more obvious how lessons 'could be' ordered for learners or teachers.
General Game Engine Changes
- Multiple full screen resolutions are now supported through the ScreenResolution class, and the game window may now be resized or made full screen while the game is running.
- Skyboxes have been added to the game libraries. Skyboxes are a way to make games appear more like a virtual world, effectively creating a 3D background.
- Made a variety of improvements to the Camera class. This includes the addition of Yaw, Pitch, and Roll as controls. Using these actions is not required, but can be simpler for many kinds of games and applications.
A variety of general changes or bug fixes
- Added NetBeans 8.2 Support.
- Added a -javascript flag to the console compiler to convert a Quorum program to JavaScript.
- Updated documentation on the website for the standard library and in the console compiler.
- Fixed several minor inconsistencies in the way flags are passed to the console compiler.
Known Issues
- Microphone support is not yet available on the web.

Quorum 4.0.6 January 21st, 2017

This patch includes a variety of small changes as we continue with Quorum 4. Besides the fixes below, this version includes a new version of the website, which should bring us one step closer to web support for many of Quorum's features.

Fixed an but pointed out by Amanda Rodda+Tyler with the JavaScript converter causing it to not properly popup input dialogs.
Fixed a minor issue with the compiler causing generics to be slightly less strict than intended.
Added SetInput and Empty actions to the textbox class.
Fixed an issue with the textbox causing it to sometimes delete two keys instead of one.
Fixed a spelling mistake in one of the package names.
Continued working on the documentation for the various new systems.
Rewrote the the web library generator for the standard library.
Fixed a variety of bugs in the JavaScript converter.
Fixed a grammatical issue in one of the compiler errors.
Fixed another issue with rotation in the game engine.
Fixed a minor compiler bug causing an exception to be thrown on invalid input.
Fixed a bug pointed out by Pete Lamonica where carriage return and line feed were flipped in the JavaScript converter.
Made some additions to the game engine that will help toward running it on the web.
The website has now been rewritten from scratch. A vast majority of it is now written in Quorum.
Many of the web tutorials have been rewritten from scratch and are now runnable on the web. Some lessons are now runnable online as well.
Made a significant number of accessibility improvements on the website, including with the development environment and in general.
Added an option to compile Quorum to JavaScript from the options window. The feature should be considered Beta until Quorum 5.0
Added several options for changing the screen resolution both in windowed and full screen mode.
Some features from the game library are now supported online.

Quorum 4.0.5 September 9th, 2016

This patch includes a variety of small changes as we continue with Quorum 4:

We have finished the 3D collision system for Quorum 4. This system now works similarly to how 2D collision works.
Added a new feature allowing fonts to have colors other than black. We had planned this feature for some time and are glad to finally have it in the build.
Fixed a bug causing SetVolume to set the volume for all sounds, not the individual instance.
Fixed a bug causing models to scale incorrectly if the object has been rotated.
Added a way to rotate children embedded in a model, which is called RotateChildren in the Item3D class. An example use case might be if we want to do things like spin spheres around a model.
Added an action to Item3D allowing the user to Rotate Around a point in space. This new action is in Item3D and has the following signature: action RotateAround(Vector3 point, Vector3 axis, number degrees).
Added a way to obtain a unique key for each loaded 3D model on the system. To get it, we call GetBlueprintKey in the model class.
Fixed several small bugs causing an error to be thrown for certain keys inside of a text box.
Fixed a bug with streamed and non-streamed audio, causing them to share the same ID. This was causing some programs to have side effects if both were used.
Added an action called GetSource to Mouse Events, which allows the user to determine what fired the event.
We adjusted the SetVolume and SetBalance actions in audio so that they properly clamp values to between -1 and 1.
Many of the examples for SetListenerPosition were incorrect in the online documentation. These have been fixed.
Added a way to connect the game engine into a Java Canvas.

Quorum 4.0.4 August 6th, 2016

This patch fixes a variety of issues found at EPIQ 2016 and after by users. This patch includes:

Made Several fixes to the sound system, including a case where we accidentally flipped the axis in 3D sound for certain helper actions (e.g., rotation).
Increased the number of sounds that can be played at the same time in the game engine.
Fixed a bug causing rotation in the z-axis to rotate counterclockwise instead of clockwise. The other axes had the intended behavior.
Fixed a bug causing rotation hierarchies (e.g., children several levels deep) to not properly rotate.
Fixed a bug causing projects loaded on a networked drive in Windows 7 or 10 to not load game engine projects correctly.
Finished more documentation for the game classes. There is still more left to complete, but this adds quite a bit. Many examples are now included where they were previously missing.
Added actions to get and set the cursor position in a text box.
Fixed a bug in text box causing an exception to be thrown if the user typed a space.
Fixed a minor bug in the compiler causing the system to throw an exception if casts are used incorrectly in a particularly peculiar way.
Fixed a bug causing layers to not properly handle event listeners if a listener is added directly to the item.
Added sphere primitives.
Fixed a usability issue with the Camera class. Its parameter lists were inconsistent, which is now corrected.

We would like to thank Sina Bahram, Pranav Lal, and DJ Prater for their help in identifying some of the problems in the above list.

Quorum 4.0 July 5th, 2016

Quorum 4.0 is the next major update to the programming language. In it, we have provided a variety of new features and improvements for many systems. The highlights of this release include support for 3D gaming (audio + visual), mobile support (iOS only), and significant improvements across the board to the development environment (e.g., navigation, folding). Besides these larger changes, we have spent considerable time making improvements to a large number of systems in Quorum and have expanded on many. This includes the addition of linear algebra libraries, improvements to the existing LEGO libraries, and significant improvements to the design of the game engine. Finally, we have added many new tutorials on a variety of systems.

3D Gaming

One of the major features in Quorum 4.0 is a new 3D gaming system. On the backend, Quorum uses OpenGL, one of several standard gaming engines for commercial games. On the user level, however, we have spent significant effort working with people writing games in Quorum to try and iterate on our design. Overall, the 2D system has been improved and simplified in a variety of ways, the overall libraries have been unified, and accessibility support is now baked in in ways we think are easier to understand.

Besides this, 3D support itself has been modeled similarly to 2D. In other words, with 2D, you could load an image or sound and move it around. With 3D, while traditional modeling applications in OpenGL or Direct3D require quite a bit of knowledge about computer graphics, our libraries try to simplify those aspects of the system that we can. The idea is, besides the added dimension, to make the 2D and 3D systems feel as similar as possible to the programmer to aid in learning. Here are some additional highlights for the new engine:

We added a linear algebra library. The linear algebra libraries include: Matrices Vectors Affine Transformations Frustrum Calculations Planes Quaternions Ray calculations Generally, students do not need to use the underlying mathematical libraries unless they need something specific in their game. However, the full stack is there if people need it.
- Matrices
- Vectors
- Affine Transformations
- Frustrum Calculations
- Planes
- Quaternions
- Ray calculations
Games can now be compiled to mobile platforms. In Quorum 4, we are starting with iPhone support, but hope to add Android support in a patch.
Games now consist of a system of layers. Each layer can contain either 2D, or 3D, content, but may not contain both. Each layer is controlled separately and includes support for both visuals and sound. The application of this approach is that it makes it easier to create independent visuals or aural components, like a user interface on top of a 3D game. Many users will have no need of layers and their use is not required.
Changed the Item class considerably in order to work for both 2D and 3D. Many actions have been slightly altered or moved to either an Item2D class or Item3D class. We tried not to make changes that broke previous games, except in the case where usability testing revealed a system was difficult to use.
Collision system: In focus groups and interviews for Quorum 3.0, users consistently had difficulty with the collision system. For Quorum 4.0, we rewrote the system from scratch. It is now, we hope, significantly easier to use. In addition, we have rewritten the technical side from scratch, now using standard approaches from the scientific literature. More enhancements are planned for the future.

Visual Games

The visual aspect of Quorum has now been significantly improved. We now support 3D games, built on our linear algebra library. We have also conducted significant user testing on creating games with our libraries and have spent considerable time re-tooling them in order to make them easier to use. This was conducted for both the 2D game system and the newer 3D one. To make things easier, we have also unified the libraries for 2D and 3D games, so that the way you interact with them is as similar as possible. Below are some highlights from the visual part of the system.

Cameras: Quorum has now integrated a camera system for both 2D and 3D games. This includes the standard perspective and orthographic modes and the interfaces are unified to make it simpler across dimensions or systems.
Models: We are supporting two different kinds of modeling formats in this first release, namely g3db, the format used by the well known libGDX library, and wavefront's .obj and .mtl format's. We hope to support more formats in the future.
Added in a lighting system. Currently, we support: Ambient lights: In graphics, these lights indicate the overall lighting of the scene. Directional lights: In graphics, these lights indicate the overall lighting coming from a particular direction. Point lights: Point lights are those that can be added to the engine and moved around like any other object. You can also attach them other game objects and they will adjust automatically (e.g., a sphere that emits light).
- Ambient lights: In graphics, these lights indicate the overall lighting of the scene.
- Directional lights: In graphics, these lights indicate the overall lighting coming from a particular direction.
- Point lights: Point lights are those that can be added to the engine and moved around like any other object. You can also attach them other game objects and they will adjust automatically (e.g., a sphere that emits light).
Adjusted many internal classes to account for multiple operating systems (e.g., various mobile platforms).
Added support for 3D textures and materials.
Adjusted the input system to account for changes to all of the others.
Primitives: Like with 2D, we wanted to simplify making basic images and shapes. For 3D, we continued this by providing a variety of 3D shapes that can be loaded easily and by default.
After conducting some internal and informal pilot tests, we adjusted OpenGL's coordinate system to be left-handed instead of right-handed. We then unified this across all systems in Quorum. This has no impact on, but is consistent with, the 2D system.

Auditory Games

In addition to broad gaming features, we have expanded on the auditory system in Quorum. Here are the features we now support.

Added in support for creating 3D scenes. This includes making an "Item" version of sounds that you can attach to the game engine and manipulate in real-time. The application is that it allows you to make a character and walk around a 3D environment.
Added in support to change the listener position in a scene.
Added in the ability to have doppler shift on sounds.
Fully tied the auditory system with the visual system so that the libraries match. This make it easier to create games where, once characters are setup, the sounds automatically set themselves up logically without much input from the programmer.

Development Environment Improvements

This update adds a variety of development environment features. This includes brace matchers, highlighters, a rewrite of the navigator, efficiency improvements, and a variety of other features.

Added brace matching into the development environment. This feature existed in a previous version of Quorum, but was removed in 3.0 temporarily. It is now back and significantly improved.
The navigator system has been rewritten from scratch. The new version now includes: Significant improvements to user behavior like sorting. Improvements to keyboard accessibility. The addition of control structures into the navigator window. The reason this change was made is due to the study run by Baker, Milne, and Ladner. The design of this new system is not identical to StructJumper, but it hits on the key properties and allows you to easily obtain much of the same information accessibly. A fix to an issue that was causing the navigator to be unresponsive when the development environment boots for a short time. A few new visual icons for control structures.
- Significant improvements to user behavior like sorting.
- Improvements to keyboard accessibility.
- The addition of control structures into the navigator window. The reason this change was made is due to the study run by Baker, Milne, and Ladner. The design of this new system is not identical to StructJumper, but it hits on the key properties and allows you to easily obtain much of the same information accessibly.
- A fix to an issue that was causing the navigator to be unresponsive when the development environment boots for a short time.
- A few new visual icons for control structures.
Added code folding into the system. By default, the folds are open.
Added semantic coloring into the environment. This includes coloring fields green, bolding action and method names, and other features common to programming languages.
Added occurrence marking. This includes highlighting components that are semantically related (e.g., variables in the same scope).
Included a number of improvements to code completion. This includes: Better responsiveness overall. Primitive types now correctly show code completion values. Types involving parent variables now correctly walk you through a call. For example, if you type parent:, it will provide you what words are legal next. Similarly, once a parent is chosen, the actions and fields from that parent will be shown.
- Better responsiveness overall.
- Primitive types now correctly show code completion values.
- Types involving parent variables now correctly walk you through a call. For example, if you type parent:, it will provide you what words are legal next. Similarly, once a parent is chosen, the actions and fields from that parent will be shown.
Quorum 4.0 now includes editor hints. When a user makes a mistake, like having a compiler error or other problem, in some cases Quorum can detect what the problem was and automatically fix it on request. This does not work for all possible types of errors that can be made, but is useful for common situations. In all cases, editor hints have the keyboard shortcut of ALT + ENTER. Some examples of the hints provided by the system are: Automatically Find Use Statements: If you want to use a library, but do not remember the correct use statement, you no longer have to. For example, if you type Game game, and get a red line, Quorum will ask if you want to "fix" the error, which will put the correct "use" on the top of the file. Automatically Compute Return Types: If you have an action that is called, like MyAction(), but you don't remember its return type, Quorum will now automatically fill in the left hand side of that expression. So for example, it may convert "MyAction()" to "text value = MyAction()"
- Automatically Find Use Statements: If you want to use a library, but do not remember the correct use statement, you no longer have to. For example, if you type Game game, and get a red line, Quorum will ask if you want to "fix" the error, which will put the correct "use" on the top of the file.
- Automatically Compute Return Types: If you have an action that is called, like MyAction(), but you don't remember its return type, Quorum will now automatically fill in the left hand side of that expression. So for example, it may convert "MyAction()" to "text value = MyAction()"
Fixed a wide variety of bugs involving parsing. Some of these caused red lines to show up in inappropriate times.
Added accessibility support for most of the new development features. The two exceptions in this release are improved accessibility support for GIT/version systems and code folding. Both systems are possible to make accessible, we think, but the way they are integrated into NetBeans. We plan to focus group the known issues this summer to evaluate whether the fixes should prioritized over other potential features.

General Improvements and Bug Fixes

This section includes a variety of improvements or bug fixes the team worked on for this release.

Added support for the LEGO Gyro sensor.
Significantly reduced the delay on booting up LEGO robots in Quorum
Made significant improvements to the documentation generator in Quorum. These include: Updated the look and feel to try and make it easier to read. Added a summary table for actions. Added a summary table for variables.
- Updated the look and feel to try and make it easier to read.
- Added a summary table for actions.
- Added a summary table for variables.
Significantly filled out the backend of Quorum in regard to how it tracks source code. This should make it easier to add support for other development environments in the future, if we decide to do so.
Significantly re-tooled Quorum's web support. This is part of a long-term project on the team. Technically, it could be used today, but we are intentionally not creating tutorials or lessons for it, as we are actively adjusting the system in the lab. Eventually, Quorum's website will be rewritten in Quorum using this system.
Made significant improvements to the Quorum to JavaScript converter. It is still not 100% complete in regard to supporting all Quorum features, but it now supports substantially more. We will continue to work on this tool for future versions, until eventually it will be released as a standalone supported tool for Quorum on the web.
We rewrote the random number generator class to use the standard Mersenne Twister algorithm.
Included one minor bugfix to bitwise operations.
We made a variety of optimizations to Quorum, which ultimately causes the compiler to compile itself approximately 17 percent faster on average. As the Quorum project continues, we will optimize further, and test under a variety of other conditions, over time. Users needing optimizations for particular applications can make requests on the mailing list.
We removed the blueprint package for data structures. This was a small optimization in our system and the package was not really used in a meaningful way anyway. This simplifies the inheritance hierarchy of our data structures.
We moved the Iterator class to Libraries.Containers.Iterator, out of the now removed blueprint package.
We have included a variety of minor compiler bug fixes the team has completed over the last year. As the compiler has become more mature, these have become increasingly esoteric (e.g., better accounting for user error).
Improved the clarity of some compiler messages based on user feedback. We think there is more work to do here, but we are making these changes slowly, carefully, and with user feedback.
We fixed a number of issues related to how various screen readers work with Sodbeans. This especially includes details of our startup scripts.
We changed the startup script to now say Sodbeans 6.0 instead of NetBeans. So far as we could tell, some users seemed to prefer it says Sodbeans so they can identify it when it starts up. This used to be the case, but changed in Sodbeans 5.0. It has now been changed back.
A list of bug fixes tracked by our bug tracker (Jira) can be found on that site.

Documentation Improvements

We have made a number of changes to the online documentation in Quorum, including adding a variety of lessons and tutorials. These include:

The events tutorial has been split into four separate ones. These include input polling, mouse events, collision, and touch events.
Added a touch events tutorial for mobile platforms.
Updated the collision tutorial for Quorum 4.0.
The drawing and animation tutorials have been renamed to account for changes to the system.
Added a tutorial on loading 3D models and drawing them in 3D.
Added a tutorial on basic animations in 3D (e.g., rotations, scaling, moving)
Added a tutorial system on how to manipulate the camera.
Added a tutorial on lighting.
Modified the tutorial on creating 3D sound scenes, now including the use of doppler and the new Audio3D class. This new class is used to attach Audio objects to 3D moving items.
Added a tutorial on using 2D or 3D layers.
Adjusted the LEGO tutorials to include the gyro sensor.
Added a tutorial on team programming in Quorum.

Quorum 3.0 Update 48 July 22nd, 2015

This update is deployed to the update centers.

Added a new action for custom colors in the Color class.
Fixed a bug in the speech engine causing some say statements to not output sound correctly.
Fixed a bug with the Error Window hotkey causing it to not work if the C++ modules are loaded.
Changed the Error window hotkey to CTRL + ALT + SHIFT + 9
Changed the text-to-speech toggle to CTRL + ALT + SHIFT + T

Quorum 3.0 Update 44 July 21st, 2015

This update is deployed to the update centers.

Changed the loading of the game engine plugins to include a static initializer.
Fixed a bug causing the Enable Looping action in Audio to not work correctly.
Fixed a few additional minor bugs.

Quorum 3.0 Update 43 July 16th, 2015

This update is deployed to the update centers only.

Fixed a bug causing self-voicing to fail on bootup if you were using JAWS or NVDA and you installed the sleep scripts.
Fixed a bug in the game engine causing children to not properly respect the scale, rotation, and orientation of their parents.
Added a hotkey and menu item for turning text-to-speech on and off.
Changed the name of the menu called Magnification to Accessibility.
Fixed a bug in the project properties window forcing the user to reboot NetBeans in order for a name change to take effect.
A few additional minor bug fixes.

Quorum 3.0 Update 42 July 9th, 2015

This update is deployed to NetBeans only, but not as a separate zip file on the release servers.

Actually fixed bug with Lego Robot files not properly being sent over to the robot on Windows.
Added a test case and fixed a compiler bug.

Quorum 3.0 Update 41 July 8th, 2015

This update is deployed to NetBeans only, but not as a separate zip file on the release servers.

Fixed a bug with scaling in the game engine.
Fixed a bug with code completion showing the wrong documentation.
Fixed a bug with Lego Robot files not properly being sent over to the robot on Windows.
Finished the documentation for the game engine. Items should now show up correctly in code completion.
Finished the documentation for the lego robot systems. These should also now show up correctly in code completion.
Fixed an issue in the documentation generator causing robots to not show up properly.

Quorum 3.0 June 30th, 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, are welcome.

We had a number of technical goals in mind for the Quorum 3.0 release. We highlight some of the most significant alterations below:

Standard library changes

Game Engine 1.0: Quorum now supports a computer gaming engine (in OpenGL). In the first release we are supporting 2D graphics and basic 3D sound (through OpenAL). The design of the system was inspired in part by the excellent LibGDX project. Some of the major features include:
- OpenGL 2D graphics. The OpenGL aspect is wrapped using LWJGL for efficiency and is used similarly to other toolkits on the market.
- Event handling (e.g., keyboard, mouse)
- Font rendering through the FreeType font libraries.
- Open AL support for audio. In this first release, we support .ogg and .wav files. This library replaces (and upgrades) the existing sound libraries.
- A game creation architecture. This includes a variety of support classes to try and make it easier to create computer games.
- Automatic collision detection support.
- Basic support for texture atlases (ImageSheet objects in Quorum speak).
- A significant amount of documentation and curricular lessons designed to help people learn how to program games in Quorum. Some of this material will come out on the June 30th release, while more will trickle out over time as we write it.
Lego NXT robotics toolkits are now supported. Specifically, we now support connecting to lego robot kits, which can be used for a wide variety of purposes. Most major functionality in the lego kits are supported.
Removed support for Botball robots. We feel as if this library was generally not used much by the community and have decided to cease support. Continuing support for this would have required us to re-tool the system to support the new Botball kits, but we decided to focus time on Lego instead, as these kits are cheaper and more popular.
Included a wide variety of small changes or improvements to the standard library. Many of these came about due to the bootstrapping process, or teaching Quorum to compile itself.

Integrated Development Support changes

Sodbeans has largely been rewritten from scratch. The reason we did this is because we largely had to, given the new compiler.
The module system used by Quorum has been significantly condensed. This will make the update process easier in the future.
Accessibility Support is now in its own module. A new Accessibility preferences pane provides a variety of new accessibility options.
Speech now works in IDE on Mac OS X.10, even for components that do not read properly in JDK8 or NetBeans. This is only true if self-voicing is active.
Several bug fixes to the Quorum debugger have been implemented compared to the 4.6 release. This includes fixes for efficiency as well as user interface improvements.
The IDE experience has been significantly improved, with much more responsiveness from Quorum generally.
Integrated an Image Sheet Generator for the new game engine. This generator allows the user to automatically generate ImageSheets in IDE to simplify the process compared to kits like LibGDX, where the process can be somewhat confusing.
Fixed a bug related to the IDE using too many CPU cycles after a number of runs of Quorum.
Changed all API calls to use the new Quorum 3 implementation, with relatively little supporting Java code in the IDE. This should make it easier to port Quorum to other IDEs, for those that prefer different systems.
Improved the project user interface in the properties window of Quorum projects.
Added support to wrap in custom plugins or jar files into Quorum projects. Users should only do this if they know what they are doing, but this new system provides a much more convenient method for connecting between Java, C/C++, and Quorum, including full access to the JDK, C libraries, etc.

Major language changes

Quorum now uses an ANTLR 4 backend. Many 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 future cross-compiling we have planned (e.g., Quorum to Javascript converters).
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.
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 in our hooks to ASM, as we started with features specific to the Quorum compiler, but quite a bit is supported.
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 backend with a Quorum to Javascript converter. A prototype using this technology can be found at quorumlanguage.com in our hour of code tutorial. Updates and more libraries will be supported over time.
Fixed a bug in Quorum 2.0 that didn't allow us to support action chaining (e.g., a:b():c()). Code completion is not yet finished for chained values.
A significant optimization pass has occurred for programs generated in Quorum, making programs have faster execution and bootup times under some circumstances.
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). The final version of Quorum 3.0 is compiled in Quorum 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.
Fixed a bug in the way Quorum handles inheritance, which ultimately changes how plugins are written. While users generally do not have to use this system, this causes any hidden variables written by the compiler to have slightly different names (e.g., $Interface to _). Also, because of this change, variables, actions, and classes can no longer have an underscore as its last character.

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 to allow. Users that do have evidence from randomized controlled trials should get in touch with our team on the mailing list.
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. Users should not notice a difference with previous releases, with the exception that chaining is allowed.
Significantly redesigned the testing for the type system, with future improvements in mind. Especially, we have 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. This is a backend change and does change how user's use errors. It does, however, make the system work considerably better.
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 email the mailing list. 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 overall.
Considerably improved the stack trace information presented from errors.
Errors do not now have a corresponding interface type generated, 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 a bug in Quorum 2.
Included a number of optimizations at various points in the control structure pipeline.
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.

Compiler Support

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 from Quorum to Java Bytecode and JavaScript.

Other changes

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. To make input scalable we have changed the in-IDE behavior as well, now using the standard input box line in NetBeans. This behavior is, we feel, somewhat confusing, but is a tradeoff that fixes a significant bug in Quorum 2.0.
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 and was an annoying bug the team wanted fixed.
Fixed a number of issues with the way parent actions or fields were called.
In classes that explicitly declare system actions, the plugin generated is now accessible from inside the plugin architecture. To access it, users can access the variable named plugin_.

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.

Standard Library and compiler Fixes/Changes

Fixed a bug causing certain primitive types to not hash correctly.
Fixed several minor bugs in the standard library.
Added new data libraries for reading XML files and CSV files.
Added a number of new additional test cases for various components.
Fixed a rare verifier error in the compiler.
Fixed several other small compiler issues.

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.
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 Quorum projects.
- 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 them further.
- 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 account.
- 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 Libraries.Compute.BitwiseOperations.
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
end

The syntax is now the following:

if a = b
elseif c = d

else
end

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.
- 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.
- 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.
- 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).