Friday, October 19, 2012

Multi-Column Table View

MCT has a new plug-in. Multi-Column Tables demonstrates how to display detailed data from each telemetry object in a collection. While the alphanumeric table view can display the basic value of each telemetry object, this view allows you to show more information about individual objects. Click on a column's name to sort the rows by that value. The set of which columns to display can be customized by the user via the settings pane.

By default, the Multi-Column Tables view displays four columns of information about each object -- its ID, display name, value, and timestamp -- all of which can be resized and reordered by the user.  As with all Open MCT plug-ins, this functionality can be extended as much as needed.

Thursday, October 11, 2012

Non-Time / Non-Time Plots

One of our long-standing feature requests has been to support the plotting of data points against other data points, as opposed to against a time axis. While time-based plots are the norm in mission control, for a few specific disciplines this alternate approach to plotting (which we've become accustomed to referring to as "non-time non-time") is an essential part of their work.

Release 8 Beta 1 introduces this functionality to MCT. In this beta release, it is available as a separate view for collections of multiple telemetry; going forward, it will be incorporated into MCT's existing plot view, and will support the same variety of configuration options.

Monday, October 1, 2012

Release 1.8b1

The first iteration of release 1.8 of OpenMCT is complete. Both source code and binaries are available on Github. This beta version (1.8b1) may be less stable than full releases, but has passed group testing.

New features in this release include preliminary versions of two new views:
  • Non-time/non-time plots, allowing both the x and y axes to display non-time properties
  • Multi-column tables showing additional user-selectable object properties as columns
Future blog posts will explain these features in more detail.

    Sunday, September 9, 2012

    Release 1.7 is Complete

    Release 1.7 of OpenMCT is complete. Both source code and binaries are available on Github. This release is the culmination of four rounds of extensive development and group testing.

    The focus for the final iteration was on bug fixing. Notable improvements included:
    • Plot controls now include year
    • Improved plot limit arrow reliability 
    • Enabling of plot limit arrows on panned and zoomed plots
    • Improved stability of directory area
    • Usability improvements and bug fixes in object staleness / commit tracking

    Thursday, September 6, 2012

    MCT button and icon graphics available for download

    MCT button and icon graphics are now available for download on the OpenMCT website. This zip file contains PSD, PNG, AI, and GIF files for use with developing MCT.

    Wednesday, August 22, 2012

    Object-Oriented GUIs are the Future

    Do you like futuristic prototypes and imaginings of human-computer interfaces such as those sampled on the wonderful site HUDs and GUIs? Be sure to pull down the Categories menu there, and check out the clips from films such as Minority Report.

    Two tantalizing aspects of design illustrated in those clips are embedded and ubiquitous computer hardware and software—computers whose functions manifest not in objects specialized to be "computers," and often not even as "tools," but in objects that already exist for everyday purposes. A common example is a car whose functions are enhanced with computers. More futuristic examples include a door that guesses when a person wants it to open and close, as shown in Star Trek.... Oh, right, that's been in my grocery store for decades. But in the future they will be foolproof. More futuristic examples include pieces of paper that enhance, store, and retrieve what I draw. Embedded and ubiquitous computing do not push just the computer software application into the background of the users' awareness; they push the computer itself into the woodwork.

    We need not wait for embedded and ubiquitous computers before we can get a substantial portion of their benefits by making human-computer interfaces object oriented. "Object oriented" in this sense has nothing to do with whether object-oriented programming is used. Instead, it means that the user interface as perceived by the user is oriented to the users' domain objects rather than to the computer software applications.

    Look carefully at those clips, and notice that even when users are interacting with an overt "computer," rarely are they focusing on "applications" (i.e., "programs"). Watch those clips again, and notice which "things" the users are seeing and manipulating. Those things most often are objects in the users' domains of work or play, rather than the tools (computer applications) that the users use to deal with those domain objects. This is most apparent in direct manipulation gestural interfaces. The users are grabbing, rotating, and flinging people, diagrams, buildings, and spacecraft. Sure, when they fling a "person" from one computer screen to another, they are not flinging the actual person, but they are thinking of that person as what they are flinging; they are not thinking of flinging that "window" to another screen. They do not update the last known location of the evildoer by opening a spreadsheet, finding that evildoer's name in the first column, looking across the rows to find the Location column, then typing to change that row-column intersection's cell from one building's name to another. Instead they simply drag whatever representation of the evildoer they happen to have in front of them (list row, window, picture, icon, ...) onto whatever representation of the new building that is handy (satellite image, schematic, list row, ...). All representations of both the evildoer and the building instantly change to reflect that new association of those objects (evildoer to building). The users focus on the objects of their domain—the objects in their mental models while they are doing their tasks to meet their goals given their situation of use.

    Similarly, users simply flip views of the same manifestation of an object, from graphical to alphanumeric to pictorial to audio, rather than searching again for that same object in each of several different applications, each devoted to only one such type of view. The heroine is looking at a live satellite image of the building, then flips that exact same portion of the screen to show a schematic view of the building, as if putting on x-ray glasses. She does not fire up the separate "Schematic Viewer" application and, once there, hunt down that building. She does not even drag that building's image from the "Satellite Viewer" application to the "Schematic Viewer" application. She merely flips views as if putting on a different pair of virtual eyeglasses, the whole time keeping her vision and therefore her attention fixed on that building in front of her eyes—the domain object of her attention.

    In short, all those futuristic scenarios have the users' mental models of their task domain objects thrown onto the computer displays in front of them. In the futuristic world of embedded and ubiquitous computers, "computers" have no natural place in the users' mental models of their task domain, so the computers have no place as recognizable, concrete, discrete, distracting entities in the users' physical environment. Likewise, the computer software applications have no natural place in the users' mental models of their task domain, so the computer applications have no place as recognizable, concrete, discrete, distracting entities on the displays.

    Back here in the present, most users are stuck not only with physically discrete, intrusive, distracting, attention-demanding, time-consuming computers; they are also stuck with similarly disadvantageous discrete, multiple, computer software applications. Most graphical user interfaces (GUIs) are application oriented. But users need not be so burdened, even today! We have the technology to drastically reduce if not eliminate the notion of the computer application from the user's physical environment, so they can deal with only a single application, and within it focus purely on the objects from their mental model of the task domain. One easy way to implement object-oriented GUIs is to use NASA's Mission Control Technologies (MCT) software platform. Just build plugins to provide additional types of objects, views of objects, and actions on objects. Users simply see all those appear within the same MCT application. It's general purpose, not restricted to space mission operations, and it is open source!

    In a future blog post I will explain a design process for figuring out what the users' objects, attributes, and actions should be. It's called The Bridge, and it is described in Chapter 2 of a book.

    Friday, August 17, 2012

    Open Source Ops Software for Commercial Space?

    It's easy to understand why non-profit organizations want to use free, open source mission operations software such as MCT. For-profit, commercial organizations also like free products, but should they worry about using software that other for-profit companies can use? No, because they don't compete with each other on the basis of their mission operations software, any more than they compete with each other on the basis of their accounting software. Operations software (the software that the ground-based flight controllers use) is necessary, but it is not a selling point; it is not where commercial space flight companies try to add value above the value provided by their competitors. Space companies compete on the basis of the value they add to the services they offer, and the most visible key to that is the flight hardware (vehicle, rocket, satellite...). Companies consider operations software to be a necessary expense. The less money a company spends on their operations software, the more they can spend on their flight hardware and services, and the more profit they can make.

    Flight hardware is customized across companies, so flight software (i.e., the software that runs on the flight hardware) must be customized at its most fundamental level to suit the customized flight hardware. But flight operations software needs to be customized only superficially, in the same sense that a word processing application is "customized" only by writing unique documents with it; the documents are the customization of the word processor, and the flight operations displays are the customization of the flight operations software. Competing companies don't worry about using the same word processor to produce proprietary documents, and the same operations software can be used to produce customized flight operations displays without revealing proprietary information.

    A benefit of using open source software that is common across organizations—commercial or not—is the greater availability of potential employees who already are familiar with that software. Hiring someone who already is familiar with your operations software decreases your training costs, decreases the time needed for a new employee to become productive, and reduces the risk of that employee making mistakes. This is the same benefit companies get when they use a common word processor or accounting package.

    Another benefit of using open source software is the reduced cost of getting new features and bug fixes, especially those that might be discovered during flight operation situations that your own company has not yet encountered. In effect, your company gets free flight operations expertise embodied in the software. Of course, other companies also get your expertise through the same mechanism, but that brings me back to the point I began with: Companies do not compete by adding value to their flight operations software. They want their operations software to be as low cost, low risk, and low hassle as possible so they can focus their resources on providing better value in their flight services and vehicles. A great way to do that is to use the free, open source MCT software!