Breaking Stuff with the Keyboard

We are now neck deep in implementing changes for the Quorum 5.0 release. Most of the time when we make changes, we go out of our way to not break backward compatibility. When we do, depending on what kind of system it is we are adjusting, our team internally requires evidence. For example, changes to core syntax or semantics require a randomized controlled trial or other rigorous techniques. If the changes are to something less important, our standards change accordingly. Further, if we identify technical problems, sometimes just make the changes. In other words, if we find a bug, we aren’t going to run an experiment. We’re just going to fix the bug.

For Quorum 5, one change we are making that will break backward compatibility with Quorum 4 is in keyboard constants. Basically, we did a review pass of using keyboard events in the game engine. As we are porting the engine to the web, we noticed every browser and platform was even more varied than we realized (e.g., Safari is very different than Chrome). Further, our keyboard constants were pretty messy and, so far as we could tell, had problems that fell in the technical issue camp. As such, here’s a list of all of the changes to the constants in KeyboardEvent and related keyboard input classes:

Removed

The following constants were removed because they could not be detected by our backend anyway. They represented extra hooks we thought we had, but really didn’t, from way back in the Quorum 3 release.

AT
BACK
CALL
CAMERA
DEL
DPAD_CENTER
DPAD_DOWN
DPAD_LEFT
DPAD_RIGHT
DPAD_UP
CENTER
ENDCALL
ENVELOPE
EXPLORER
FOCUS
HEADSETHOOK
MEDIA_FAST_FORWARD
MEDIA_NEXT
MEDIA_PLAY_PAUSE
MEDIA_PREVIOUS
MEDIA_REWIND
MEDIA_STOP
MENU
MUTE
NOTIFICATION
POUND
SEARCH
SOFT_LEFT
SOFT_RIGHT
SYM
VOLUME_DOWN
VOLUME_UP
META_ALT_LEFT_ON
META_ALT_ON
META_ALT_RIGHT_ON
META_SHIFT_LEFT_ON
META_SHIFT_ON
META_SHIFT_RIGHT_ON
META_SYM_ON
PICTSYMBOLS
SWITCH_CHARSET
BUTTON_CIRCLE
BUTTON_A
BUTTON_B
BUTTON_C
BUTTON_X
BUTTON_Y
BUTTON_Z
BUTTON_L1
BUTTON_R1
BUTTON_L2
BUTTON_R2
BUTTON_THUMBL
BUTTON_THUMBR
BUTTON_START
BUTTON_SELECT
BUTTON_MODE

Changed

The following constants were renamed to make them more consistent with other, similar keys, or just to more closely follow standard Quorum naming conventions:

FORWARD_DEL changed to FORWARD_DELETE
NUM changed to NUM_LOCK
PLUS changed to NUMPAD_PLUS
STAR changed to NUMPAD_STAR

Added

These constants were added to allow for control over a wider number of standard keys on a keyboard.

CAPS_LOCK
PAUSE
PRINT_SCREEN
META_LEFT
META_RIGHT
NUMPAD_DECIMAL
NUMPAD_ENTER
NUMPAD_MINUS
NUMPAD_SLASH
NUMPAD_EQUALS
SCROLL_LOCK

Web Compatibility

All key constants in the new version are usable on the web, with the exception of these constants:

COLON
META_LEFT
META_RIGHT
PRINT_SCREEN
As always with changes that can potentially break an app, if anyone has concerns or comments, they are welcome to email the mailing list. In this case, we imagine this particular change won’t impact many people, but we want to put the information out there anyway.

Quorum Web Update

We have now made significant progress in the lab on the Quorum 5.0 web updates. The following is now working internally for the web version of Quorum:

  1. 2D Graphics: We have all the normal pieces functioning now, except for image sheets
  2. 3D Graphics: Pretty much everything is finished here as well, except for loading custom 3D models.
  3. Sound: Sound works similarly to Quorum in offline mode, except that in-browser sound systems do have some limitations (e.g., HRTF support only instead of 5.1, no doppler). There are also some limitations to specific browsers.
  4. Embedding: On the Quorum site, it will not be long until these little development environments start popping up all over the site. They can now be embedded in our lessons.

We still have a few things left to do. Notably, our testing has been pretty limited so far, we have only embedded into one lesson, and we have not finished our accessibility and user input designs. We are close though and this thing is pretty fun to play with.

This image shows three components. First, there is a normal Quorum development environment, coupled with its error or console window. Finally, there is a canvas window shown, which executes any audio or visual content.

There is one last thing that is worth noting. Right now, if we want to run our games on the web, there is some extra code we have to tell Quorum about, which looks like this:

WebConfiguration config = GetWebConfiguration()
//which HTML canvas do we want to draw on?
//We need to know because there can be multiple games
//on a page
config:canvasID = "instantiateObjectIdeGameOutput"

The reason is because Quorum needs to know which part of a web page to alter for games. It is possible there is a way around this with some sensible defaults, but right now it is the one difference between online and offline modes. Either way, considering there is zero JavaScript required, a pure Quorum solution, it is a small sacrifice.

Screen Resolution Adjustment

One new feature in Quorum 4.0.6, which was requested recently on the mailing list, is an easier way to adjust screen resolutions in games. We have now finished this feature and added a tutorial online:

https://www.quorumlanguage.com/tutorials/games/resolutions.html

This should make it easier to adjust the screen in a variety of ways. With it, one can query the system for what screen sizes are available, set it to an allowable value, or make adjustments on the fly. Because screen sizes could potentially impact in-game cameras in several ways, several versions of the actions are available depending on the desired effect.

Quorum 5.0 Alpha

There are obviously more important things going on in the world today, but we have now posted for the first time the alpha version of Quorum 5.0 online. While alpha implies that not all of the features are in, the team is internally moving toward testing some of the new physics and online features. When this happens, which is about on schedule for the year, we toss up a beta server and give everyone access.

Technically, anyone can access the beta with a special access key that we’ll put below, but most of the time these betas are mostly used by the UNLV team internally. The reason is because none of the documentation is publicly available yet, as we are still inventing everything. Normally, we do not finalize the documentation until after the design is set in stone.

New features in the alpha, besides many of the steps included in the Quorum 4.0.6 release include:

  • Physics Support in 2D Games. Not all features are complete, but many are. Support for 3D is not included.
  • NetBeans 8.2 support. Last year, we kept with the NetBeans 8.0.2 release, but will be moving to 8.2 for the Sodbeans 7 release.

    To access it, we can go to plugins -> Settings and put in the following key: http://quorumlanguage.com/beta/quorum/updates.xml From there we can install the Quorum 5.0 plugin. Note that because of changes Oracle made to NetBeans, this version is not compatible with NetBeans 8.0.2. This means that, since Quorum 4 is built on NetBeans 8.0.2, you can have both Quorum 4 and Quorum 5 beta installed if you wish.

Quorum 4.0.6 Released

Version 4.0.6 has been released for Quorum. This version fixes a number of minor bugs on the system and rolls in some alpha versions of new features planned for Quorum 5.0 (e.g., compile to JavaScript). Some of those features are not fully complete yet, so buyer beware, but we are using them internally and they seem stable enough to make available for testing. Further, this version rolls in a new way of handling various screen and camera resolutions. We have built a tutorial on how to use that, which will be posted live probably next week. Finally, the command line version of the compiler has not been posted live yet, but will be in the relatively near future.

As always, the full release notes are available and the notes for 4.0.6 are posted below:

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.
  • While not yet complete, finished a great deal of the new work on running games on the web.

Smart Girls

Smart Girls put up a nice little video for the outgoing administration:

Looks like I had a cameo. I’m proud to be making my small little contribution to try to make life better for those in our society. This isn’t just for the blind community, even though I care deeply about that, but for everyone!

EPIQ Applications

It’s that time of year again to apply for EPIQ. To remind the reader, here is a direct link to the application:

EPIQ 2017 Application

This year, we are making a small change to the registration process. In previous years, EPIQ has always filled up with more applications then we can accept. So the question the steering committee has struggled with is, how do we fairly filter?

The reality is, we have never had a good answer to this question. Each year until now, the committee has discussed and ultimately voted on applications and scholarships. However, it seems like there often a handful of people leftover where we want to accept and give space to all of them, but where we just do not have the space. In these cases, we feel like all of the candidates are qualified, which makes the decisions rather gut wrenching for all of us on the committee.

Because of this, the committee voted to make one small change to the registration process into account this year. The committee will still vote on applications and accept as many as we can, but once we start running out of room, we have agreed to take application date into account during the process. In other words, if we are forced to say no due to space or funding limitations, we will go with the individual that applied earlier.

Point being: Get your EPIQ applications in earlier for priority consideration!

Twitter Sucks for Science

Twitter is a strange place. To be honest, I am not a big fan and prefer not to use the service. One reason is, amongst many, that it just doesn’t lend itself to scientific discussions. From time to time, against my better judgment, I log on.

Anyway, today is a good example. It’s my son’s birthday in a few days and we were arranging some fun when I get a tweet where I’ve been dragged into a conversation. Some fellow apparently finishing a Ph.D. at Cambridge posts this:

Cool, sounds interesting. I gave a talk at Code Mesh a few years back and actually really loved the venue. Jessica Kerr (@jessitron) talked me into it and I am really glad I went. I recall fondly a wonderful little talk about GPU programming. In any case, this starts a discussion between a few folk I don’t know until eventually this Tomas person drags me into it, for some reason, saying this:

The context, I suspect, is that folks are discussing the role of empiricism. Empirical work has gone on for centuries and takes many forms. I won’t go into that here because there are a ton of textbooks on the subject (e.g., history, methodology, analysis). The author seems to reject running studies. Since I’ve been dragged into it, let’s break the claim down into two parts:

  1. That a controlled study of development and maintenance cannot exist. Perhaps, if generous, the word “imagine” here would imply the author could not think of one. Either way, it is a rejection of either all studies possible or the ones he can imagine.
  2. Large scale systems are “what matters”

Now, for the first, let’s clear a few things up. This is vague. Further, there is a very long history of at-scale experiments in many fields. Even in computer science, studies exist. I’m not the one making the claim here, however, so the author has the burden of proof. Further, what large means in this context is also vague. If a study were to be conducted, at scale X, the author could just move the goalpost higher and say it wasn’t the intended meaning. In short, the argument lacks sufficient specificity, which is one of the advantages of empirical work.

For the second claim, that large scale systems are the ones that matter, this is a moral judgment. I care about students in education, people writing small applications, people with disabilities, women, men, and those writing any kind of applications. I care about scientists writing small scripts with R, people with motor impairments using Scratch, and everything in between. I care about undergrads learning and middle school students writing games. I care about blind people and how they program for any purpose. To argue that some of these applications, or some of these people, do not matter is a moral judgment and I think the author’s argument here is careless. Again, though … twitter. Instead of responding, I just ask for evidence for what the author is thinking. Naively, I assume the author would just send me a citation about their large scale studies claim:

I’m actually curious. If the poster has evidence, I’m always looking for new stuff. It isn’t as if the data is very fleshed out in the literature. Heck, scholars are busy folk and write new papers all the time and my question seemed reasonable. The response is odd:

In short, I ask for evidence about a very specific claim made by someone dragging me into a discussion and I am somehow magically against the “philosophy of science.” Frankly, that’s dishonest. Further, I’m hardly an expert in the philosophy of science, so maybe Kuhn, Feyerabend and Latour had much to say about the human factors impact of static type systems, or something else about computer science. I suspect, however, that in typical twitter style, it’s just a fellow dodging a question.