Quorum 12.2

This release sums up Quorum from version 12, which by accident was not released as a tag except on the Quorum Studio side. The release notes are generated.

What's Changed

• Fix LEGO Spike bug. by @Bret-B in #111

New Contributors

• @Bret-B made their first contribution in #111

Full Changelog: 12.0...12.2

Quorum 11.0

Quorum Studio 5.0 and Quorum 11.0

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:

1. A number of fixes to charts related to accessibility and the visuals of charts
2. Added more customizable annotations to a variety of charts
3. Added support for principal component analysis, including common rotations like varimax and oblimin.
4. Added a series of common tests and metrics relevant for factor analysis
5. Fixed a bug in data frame filtering where less than equals was broken
6. 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
7. Created documentation for many common statistical tests, from basic analysis of variance style tests to non-parametric equivalents or factor analysis
8. Added some fixes to the descriptive statistics to avoid false results on non-numerical data.
9. Fixed bugs with columns not preserving types in transform longer and wider
10. Fixed a bug in correlation tables causing it to crash if you have a single correlation in the table
11. Made significant improvements to the SVG system for charts, squashing a series of accessibility issues and making them more robust broadly
12. Fixed a series of issues with accessibility and the shadow-dom implementation
13. 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
14. Changed a series of naming conventions across the data science library
15. Added a number of helper actions into the DataFrame to assist in doing various statistical operations more easily
16. 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
17. Added tests for multivariate ANOVAs and factorial ANOVAs to the data science library
18. Added more chart options and defaults to cover a wider array of selected columns and factors.
19. Added a set of helper actions for various operations in DataFrame
20. Added support for flowcharts
21. 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
22. Renamed a number of statistical tests to be more in line with the meaning of what those statistical tests accomplish
23. 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
24. Added tests for variance assumptions for use with multivariate factorial ANOVAs. (i.e. Box’s M Test and factorial Levene’s Test)
25. Added more helper actions for various operations in Matrix
26. Added a test to conduct multivariate Linear Regressions
27. Made a significant number of changes to accessibility with charts after testing across many devices and screen readers
28. 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:

1. 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.
2. 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
3. Created a highly customizable rendering pipeline for blocks inside of an editor. This turned out to be an important efficiency consideration
4. Created a custom accessibility architecture for blocks. Each platform makes assumptions about blocks customized to that modality
5. Changed the gutter architecture to be more flexible than it was. Notably, before they were tied specifically to textboxes
6. Linked Quorum's compiler architecture to the creation of blocks in a whole bunch of strategic ways
7. Added a wide variety of common keyboard affordances for blocks, including basic ones like add, delete, copy, paste, undo, redo, or others
8. 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
9. Created methods whereby freeform blocks automatically turn into the appropriate block types as you move around in the editor
10. 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
11. Created gutters for blocks for line numbers and Git support. Don't worry, we're sending text to git not little pictures ...
12. 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
13. Added a Find dialog for finding items from blocks
14. Added code completion to blocks
15. 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
16. 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
17. 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
18. 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:

1. Native support is now in its own repository, quorum-natives
2. 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
3. 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
4. On iOS, the build is now fully automated. For whatever reason, this system was easier to automate than the others
5. Rewrote font support on iOS devices at the native level, moving it to largely the same system other operating systems are using
6. Removed junk code from the iOS native stack
7. 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 ges...

Quorum 10.6

Quorum Studio 4.6 and Quorum 10.6

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:

1. 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.
2. 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.
3. 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.
4. 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.
5. 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
6. 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.
7. 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.
8. 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.
9. 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.
10. Replaced the table implementation in matrix with the newer DataFrame class behind the scenes
11. 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
12. Added an optimization to the Comparison class for default primitive sorting
13. Added support for Comparisons inside of the Vector class
14. Fixed a memory leak in ShaderProgram causing a considerable number of Text objects to be auto-boxed accidentally
15. Changed the Item and Control classes to not instantiate all of its arrays by default, which saves memory
16. 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.
17. Fixed a bug with ChartComparison where it was creating and throwing away extra objects
18. Lowered the default number of vertices used in the Polygon class, as it was not using the vertices for the common case.
19. Fixed a bug in Polygon that was creating an extra vector that was being thrown away.
20. Fixed a bug where HTML reserved characters were not properly handled when processing SVG images.
21. 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
22. Migrated file downloads to github releases. We will be using this system from here forward to reduce server load and just generally more conventional.
23. Removed the final PHP file from the server backend. Quorum now uses only Quorum for hosting Quorum on the Quorum server.
24. 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
25. Changed the auto-update scripts to account for the change to github
26. Fixed a bug in text fields where double click was not working
27. Fixed a view in text fields where the view was not correctly updating visually with the cursor in some situations
28. Fixed a bug in text fields where triple click was not working

Quorum 10.5

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