Quorum Release Notes

We post changes to Quorum here

Quorum Studio 6.3 and Quorum 12.3: December 9th 2024

This is a bug fix and maintenance release but also contains a few new features. Notably, Spike kits now support a great deal of the sensors and thingies that come with the kit. Past this, this release contains a series of memory and processor optimizations related to graphics.

Changed the LEGO Spike (tm) Quorum adapter to output micropython bytecode. The difference is huge, but it does seem to especially improve bootup time
Adjusted the way LEGO Spike (tm) materials are compiled, adding a transitive dependency solution so that it is more general purpose. Note that if you use a ton of classes from Quorum that, while this is allowed, it can bloat the size of the bytecode. In practice, this should come up pretty rarely. Even if it does, if you are asking Quorum to compile in a bunch of classes, then it takes more space
Fixed a bug related to coroutines in Spike. They now await properly without requiring the user to know about the existence of this feature
Fixed a strange little bug where the transpiled code would not compile if you had a loop with an empty body.
Added a considerable number of sensors and other features in Spike. This list now includes Button, Color, ColorSensor, Device, Display, DistanceSensor, ForceSensor, Hub, Light, LightMatrix, Motor, Port, Sound, Spike, and a few others.
Added a considerable amount of documentation in the Spike API. These are not tutorials, but will hopefully help
By default physics in 2D no longer loads any memory resources. This substantially lowers the memory footprint for code that does not need physics, like charts
Fixed a bug in Quorum Studio where the smart nav hotkey was clashing with the clean and build key on Windows.
Fixed a number of seemingly small issues with memory and CPU optimization related to drawing and charts
Added the ability to have Bold and Italic fonts in Quorum. It's weird this feature was not in there, but it was not.
Changed the default font used in web based Quorum to include bold fonts
By default in charts, the titles are now bold.
Made a few small adjustments to the look of charts. These are purely visual changes and there is more to come, but this is the start
Conducted some light refactoring across the chart system
Added a new Hour of Code for Data Science to the Learn page. This Hour of Code makes use of the online blocks system
Added a loading spinner to the Run button in the online blocks system to signify that there is loading happening in the background
Significantly improved performance related to the online accessible blocks system in the hour of code. This helps especially in helping it become workable on low power devices
Gesture support has been added to the online blocks. Now on touch enabled devices you can make use of swipes, taps, and pans to interact with the blocks
Along with gesture support the online block system has been updated for use with screen readers on mobile devices. Navigation by headings is recommended to find landmarks in the blocks to help navigate and interact with the blocks on those devices

This release is dedicated to the awesome student project team at the University of Nevada, Las Vegas that helped get the LEGO Spike robots over the finish line. This includes, in no particular order, Bret Benjegerdes, Zachary Wylie, Anh Kiet Cong, Emanuel Pecson, Daniela Pedraza Orenday, and William Luong. Thank you so much for all the hard work you put in!

Quorum Studio 6.2 and Quorum 12.2: October 4th 2024

This is a maintenance release that includes bug fixes and one alpha feature that has been long requested by the community. Specifically, this is the first release to include a preliminary implementation of LEGO Spike (tm) robots from within Quorum. While this is now included in the user interface, the implementation is preliminary and not well tested. We put it out there only so the community can try it and provide feedback. That said, you can now set a property in the project file for Spike, then compile normally. If you build, or clean and build, it will output a micropython file that can be sent to the robot. Similarly, if you press the run button and the robot is physically plugged in, it will attempt to locate it and send it to a slot. The slot the program is sent to can be adjusted in the project properties page and is 0 by default.

Past this pre-alpha feature, the following bug fixes are included:

Fixed a gross bug where the 3D scene engine would crash Quorum Studio on bootup. We highly recommend upgrading for this alone if you use that system
Fixed a few small bugs that could crash Quorum Studio
Fixed a bug in the Palette that would cause it to incorrectly include private actions in some circumstances
Adjusted the online blocks system to prevent multiple clicks on the run button as things loaded
Adjusted how graphics are loaded in the online block editor to better help the memory load. Now, graphics systems like blocks need to retain state as text when unloaded, as opposed to text and graphics state
Fixed an extremely, unendingly, ridiculously, annoying bug where Quorum Studio would crash if you copy from a very large file.
Added the ChartDisplayer class. The purpose of this class is to allow for the creation of multiple charts at once and to display them all for browsing or saving. For example, you might create 50 charts, display them, or save them all into accessible formats.
Added an option to hide sub chart titles, x-axis title and y-axis title rather than only the entire x-axis or y-axis.
Changed computation of effect size in wilcoxon and mann-whitney u test from z / sqrt(N) to abs(z) / sqrt(N) to ensure a non-negative value.
Fixed a bug in csv saving that caused it to not save linefeeds in one cell within a text element.
Made additions to Serial and SerialPort classes for compatibility with LEGO Spike.
Added classes for ColorSensor, ForceSensor, Hub, LightMatrix, Motor, and Spike into the new Libraries.Robots.Spike package. These classes together allow you to send code to the robot for at least a small collection of features.
Added a new project for moving a Spike robot into the new project dialog.
Added a toggle button in the project properties dialog for LEGO Spike (tm)
Added a new tab for LEGO Spike (tm) with the slot number specified for where to send it to the robot.
Fixed a bug where Quorum Studio would tell you to use the wrong hotkey to go to the Errors tab when building a project with errors.

We want to especially thank Gina Fugate for her patience on the Spike Front and Bret Benhegerdes for figuring out how to send the file to the physical robot. It's not everything the community would want, but it's a start. For those that want to use Spike, please let us know if you have any feature requests, as we are not entirely sure what the community needs.

QuorumStudio 6.1: June 21st 2024

Quorum Studio 6.1 adds a few enhancements related to accessibility and some small fixes related to the debugger. This is a minor bug fix release

Fixed an off by one issue with breakpoints. This had to do with the system incorrectly calculating a partial line if you are scrolling
Sorted the variables in the variables window for the debugger. This bug has annoyed us for years and took almost no time at all to fix. Sometimes a fix is easier than you imagine.
Enhanced accessibility information for the debugger. Basically what this means is that if you are using a screen reader, the debugger is now smarter about telling you where breakpoints and the debugger line are.
Enhanced accessibility information for version control systems. Now if you are using the editor, there is accessibility information sent about it. The idea is that it is now easier to use Quorum with version control systems like Github.
Significantly increased the speed of the text editor.
Added a button under help in Quorum Studio to pop up the log file on various operating systems.
Fira monospace font is now available on the web
Fixed an issue where dragging a block with the mouse cancels keyboard block insertion
Blocks in the palette are no longer malformed if the palette is opened without any open project tabs
If the user starts placing a placeholder block with the keyboard, then drags something in, the system no longer thinks it's still in keyboard mode (causing a crash on Enter)
Added a series of null reference checks for an esoteric crash in InternalRemovePlaceholders in the block renderer
It is no longer possible to crash the environment by using the keyboard to insert blocks from the palette with no project tab open
Blank blocks should no longer disappear when placed at the bottom of a file via the palette
Dragging a blank block to the editor with the mouse will no longer cause the dragged block to disappear
Fixed an issue that made it possible to begin inserting a new block via the keyboard when you were already inserting a different block, causing the system to try to add multiple blocks at once
Fixed a crash that could occur if a block was set to be a Placeholder without being attached to a BlockEnvironment first
Fixed an issue that caused accessible level information on scoping blocks to be off by 1

QuorumStudio 6 and Quorum 12: May 9th 2024

This version of Quorum Studio focuses on the next iteration of our accessible blocks system, finalizing the desktop version of the design we originally imagined years ago. This version also puts in the groundwork for the web version of accessible blocks, which we are expecting to come online this summer. The biggest features are that we have completed all of the major affordances for the mouse, added a block palette similar to other blocks technologies, and spent a considerable amount of time fine tuning the blocks so they look, feel, and sound like we want them to, for good or ill. Finally, we include in this version an innovation we are calling scaffolded block programming, which users will observe in a special block palette we call Advice.

Blocks Improvements

Over the last year of blocks being available, the Quorum community has sent us a considerable number of helpful ideas, and yes some bugs, on how they imagine blocks could be for everyone, including those with disabilities. We have done testing, gathered feedback from adults and young people, and answered more emails than we want to think about. We have consolidated all of this feedback and spent a great deal of time thinking, coding, and frankly just tinkering with blocks to make them what we want them to be. Version 2 of Quorum blocks was written in version 1, so you could realistically say we have now been using blocks to build blocks for more than a year. We hope to iterate for years to come and are getting closer and closer every day to our vision for them.

The list here is going to be pretty short, covering the big picture, but honestly there are hundreds of small changes across the system and they are way too numerous to put in the notes and have it be meaningful for people. Thus, here is an abridged list of the changes:

Added mouse support for the blocks. We always add keyboard support first for accessibility, but we should be pretty close to parity now for traditional blocks systems in terms of other modalities. Many aspects of the blocks can now be used both with screen readers, but also clicked or manipulated in other ways
Added the ability to move the scope of control statements with the mouse.
Made a considerable number of tiny little changes with blocks and the keys and features it supports in an attempt to make them feel simple and more natural
Made a host of bug fixes related to the blocks. This includes crashes, parsing issues, and really just general touch ups here and there.
Dramatically improved logging of the system and especially inside blocks, especially for crashing and other issues

Scaffolded Block Programming

As one additional feature for blocks, we have created a new way to interact with blocks that we have not seen in other block languages. This system, which we call Scaffolded Block Programming, can predict based on the cursor certain aspects of what code the user may be wanting to write. Additionally, it can pull up documentation as the user works to provide hints related to the context in which they are working. From the user's perspective, we call this the Advice palette. Another way to think about this is that as you use the environment, it tries to give you information, or advice, on the types of things you can do from there.

This system is new and designed to potentially reduce transitional friction between text and block languages. Part of our design philosophy was making it so you do not need to switch for professional practice, while keeping it simple for children. However, since the system is new, we suspect it could use with a solid round of constructive criticism and feedback from a diverse set of people. While we have made decisions for it around the best available evidence we have so far, we suspect it will get adjustments with more evidence and testing. Here is a rough overview of the kinds of things this system does:

The horizontal cursor is now a hook for the scaffolds. For example, if the cursor is on a blank block, it will tell you the types of things you can place in that location in the source
For items in the standard library that are objects, if that class has documentation available, and we admit not all do, a snippet of that documentation will pop up so the user knows what the class does
If the horizontal cursor is on a primitive, or some other internal Quorum construct (e.g., output, say), it will now provide information on what the command does in the programming language. The broad idea is that it makes it so the user no longer has to lookup commands they do not remember.
Any item that pops up can be manipulated with the keyboard, mouse, screen reader, or other devices. As always, those with specific accessibility needs are welcome to reach out. We are always willing to learn more about what might help people
Besides the Advice palette, there are basic, control, and action palettes with various items from the programming language. New ones are relatively easy to add, so ideas are welcome

Finch Robot and Micro:bit Support

Due to a generous contribution from Birdbrain technologies, Quorum now supports Finch Robots and Micro:bits. Documentation is forthcoming, but it is hooked into all the normal systems, including blocks and the palette so you can tinker and explore. Big features include:

Support for normal Finch operations, similar to using it from any other language
Support for Micro:bit 1 and 2.
Desktop Quorum Studio only is supported, on Mac or PC. A web version is theoretically possible to implement, but not supported in this version

Website

The website has been completely re-imagined from scratch. Technically, we released it in January, but no notes were given until now. We focused largely on design, with art, different ways of navigating the pages, a new development environment, extra tools, and really just a solid rethinking. We also include here a few notes that were not put out previously. Here are some of the big picture changes, along with new things:

The website is now 11 billion times more adorable. We did not measure this and would never try, but we stand by this possibly not true claim.
Switched the backend of the system to use tailwind instead of css. We have no idea what a controlled study would say about this, but we are tinkering
We re-imagined the online development environments. They have a considerable number of improvements
Redid the structure of all of the pages to update themselves to the new system. There are way, way too many pages to mention
Fixed several 404 pages across the system
Fixed some tailwind related bugs across the system

Data Science

For this release, we focused largely on doing more testing with the statistics system and also using it in real-world academic publications. This process has helped us refine it, test it, and frankly get more comfortable doing professional grade statistical analysis in Quorum. Some of the release notes in this section are thus at a level of nerd-dom beyond our usual level of nerd-dom.

Added several non-parametric tests in CompareCounts to handle paired data and pairwise testing from data in various formats.
Switched the standard effect size measure in ANOVA tests to Generalized Eta, based on the paper by Olejnik, S., & Algina [1]
Fixed the construction of the design matrix for certain mixed ANOVAS to avoid singular matrices if possible.
Fixed CrossTab to fill in 0s if no counts were collected under certain combinations, which is necessary for repeated measures CompareCounts tests.
Forced the subject identifier to be recognized as a text column to optimize its access.
Fixed a box plot crash where if no values were in a group it couldn't render, now it just leaves a blank plot area.
Separated Touch Exploration and Gesture Navigation interaction models, which can now be toggled using SetTouchExplorationEnabled(boolean).
Fixed a bug in Gesture Navigation on Android so that the number of fingers for swipes are properly recognized.
Fixed several bugs in Touch Exploration on Android so that focus changes properly as Chart elements gain and lose focus.
Added 'end of list' information to the end of Chart element descriptions.
Added a looping feature to Chart element lists (including Chart information, sub charts, series, etc).
Added the ability to toggle the visual highlighting, using ShowVisualHighlight(boolean), so that screenshots can be taken off just the base Chart.
Added texturing to the charts as an accessibility enhancement. By default, no textures are on, but if you turn it on, a default set of patterns will be applied in SVG mode.

[1] Olejnik, S., & Algina, J. (2003). Generalized Eta and Omega Squared Statistics: Measures of Effect Size for Some Common Research Designs. Psychological Methods, 8(4), 434–447. https://doi.org/10.1037/1082-989X.8.4.434

General Bug Fixes and Improvements

As is normally the case, there are always bug fixes. We have noticed more crash reports than usual with Quorum Studio 5.1 and have spent considerable time knocking these out. We appreciate all the reports and are sorry for the hassle. Many of these were way more difficult to find than we expected, involving some very esoteric internal systems:

Fixed a bug in Mac OS Sonoma where the system could not build on iOS
While the numbers vary by machine and architecture, we have added some basic optimizations into overriding the standard library. On some configurations, we have observed reductions by upwards of 60-82% of CPU time. Special thanks to the St. Louis team for their help in testing.
Fixed an extremely gross and esoteric bug that would cause a spurious compiler error to be thrown when running the compiler with a non-deterministic file ordering where public fields are accessed from outside of a class. This is about as close to English as we can get for this crazy bug. Don't ask how we found it, because it makes even less sense.
Fixed a bug in the yaml file for the Quorum server where the standard library would not correctly generate the libraries pages
Fixed a bug in the compiler that would cause a particularly unintuitive error message to come out, even if the compiler generated a better one, in certain circumstances
Fixed a bug causing the compiler to sometimes ignore a perfectly good identifier name that it could have told you about when you had an error in your own code
Fixed a bug in the compiler that would sometimes cause the parser to not correctly identify that there was a missing type statement after a returns value
Fixed a series of bugs in the compiler exposed by the blocks system related to parsing weird stuff as you type. There were a bunch of these, many of which causing unexpected crashes because the compiler architecture just wasn't designed to work that way when it was created. The reason it happened is because we adjusted the adaptive LL * algorithm for a hand-parsed parsing architecture back in Quorum 9. We did that because it allowed us to put the compiler error messages at the 8th grade reading level. This worked fine, but the blocks exposed a bunch of small issues slightly outside of those original design goals
Fixed a bug in the scene editor causing a crash when you close a file
Fixed an exceptionally esoteric bug causing a rather large memory leak in the accessibility system on Windows related to setting JNI global references and not freeing them under certain conditions.
Fixed a bug that caused Quorum Studio, if you load it for the first time, to appear very small. The way this is calculated now by default is for it to be approximately 3/4 of the size of your monitor, which you can override how you see fit. Because it is difficult to know all the permutations of monitors and setups people have, if it looks strange for you, yes you, on bootup for the first time, feel free to get in touch and let us know what your setup was.
Signed the installer on Windows. We plan to sign the installer on Mac as well, but have not yet finished this work. The lack of signing appeared to be causing the most problems on Windows, so we prioritized finishing that one first.

Quorum Studio 5.1: September 8th 2023

This is a bug fix release with one large change. First, the biggest change in this mini-release is we have added Voice Over support on Mac OS X. This feature has been a long-time coming and we were finally able to complete the first version of it. We want to especially thank Matt Campbell and his excellent AccessKit technology for this side of the accessibility work. AccessKit allowed us to plugin to accessibility, similar to how we do on Windows, much more quickly and easily than we were expecting.

To be clear, while Voice Over support seems to be working how we want it to, there are a few known bugs in this first version. Notably, while nearly all of the systems are working how we intend in this design, the version of AccessKit we are using to make this happen is a pre-release and there are a few remaining issues related to roles, especially in trees, tabs, and tables. For example, tabs think they are radio buttons. This is adorable, but clearly a bug. We plan fixes for these issues as we continue working, but decided the community would benefit if we got out a patch now. Known bugs notwithstanding, this new version is dramatically more accessible and block mode is, in our view, really fun to use in the Voice Over screen reader. We would encourage any Mac Voice Over users to provide any feedback they have about the new version.

Fixed a bug where if you close a tab, it wouldn't ask if you wanted to save under some conditions. We may have missed a few cases, but think we got most of them
Fixed a strange bug where the Quorum Studio properties dialog would always think you have overridden the Quorum Standard Library even if you did not
Breakpoints in the debugger have had some minor cleanup and bug fixes
Undo/Redo has been adjusted heavily in the block editor. Previously, while it was not wrong, the way it moved and generated blocks during undo operations felt confusing, so we adjusted it
Fixed a desync bug involving scoping. We also fixed several other desync bugs too esoteric to describe in English.
Fixed a bug where if you have two statements in a specific way in a freeform block, you could get a desync bug
Fixed a bug where freeform blocks wouldn't properly recognize system actions, blueprint actions, and shared classes
Adjusted the way we manage Eigenvalue decomposition for certain kinds of mixed models
Fixed several issues with output and statistical tests
Added an ExperimentalDesign class. There is no documentation for this yet, as we are experimenting with the design, but we are pushing this live to play around with it
Added an action to pass an experimental design to the data frame. This is necessary for some rather complex models where factor selections alone are not sufficient for describing the statistical test you want to run
Fixed a bug with network requests related to Get requests
Adjusted the accessibility information presented in boxplots
Added mouse over support for regression lines
Added a way to set borders around the legends in charts
Fixed a desync bug in text fields
Fixed a chart bug that could cause a crash with long names
Fixed a bug in web input that could cause spurious output
Fixed a bug causing the residual squares to give the wrong answer in charts under certain circumstances
Added Voice Over Support for Mac OS X

Quorum Studio 5.0.4: August 8th 2023

This is a bug fix release for Quorum Studio. Changes come largely from a round of focus groups conducted over the summer with teachers and students.

Fixed an error in the standard deviation and variance equations on the summary statistics page
Updated all of the SVGs to be generated in the current version of the library
Updated the charts documentation to Quorum-11. They were previously using a slightly older version of the standard library
Fixed a weird mouse bug where you can only click on the right hand side of a block but not the left
Fixed a bug where some multiple line block parts would not take up more than one line when they needed to. An example would be if you have a conditional expression that takes up multiple lines
Adjusted the height of the notches in blocks so they are relative to the total padding size
Blocks with errors now correctly respect scaling when drawing and positioning their notches
Adjusted all of the colors in dark mode to make them more readable
Changed the selection color in light and dark mode to make it more readable
Fixed a bug which could make the selection cursor stick around in the block editor when the editor wasn’t focused.
Adjusted the code completion window to now accept Tab to do code completion.
Fixed an issue where scatterplots on the web render the points incorrectly as squares
Added a property to Quorum Studio so that blocks can be rendered thinner in terms of the left bar or the padding above and below a block. The notch scales according to this property as well.
Fixed a bug where too many labels were being sent down to the accessibility system
Made it possible to click and drag the edges of the project panel and console area to make them bigger or smaller.

Quorum Studio 5.0.3: July 24th 2023

This is a bug fix release for Quorum Studio and contains a series of issues with various systems:

Fixed a bug where if Quorum Studio does an update, it would not properly close the application once the updater starts. Note that because this bug was fixed for a future release, the feature will technically only start working in the release after the next release
Fixed a bug in rendering blocks where, if you were rendering in the standard library and there were multiple blocks on a line that were previously written in a raw text editor, it could sometimes render the block out of place or too thin
Fixed a bug in smart navigation where it would go down, but not up, inside of blocks
Added navigate to declaration, a feature in the text editor, into the block editor. This allows the block editor to determine the semantics of the code and jump to a location where the code is declared, which is helpful for looking things up
Fixed a bug related to editor hints and compiler errors in blocks where sometimes the hint or error would not show up or would be at the wrong location. While the algorithm is now much simpler and appears to be more accurate, there may be a case lingering where it is still off
Fixed a bug where adding a colon into a block’s field causes the cursor to jump back to the start of the field under certain conditions
Fixed a bug in the debugger where it was to jumping to the wrong lines inside of blocks
Fixed a bug related to Bonferroni corrections on factorial CompareMeansPairwise tests where the number of tests performed was not being correctly computed
Fixed a bug where Quorum Studio would not properly exit if a check for updates was issued and the system started the update
Fixed a threading bug with the continue button that could sometimes cause a crash related to the debugger visuals under rare circumstances
Slightly adjusted the size of the find in project dialog to make it more sensible at more sizes

Quorum Studio 5.0.2: July 11th 2023

This is a bug fix release for Quorum Studio and contains a series of issues with various systems:

Fixed a bug where nesting an elseif block inside another elseif block crashes Quorum Studio
Fixed an issue where hints would sometimes cause location information to go bonkers, which in turn could lead to de-sync issues with blocks
Fixed a bug where numpad enter seems to enter a new-line into a TextBox instead of parsing and adding a FreeformBlock
Fixed a bug where, under some conditions, multi-selecting down to the last block and deleting causes a crash
Fixed a bug where creating an action from freeform that includes a return type gets bad indices for the return field.
Fixed a bug where the Quorum project properties dialog would crash if you have never done an override of the Quorum standard library, which was preventing users from turning blocks mode on and off
Fixed a bug causing the input template to have incorrect behavior during parsing inside of a block.
Fixed a bug where the Undo/Redo keys were hooked up, but the buttons on the toolbar were not
Fixed a strange and esoteric bug where line numbers were wrong in the line number gutter sometimes
Fixed a bug where F3 and SHIFT + F3 were not working in the find dialog in blocks
Fixed a bug in the find dialog where the select word was not correctly transferring the copied text at the right time to the dialog
Made a speed optimization inside of the classes for ANOVA tests related to the sum of squares calculations
Removed a memory and optimization problem inside of the matrix multiplication transform
Allowed multiple factors in compare means pairwise
Fixed a bug in the concatenation opcode where it was not properly evaluating in the interpreter
Fixed several bugs with statistical effect sizes in complex statistical situations. This is an extremely complex topic and we suspect more work needs to be done in this area
Changed the AddSelectedFactors and AddSelectedColumns actions to retain ordering by default, based on user feedback

Quroum Studio 5.0.1: June 26th 2023

This is a bug fix release for Quorum Studio 5.0.0. The fixes include:

Fixed a crash bug when you use the arrow keys at the top or bottom of the file
Fixed a bug in new project dialog where the browse button was incorrectly hooked up

Quorum Studio 5.0 and Quorum 11.0: June 21st, 2023

Quorum Studio 5.0 and Quorum 11.0 marks what is perhaps the most significant change in the user interface for the language in many years. Notably, this is the first release of, so-called, Quorum blocks, which adds a blocks-style accessible editor into Quorum Studio as the primary way of writing code. Second, a large and significant amount of change has been done around the user interface components in the language, from charts to buttons, to other controls. This includes visual styling across the board and improvements to accessibility and layout. Finally, we have made significant progress on improving support on mobile phones.

Data Science

We have made a number of improvements to data science packages broadly in this release. These include:

A number of fixes to charts related to accessibility and the visuals of charts
Added more customizable annotations to a variety of charts
Added support for principal component analysis, including common rotations like varimax and oblimin.
Added a series of common tests and metrics relevant for factor analysis
Fixed a bug in data frame filtering where less than equals was broken
Broadened data frame filtering so you can use parentheses. How wide to broaden filtering operations for databases or data frames is still an open question, but this particular addition seems reasonable because you cannot complete many common filtering operations without it
Created documentation for many common statistical tests, from basic analysis of variance style tests to non-parametric equivalents or factor analysis
Added some fixes to the descriptive statistics to avoid false results on non-numerical data.
Fixed bugs with columns not preserving types in transform longer and wider
Fixed a bug in correlation tables causing it to crash if you have a single correlation in the table
Made significant improvements to the SVG system for charts, squashing a series of accessibility issues and making them more robust broadly
Fixed a series of issues with accessibility and the shadow-dom implementation
Fixed a whole host of small bugs across the data science and charting systems. Many of these are not terribly noticeable, like small changes to calculations or adjustments to graphics, accessibility, or visuals. These relatively small changes across the board makes the system broadly feel more polished than in the last release
Changed a series of naming conventions across the data science library
Added a number of helper actions into the DataFrame to assist in doing various statistical operations more easily
Added actions for the regression models to predict from a separate DataFrame than the fit happened with. We suspect functionality like this will get added throughout the system over time
Added tests for multivariate ANOVAs and factorial ANOVAs to the data science library
Added more chart options and defaults to cover a wider array of selected columns and factors.
Added a set of helper actions for various operations in DataFrame
Added support for flowcharts
Added support for N-dimensional charts. This works for many kinds of charts if N is considered the factor or selection, but not all chart types
Renamed a number of statistical tests to be more in line with the meaning of what those statistical tests accomplish
Removed a separate selection from the regression class. It now pulls its selection from the DataFrame, like the rest of the statistical tests and charts
Added tests for variance assumptions for use with multivariate factorial ANOVAs. (i.e. Box’s M Test and factorial Levene’s Test)
Added more helper actions for various operations in Matrix
Added a test to conduct multivariate Linear Regressions
Made a significant number of changes to accessibility with charts after testing across many devices and screen readers
Added a test to conduct multivariate and factorial repeated measures ANOVA

Blocks

This is the first release of Quorum that supports, so-called, "quorum blocks" inside of the Quorum Studio and online editors. Quorum's implementation is highly custom and home-grown, in order to account for accessibility across platforms and devices. While this is version 1 and in many ways we would call it beta, it has a considerable number of features related to using blocks in an editor. We say beta here in part because a few features we had planned for version one were pushed to a later release. An abridged final feature list for version 1 follows:

Quorum blocks is available in Quorum Studio 5.0 and will be available in an online editor after release. Accessibility architectures are different in each place, but are designed to feel somewhat similar. We completed Quorum Studio first because it is easier for us to test in that environment compared to online.
Blocks are now the default for all programmers, including us as the development team. By default, plain old text editors are no longer used, but in a pinch you can turn the blocks off, but our intent is for people to use them
Created a highly customizable rendering pipeline for blocks inside of an editor. This turned out to be an important efficiency consideration
Created a custom accessibility architecture for blocks. Each platform makes assumptions about blocks customized to that modality
Changed the gutter architecture to be more flexible than it was. Notably, before they were tied specifically to textboxes
Linked Quorum's compiler architecture to the creation of blocks in a whole bunch of strategic ways
Added a wide variety of common keyboard affordances for blocks, including basic ones like add, delete, copy, paste, undo, redo, or others
Created what we are internally calling a free-form block, which allows users to use common keyboard affordances to temporarily override the affordances of blocks if they want to. This allows users to use blocks more like a text editor when they want to and to use them more like blocks when they want to. In the academic literature, people have called similar concepts many names
Created methods whereby freeform blocks automatically turn into the appropriate block types as you move around in the editor
Created a mechanism for deletion we are calling 'Least Semantic Distance,' that tries to allow changes to the source code that minimizes what the deletion does to the source code, while retaining the general semantics beyond the deletion
Created gutters for blocks for line numbers and Git support. Don't worry, we're sending text to git not little pictures ...
Added a variety of templates. These are very similar to auto-complete in a traditional development environment and automate creating blocks in the environment. In the first version, we began with adding templates largely for control structures and core syntax and semantics
Added a Find dialog for finding items from blocks
Added code completion to blocks
Added editor hints to blocks for auto-adjustment of source code. All editor hints supported in the text editor are similarly supported in blocks. This includes features like auto-finding use statements, auto-adjusting return values, and automatically generating getters and setters
Added smart navigation keys, stemming from Catie Baker's work. They keys are the same as they have been in Quorum Studio for a long time, but in blocks
Added shadowing and many other visual attributes to the blocks. We would like to especially help the Scratch team for their help in thinking through color considerations
In the current design, we are using monospace Serif fonts for the blocks. There is considerable debate in the academic literature and, to put it mildly, it is not a slam dunk either way in regard to readability for anyone, let alone people that are blind or visually impaired. We made this decision for this release based on technical constraints for this release, but suspect we will revisit the design decision as more evidence comes out in the academic literature

Quorum Native Libraries

In this release, we rewrote from scratch the native library system for Quorum that touches the last mile on each operating system. Over the years, we have worked diligently to remove any natives where possible, but some operating system specific features really need a mechanism for calldowns. However, that system has grown organically for many years and in order to support blocks and future support for improvements on Apple, this change was necessary. This is a very complex system and we suspect it will take several release cycles to implement what we have planned here. Current improvements include:

Native support is now in its own repository, quorum-natives
On Windows, automation support is only partially complete, although some aspects of it are. Many of the much older libraries, while they still work, need to be moved over to the new approach
On Mac, the system is partially automated. The current version still includes ARM support, although building it is still pretty clunky and picky. In the current version, build instructions are documented and we suspect it will get closer to fully automated over time as we make other changes on Mac
On iOS, the build is now fully automated. For whatever reason, this system was easier to automate than the others
Rewrote font support on iOS devices at the native level, moving it to largely the same system other operating systems are using
Removed junk code from the iOS native stack
Updated the freetype dependencies in the web assembly connectors for fonts in Quorum online and fixed issues around this system

Android

We included in Quorum 11 some changes to mobile support, including Android, especially improving support for gestures and accessibility through Talkback. Support for Talkback in the first version is imperfect, but many features are supported and this is the first release we have had any support at all. Generally any program quorum generates includes these features automatically, which means if you run an Android program from Quorum, it should be much more accessible than before. Further, we now have a direct pipeline for adjusting Talkback support on this platform, which means it should be easier to make accessibility adjustments in the future.

Added initial support for Talkback
Added button support to talkback on Android
Added radio button and checkbox support for Android
Added basic support for Tree, TextBox and TabPane, although we suspect they need more work
Improved gesture support on Android, including adding many defaults for charts. We suspect this will take more work in the future for all user interface controls, but it is a start
Added chart support to Talkback on Android
Fixed a bug in Android where Quorum would not load on modern tablets
Fixed a bug on Android where it would not properly send the code to a tablet on Mac

Apple Devices

In this release, we rewrote a considerable amount of the iOS pipeline for Quorum and made some improvements to the Mac implementation. This includes basically anything related to the system, like natives, how Quorum Studio integrates in the system, dialogs, and other crucial infrastructure. Needless to say, while many of the changes really just make iOS function correctly under the hood, the bigger point is that this architecture is getting more mature in ways that should make it easier to adjust in the future. Starting in this version, it should be possible to now deploy Apple programs to the App Store, although how to do so is still a little tricky.

Fixed a bug in iOS where it would take an extremely long time to compile for the platform. It still takes a few minutes, but is much better
Fixed a bug where you could not load on an ARM processor iOS applications
Updated iOS to require version 16.2 or above. This is pretty recent, but the conclusion we came to was that we needed to make a clean break in this system for future proofing
Dramatically improved the build system for how ios is managed on the native side. All native libraries are now pre-compiled and their creation is fully automated. This should make it much easier to change this system in the future
Upgraded the mobivm dependencies to 2.3.18
Updated the FreeType dependencies and changed to the more modern FreeType Native implementation for Mac and iOS
Added support for font shadowing on Mac and iOS
Fixed a bug where the location information was incorrect for fonts on iOS, both in the simulator and on physical devices
Changed Quorum Studio to provide gradle output from a build on iOS. This is hard to read and not user friendly at all, but otherwise you really do not get any logging information from a program. This design decision is, in some ways, the lesser of two evils and we would be unsurprised if we adjusted this to make it more user friendly in the future. For now, though, at least you get feedback that the system is doing something
Fixed a bug causing the system properties to incorrectly tell you you were running on an iOS simulator or device when you were not
Fixed a bug related to detecting iOS properties on bootup before a game is created
Added new bundling properties to the project properties dialog for physical devices like an iPhone or iPad. You can select your device and put in appropriate security credentials, which will allow you to send to the device
Conducted a significant amount of refactoring in the mobivm plugins for iOS. This system still needs more cleanup and we plan to balance refactoring and features over the next few years on this operating system
Added security properties to the dialog for apple devices to send it to physical devices
Fixed a bug causing a crash if a keyboard was enabled
Fixed a bug preventing the accessibility system from receiving any messages from the overall application

User Interface Updates

Quorum-11 highlights a significant number of changes in regard to the user interface system. We made these changes for many reasons, but first, a big one is that many of the colors and other properties, while accessible, are also subjectively ugly. We wanted to improve these systems to make them look more inline with other modern applications. Second, historically, the user interface libraries have been quite difficult to program. We improve that in this version with the introduction of the Form library. Forms are a new way to make small little applications or dialogs and we suspect they will be especially useful on mobile devices. We also suspect they will be useful in dialogs and, while not really the intent, possibly larger desktop applications. Generally, while we did not run a study for this particular feature, we hypothesize they are much easier to use than the old system of creating user interfaces.

At the end of the day, the big picture in this release is that we have significantly improved many of the default colors and other properties to make the controls look visually nicer. Many of these changes are subtle and some of the ones for individual controls are listed in their specific section. We have also improved the layout of many controls across the board to try and make them look nicer. These systems might make mobile programming easier, as there are now swappable pages that you can use in your applications on a number of platforms. Overall, the improvements are not yet perfect, but they are quite dramatic. Documentation for how to use this system will be left to future work, as we needed to build it first to figure out how it should work ourselves.

Forms

Added a Form, Page, and Grouping class to represent the new forms library. Forms have a function similar to charts in that you do not need to make a Game, as this is automated behind the scenes.
Created shared interfaces for the components so they feel similar when you use the APIs
Added a series of helper actions to represent adding something, like a button, field, or some other control
Created a set of different kinds of page subclasses that manage layout. The idea is to automate as much of this as possible, similarly to in html where you declare what you are adding to a page but let the system figure out how to position it all
Added a default sizing procedure for forms based on fonts as a unit of size in relation to rows
Added a series of lazy loading procedures for a variety of systems related to graphics and also accessibility
Added a mechanism to share data across a user interface. This system is somewhat similar to the entity component model and is used in the Form and Pages classes, although it is not strictly the same and is intentionally limited, in addition to being typed. For example, you can ask the form to store a primitive value, like an integer or a string, which can be used across a set of pages. Similarly, you can store page specific content only in that page to be used across multiple controls in that page.
Added a variety of helper actions for common things you might want to do in a user interface, like laying things out, changing pictures or icons, or triggering basic sounds. Many of these are really just helper actions for Quorum systems that have long existed, but are designed to make everything feel easier to use.
Added a set of groupings and pages for controlling the layout and look and feel
Added a standard set of accessibility affordances for these new pages. Because the new system is significantly more constrained than the full user interface library is, this provides the user a relatively small set of accessibility defaults that can be adjusted for common things

Text Fields and Text Boxes

Fixed a bug in text fields where the cursor would get stuck to the left hand side
Fixed a bug in text fields where the shift key was not working as expected
Fixed a bug in text fields related to switching to the next token
Fixed a bug in text fields related to dragging
Added a border color to text fields by default
Rounded the corners by default on text fields
Fixed a bug in text fields where you could not set the font
Added a focus highlight color to text fields
Fixed an indexing bug related to text fields. They now match the way it is done in textboxes, which was the intent
Fixed a bug in Text box where scrolling was tied to an old implementation
Fixed a bug in the gutters for Text Box that caused the gutters implementation to be tied only to that control
Modernized the textbox class to move it to the more modern input sets and other features. For whatever reason, this control was not updated as it should have been a few releases ago, probably because it's quite complex
Fixed several issues with sizing and layout
Fixed a bug causing editor hints to cause a crash under some circumstances
Fixed several off by one bugs related to line selection in the editor. If others in the community observe another one, let us know, as they are easy to miss
Added support to the web version for accessibility with text boxes and fields

Checkboxes, Toggle Buttons, and Radio Buttons

Fixed a bug in checkbox where it was not properly showing a focus highlight
Fixed a bug in checkbox where it was not properly lining up the text with the check
Changed the look of checkbox to make it look nicer
Rounded the corners by default on checkboxes
Fixed a bug where the text was not lining up with the buttons
Adjusted the colors in radio buttons
Fixed a bug with button groups causing toggle buttons to not be included in button groupings
Fixed a bug in toggle buttons with the visuals showing incorrectly
Fixed several crash bugs in button groups that caused them to be strangely tied to Radio Buttons in ways they were not supposed to be

Buttons

Rounded the corners on buttons
Changed the default colors of buttons for many of its default states
Fixed a bug where buttons would not properly center their text
Fixed a bug where button text would appear at the wrong size by default
Fix several bugs with colors, especially in light mode, with buttons
Changed the default focus and other colors to make it more visually obvious when something has the focus

Lists

Fixed an issue with lists displaying text outside its bounds
Set reasonable defaults for lists in terms of sizing
Lists can now scroll in a container
Fixed an issue where lists would not properly highlight the selection
Fixed several bugs related to accessibility with lists, including online and offline

Quorum Studio

Fixed a bug in toolbar in dark mode that broke colors with the new color changes
Changed the backend system for managing iOS applications
Added several iOS related properties like signing identities and provisioning keys. These are only relevant if you want to put an iOS app onto a physical device
Added a version key to the project properties dialog
Changed the project location to a textbox so you can copy paste it to the clipboard
Fixed a bug in Quorum Studio where it would not stop a process if generated for iOS
Redesigned the Project Properties dialog from scratch using the new Form system. This substantially cut down on the complexity of this dialog, which should make it easier to maintain and look not so strange at different sizes visually
Rewrote the Quorum Studio Properties dialog from scratch. It now exposes many more properties and removes the old login system, which was no longer used anyway
While blocks are now the default in Quorum Studio and are intended to be used for all applications by design, we have exposed a property to allow you to turn it off
Separated the Android and Apple tabs in the project properties dialog
Removed the WebServer settings from the project properties dialog. Quorum's new architecture for web servers is a rewrite of the original and is now dramatically more robust, sufficiently so for us to use on our live servers. While this setting was removed, you also no longer need it to run web servers.
Rewrote the find in project Dialog from scratch. The dialog no longer appears like it was on an all night bender fighting off an army of angry porcupines
Upgraded the find in project dialog, and the Find dialog, to account for blocks mode
Upgraded the version of Font Awesome to the latest free version
Rewrote the create new project dialog from scratch. Previously, it used a tree and looked visually pretty bad at various zoom scales, despite being accessible. Now, it has a set of tabs and toggle buttons and looks visually quite a bit nicer.
Added a series of additional new project types, including those for mobile, data science, sound, various scenes, and other project ideas. It should now be a bit easier to get started with any of these project types
Refactored the new project dialog to make it far less rigid and easier to add new project types in the future

Other Quorum Standard Library Changes and Fixes

Fixed a bug in JavaScript mode that was causing a crash with input statements. Special thanks to Gina Fugate and her students for reporting this one.
Fixed an issue related to the use of solo variable declarations. Specifically, there was an edge case where you could use a variable and then toss it off the stack. Technically, this would do no harm, but in evaluating it, it exposed a number of small and unintentional issues in the parser stack, which are also now resolved. Broadly, this change should make it slightly harder to make particular kinds of likely unintended semantic errors
Fixed a bug in the parser that was not quite aggressive enough in finding potential user errors on the right hand side of an expression. This wasn't exposed in the test suite and now is
Added a few new compiler error categories related to statements and expressions where the parser cannot determine the user's intent
Fixed a bug in Process that were causing some applications to output from standard output very slowly through the listener architecture
Fixed a gross bug in the font system that was preventing fonts from working at larger sizes. This especially impacted iOS devices, but was true on desktop as well. The web was not impacted
Fixed a bug in fonts on the web that caused them to look visually torn under certain conditions.
Added font shadow support broadly into fonts across all platforms, in preparation for blocks. We did this in part because the block text was somewhat difficult to read without some outlining and so we chose an approach for the text similar to how closed captioning is often done. This feature should be usable anywhere in a font, but note that the calculations can get a bit wild so turning this setting on may cause a font to look funny for some fonts at some sizes in some locations. While it works just fine, we recommend testing carefully if custom fonts are used
Added support for raw socket connections with the SocketConnection class
Added some additional security code related to backend web servers
Added support for taking screenshots. This is currently limited to web applications, but is a start
Added support for loading Base64 representations to images, which makes it easier to load icons and other representations
Fixed a bug in code completion causing it to work incorrectly for implicit classes. This bug was supremely annoying in previous versions of Quorum Studio and appears to significantly improve code completion under some circumstances
Fixed a variety of small parser bugs causing the system to incorrectly determine the location of a particular programming construct. These small bugs did little harm in previous releases as they would not impact compilation. However, they were causing issues with the new blocks layer, which depends on the synchronization between text and the visuals
Fixed a bug in labels in web accessibility that caused it to work through a screen reader differently than we intended
Fixed a bug in web accessibility that could sometimes cause screen readers to speak the same information twice
Fixed several other small issues in accessibility in relation to accessibility on the web

Quorum Live Server

Fixed a bug that caused the server to hang and not respond if the compiler did not respond to a compilation request
Set some more sensible timeouts in the case of problems. Turns out, forever was a little too long to wait
Fixed the docker-compose scripts to trigger restarts in the unlikely case of something totally failing
Unless we missed a piece, the entire server backend in the live server is now written in Quorum. This includes the database and cache connections, optimizations, server responses (e.g., cookies) and other attributes. This rather dramatically increased performance across the backend

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