Technology Commentary

Time to learn about linearizability and its trade-offs, ordering guarantees, sequence number ordering, consensus, and coordination services in distributed systems.

Discover what surprises await in CHM's release of the Xerox PARC file system archive.

A week or so ago I posted a piece called CodeKata, suggesting that as developers we need to spend more time just practicing: writing throwaway code …

So it's been a few weeks, and I decided to cover a cool classic of cognitive science from 1995, How a Cockpit Remembers Its Speed [https://pages.ucsd.edu/~ehutchins/documents/CockpitSpeeds.pdf] by Edwin Hutchins. In this one, Hutchins tries to make the point that the unit of analysis for cognition can be moved to systems larger than individuals, and highlight properties that are distinct and can't be reduced to cognitive properties of people within that unit. Or to put it another way, you can think of cognition as it arises in the whole cockpit, and not just by putting together the cognition of the pilots in it. He shows this by focusing on how a major airliners use a small set of tools to set their speed when approaching a landing. This is an interesting approach because if you want to analyze the cognition of individuals, you have to try to guess what's going on in their minds. If you analyze the cockpit, you can be inside and look at the many representations used and interactions, without having to guess about anyone's thought process. So even though this is a 1995 paper and the calculations and tools for aircraft speed at landing have undoubtedly changed, the contrast between the approaches is what will be of interest here. In terms of landing a plane (an MD-80 [https://en.wikipedia.org/wiki/McDonnell_Douglas_MD-80] in this case), a few steps are mandated and used in nearly all non-emergency circumstances. Some of the key ones have to do with extending the flaps and slats while slowing down (enlarge the wing to increase lift at slower speeds) while slowing down. Based on the runway length, aircraft weight, braking systems, margin for incidents, weather, company preferences, and crew preferences, a reference speed is chosen as a trade-off between going as slow as possible so the landing is safe, but not so much that you can't do a go-around if something goes wrong. The possible configurations and guidelines are in the aircraft's manual and look like this: The Flap/Slat configuration and reference speed table as it appears in the MD-80 operating manual [https://s3.us-east-2.amazonaws.com/ferd.ca/cohost/flap-slat.png] Within the cockpit, there are two pilot stations, where one is considered "flying" (PF) and one is considered not-flying (PNF). The PF deals with piloting the aircraft. The PNF deals with air-traffic control (ATC), deals with checklists, and other systems and duties. With this background set, Hutchins defines three ways of describe the memory for speeds: a procedural one, a cognitive one outside of the pilots, and a cognitive one inside the pilots. A PROCEDURAL DESCRIPTION OF MEMORY FOR SPEEDS The flight is usually at roughly 30,000ft, and has to go down to 18,000ft. To pick the proper wing configuration based on all the factors mentioned earlier, they use a booklet of speed cards, each of which looks like this: A speed card from an MD-80 speed card booklet, showing various reference speeds and slat/flap configurations for a given weight [https://s3.us-east-2.amazonaws.com/ferd.ca/cohost/speed-card.png] The steps are usually, done 25 to 30 minutes before landing: 1. Determine the aircraft weight (continually computed and displayed near the fuel gauge) 2. Find the speed card and put it in a visible place in the cockpit 3. Set up speed bugs on both airspeed indicators So here is what the airspeed indicators look like: airspeed indicator instrument in the McDonnell Douglas MD-80 [https://s3.us-east-2.amazonaws.com/ferd.ca/cohost/speed-bugs.png] and here's an annotated version explaining the speed bugs: airspeed indicator instrument in the McDonnell Douglas MD-80 with annotations: Starting with the bug at 227 knots and moving counterclockwise, the bugs indicate: 227-the minimum maneuvering speed with no flaps or slats extended; 177-minimum maneuvering speed with slats, but no flaps, extended; 152-minimum maneuvering speed with flaps at 15” and slats extended; 128-landing speed with flaps at 40” and slats ex- tended (also called Vref) [https://s3.us-east-2.amazonaws.com/ferd.ca/cohost/speed-bugs-annotated.png] The descent is then done in steps. Get to 250 knots or below before going down to 10,000ft (safer for traffic volume), then going down to 7,000 with speeds matching slat and flaps extension. They start using speed bugs and checklists are usually involved. The author points out: Because it is dangerous to fly below the minimum maneuvering speed for any configuration, extending the flaps and slats well before slowing to the minimum maneuvering speed might seem to be a good idea. Doing so both would increase the safety margin on the speeds and would give the pilots a wider window of speed (and therefore, of time) for selecting the next flap/slat configuration. Unfortunately, other operational considerations rule this out. As one operations manual puts it, “To minimize the air loads on the flaps/salts, avoid extension and operation near the maximum airspeeds. Extend flaps/slats near the Min Maneuver Speed for the flap/slat configuration.” The extension of the flaps and slats must be coordinated precisely with the changes in airspeed. This makes the accurate memory of the speeds even more important than it would be otherwise. At 1000ft, they pick the final flap setting, at 500ft the final approach speed and altitude changes are called out, and keep calling it out if it varies more than 5 knots from the approach speed. A COGNITIVE DESCRIPTION OF MEMORY FOR SPEEDS OUTSIDE THE PILOTS The observable representations in the cockpit processes related to the speed are: the weight display (by the fuel gauge), the speed card booklet, the airspeed indicators with the bugs, the speed selection window in the flight guidance control panel, and the verbal communications between crew members. Hutchins adds two speed representations are not accessible: those in the memories of the pilots. The speed card booklet is a long-term memory item, and can survive the entire life of the aircraft. The weight/speed correspondences too, and they can't be modified by the crew (and there are backups). To filter the speeds in the booklet, they find the current weight and position the booklet in a manner that hides invalid configurations, and then makes this more permanent by picking the appropriate speed card. But not only that, it makes it an artifact visible to both pilots over time, and plays a social role as well as an aide to repeatedly cross-reference speeds and expected weights to re-evaluate choices made. Spoken words and speed bugs are extra representations. Spoken words are interesting because while they're ephemeral, they use sound instead of visual cues, and the PF is already very busy looking at lots of things. As for the speed bugs, they are useful when negotiating the gradual transition between lower speeds and various configurations while also just dealing with the overall approach to landing. As the speed needle approaches the speed bug for the next configuration, the pilot can call for changes in flap configurations. The bugs can provide a bridge between speed and configuration at the current weight. In some airlines, both pilots need to acknowledge the change (both visually and spoken), which gives room to find inconsistencies or mistakes, and to synchronize with their various tasks. Setting the speed bugs is a matter of producing a representation in the cockpit environment that will serve as a resource that organizes performances that are to come later. [...] I call this entire process a cockpit system’s “memory” because it consists of the creation, inside the system, of a representational state that is then saved and used to organize subsequent activities. A COGNITIVE DESCRIPTION OF MEMORY FOR SPEEDS INSIDE THE PILOTS Most of the cockpit's memory is is done through people interpreting various symbols in their environment rather than purely based on memory: speed bugs let pilots pattern match the weights and cards and speeds, without having to actually recall what they are (just where they are). Over time, standard or frequent patterns may become learned and more automatic. Still, reading the cards has been optimized: frequently used speeds are in a bigger typeface than rare ones, and key values (like the Vref) are put in a more visible box. Setting the bugs themselves can be challenging because it is done while piloting the aircraft, changing speeds, reading the values, and so on, and other tasks can mess with the working memory of pilots there. The author suspects that the many redundancies in the process around setting the bugs may help make this process a bit more robust. The interesting visual pattern of bugs is that they end up being markers around speed indicators that create "a space of speeds", meaning that rather than reading specifics speed and flap/slat settings, you can see the needle move, and just deal with things in higher level sequences without requiring as much focused attention on decoding the data: The same speed dial as before, but the space between each bug is annotated, counterclockwise: 0/EXT, 11-15, 28-40, and Danger past the last interval [https://s3.us-east-2.amazonaws.com/ferd.ca/cohost/speed-spaces.png] The key insight as I see it is: In the functional system with speed bugs, some of the memory requirements for the pilot are reduced. What was accomplished without speed bugs by remembering speed values, reading the AS1 needle values, and comparing the two values is accomplished with the use of speed bugs by judgments of spatial proximity. Individual pilot memory has not been enhanced; rather, the memory function has now become a property of a larger system in which the individual engages in a different sort of cognitive behavior. The beauty of devices like speed bugs is that they permit these reconfigurations of functional systems in ways that reduce the requirements for scarce cognitive resources. Similarly for the salmon bug, you don't have t

What do the recent advancements in generative AI mean for APIs?

Bluesky aims to rectify the mistakes of social media and transform the entire internet. Now, Jack Dorsey is seeking user feedback to shape its direction and rescue the online world.

Programming book reviews, programming tutorials,programming news, C#, Ruby, Python,C, C++, PHP, Visual Basic, Computer book reviews, computer history, programming history, joomla, theory, spreadsheets and more.

Shortfall in STEM Students, Low Pay for ICT Pros

Shortfall in ICT Pros Stifling Hoped-For Digital Transformation

I came across a great series of posts by Richard Katz about Japan and information technology. It shows that software has not eaten Japan (for now?). Some interesting facts:– “by 2025, 60% of Japan’s large companies will be operating core systems that are more than 20 years old. Would anyone today use a 2005 PC?” […]

WTF even is DevOps? What does it mean to be a DevOps engineer? Those of us in the technology industry will often (quietly) bemoan the…

One of the greatest pieces of software Apple ever produced is slowly dying because the company can't figure out how to sell it or whom to sell it to. The software is HyperCard, a simple programming environment so powerful yet simple it is used by professionals and children alike. First released in 1987, HyperCard still […]

A glimpse of an alternative economic and industrial history and future, in which the Luddites were successful in their battle against alienating technology.

First there was “Big Media.” Big, publicly owned companies like the New York Times, ABC, and HBO. In 2022, The New York Times reported an adjusted

Making remote clusters accessible, as though local, and giving developers tools to work locally in familiar ways are key ways to zap bugs and ship faster.

Costanza asked Sussman why MIT had switched away from Scheme for their introductory programming course, 6.001. This was a gem. He said that the reason that happened was because engineering in 1980 …

On this episode of the podcast, we talk to Mauricio Linhares, senior software engineer at Stripe, about the pain of migrating monoliths to microservices, defining zero-tier systems, and why plugging all your servers into the same power supply is a bad idea.

Here’s something I do often without even thinking about it.

A Comprehensive Exploration of a Multimedia Powerhouse

Sixteen years ago to the day, I started RailsCasts, a screencast series teaching web development using Ruby on Rails. It began with free weekly episodes and eventually grew to make over $1M a year, but it wasn't sustainable. This is the first of a th...

Datomic introduced a data structure model: entity-attribute-value store, transaction format, Datalog query language dialect. As you get familiar with it, you notice that this model has a lot of nice properties and is, in fact, more thought-out than it may appear at the first glance.