Cogulator & Workload HFES Workshop October XX, 2016 Steven Estes

Cogulator & Workload HFES Workshop October XX, 2016 Steven Estes
The MITRE Corporation cogulator.io

1:00 Introductions 1:15 Cogulator Introduction 1:30 GOMS 2:00 Cogulator Interface 2:30 Example Models 3:00 Break 3:15 Estimating Workload 3:45 Applied Exercises 4:15 Q&A 4:30 Dismiss

Cogulator is a cognitive calculator.
Cogulator is a cognitive calculator. More specifically, Cogulator is a simple human performance modeling tool developed by MITRE for building KLM, NGOMSL, and CPM-GOMS models. It is free and open source.

Let’s start with a model.
Open up cogulator and we’ll get some sense of what we’ll be doing to do today by building our first, simple model.

Open Cogulator Press the “+” button Type “My First Model” under name Press Enter

Look Point Verify Click
Type each word (an operator) into the modeling text area. Make sure to press Enter after you type “Click”.

You just built your first cognitive model in Cogulator.

Look at the target to click Point to the target
Verify cursor is over the target Click on the target The model you built is of someone pointing and clicking on something with a mouse. To make it a bit clearer as to what’s going on here, we can add a label to each step.

Task Time: 3.1 seconds Working Memory Load: 1.2 chunks
Cogulator returns two basic pieces of information: . Task time, or how long it would take to complete this task . Working memory load: the average number of chunks held in working memory across the task

Verify cursor is over the target Click on the target Operator (more about operators shortly) 950 ms How do we come up with those estimates? Estimates of task time and working memory load are based on the operators that make up the task. Each operator has a time associated with it (Point is 950 ms). Some operators add chunks to working memory (e.g., Store, Recall, Look, Hear)

550 ms Look at the target to click Point to the target Verify cursor is over the target Click on the target 950 ms 1250 ms 320 ms 3070 ms When we take the time value for each operator and sum them, we come up with an estimated time to complete the task. This is an example of a GOMS model. GOMS is the language the Cogulator speaks.

Cogulator is built on GOMS...
What we’ve just built is an executable GOMS model. GOMS is the language of Cogulator.

Goals, Operators, Methods, & Selection Rules
GOMS: Goals, Operators, Methods, & Selection Rules Card, Moran, & Newell, 1983 Card, S., Moran, T, & Newell, A. (1983). The psychology of human computer interaction. Hillsdale, New Jersey: Lawrence Erlbaum Associates. GOMS is based on the idea of a Model Human Processor (MHP). The MHP assumes we have a set of limited and constrained cognitive, perceptual, and motor capacities. It applies years of research to each of these capacities to quantify those constraints. GOMS is a language for expressing the ideas of the MHP within the context of completing some task (or goal-directed behavior).

Goals: What the user is trying to accomplish
E.g., enter a PIN number at the ATM, land an aircraft, check a voic , etc... Goals can be quite broad (i.e., land an aircraft) and fairly specific (enter a PIN number). Broad goals are supported by subgoals. Subgoals persist until we can model at the level of a GOMS operator. We’ll talk about operators in just a moment, but let’s look at an example model with subgoals.

. Goal: Open up the phone app . . Look Phone app icon
Goal: Dial A Friend . Goal: Open up the phone app . . Look Phone app icon . . Touch Phone app icon . Goal: Select favorites . . Recall contact is in favorites . . Look at Favorites button . . Touch Favorites button . Goal: Select the contact . . Search for contact in list . . Touch contact [Will show this model live during presentation] Here’s an example model for dialing someone listed in your favorites on your iPhone. Notice the main goal is defined by three subgoals. The “.” show the model hierarchy.

Operators: Perceptual, motor or cognitive actions

Methods: The series of steps (each containing an operator) necessary to accomplish a goal

. Look at the target to click . Point to the target
Goal: Point and Click . Look at the target to click . Point to the target . Verify cursor is over the target . Click on the target Method Returning to the model you built, we can see that it is of someone pointing and clicking on something with a mouse. To make it a bit clearer as to what’s going on here, we can add a label to each step and place a goal statement at the top.

GOMS: Goals, Operators, Methods, & Selection Rules
Selection rules are if then statements used to illustrate the flow of control in GOMS models. Cogulator simplifies GOMS (and becomes more calculator like) by eliminating the use of selection rules.

Cogulator accommodates KLM, NGOMSL, & CPM-GOMS
KLM: Card, Moran, & Newell, 1983 NGOMSL: Kieras, 1996 CPM-GOMS: Gray, John, & Atwood, 1993 Card, S., Moran, T, & Newell, A. (1983). The psychology of human computer interaction. Hillsdale, New Jersey: Lawrence Erlbaum Associates. Kieras, D., (1996) A Guide to GOMS Model Usability Evaluation using GOMSL and GLEAN4, University of Michigan. Gray, W., John, B., and Atwood, M. (1993). Project ernestine: validating a GOMS analysis for predicting and explaining real-world task performance. Hum.-Comput. Interact. 8, 3 (September 1993), DOI= KLM (Keystroke Level Model): The simplest GOMS modeling method. Contains no goal structure. Card, Moran, & Newell have well defined rules for placement of Mentals (i.e., Think & Verify) NGOMSL (Natural GOMS Language): Works at roughly the same level as KLM, but includes goal structure and methods. CPM-GOMS (Cognitive Perceptual Motor-GOMS): The lowest level expression of GOMS. Works at the level of individual cognitive, perceptual, and motor cycles (~70 ms). Example on the following slide.

. Look at the target to click . Point to the target
Goal: Point and Click . Look at the target to click . Point to the target . Verify cursor is over the target . Click on the target We started with a point and click model in KLM (just the operators). Then we created the model in NGOMSL, as on this slide.

. Attend to Hand position . Initiate Cursor movement
Goal: Point And click . Attend to Hand position . Initiate Cursor movement . Also: Attend to button as eyes . . Attend to button . . Initiate Eye movement to button . . Saccade to button . . Look at button (100 ms) . Point to button . Cognitive_processor verify cursor over button . Attend to finger . Initiate Click . Click (90 ms) [Will bring up a live version of this in Cogulator] This is the point and click model in CPM-GOMS. Obviously, the CPM-GOMS model is significantly more detailed and complex. Don’t let the complexity discourage you. Once you pick up on the patterns in CPM-GOMS it becomes much easier to understand. And, it’s often not necessary to model at this level of detail. We won’t spend too much time on CPM-GOMS today. However, it’s available in Cogulator should you need it.

GOMS assumes expert, error-free behavior.

Typically used for evaluation of usability & efficiency.

Today we’ll show how to use GOMS
(& Cogulator) for workload assessment.

A digression...

Cogulator is a tool. Before we talk about workload assessment, it’s worth pointing out that Cogulator is “a” tool, not “the” tool. Within the bounds of its defined purpose it’s been shown to work very, very well. It, however, does not design interfaces… you design interfaces. It does not assess workload… you assess workload. That is, GOMS will provide you some estimates that can inform the work you do, not do your work for you.

Cogulator’s Interface
At its most basic, Cogulator is a GOMS text editor and, as such, the primary interface component is for text entry (see image below). In addition, there are interface elements for managing existing models, reviewing and inserting operators into a model, a Gantt chart visualization of the model, and a display that provides the estimated task time and information on the current model state (Does it contain errors? Is it current?).

Creating a model [Will be illustrated with a live demonstration]
To build a new model, click the new model button. Doing so presents a dialogue box with two blank fields. Input into the collection field is optional. Collections allow you to place models into groups (discussed in more detail in the Management section). A model name is required. The name must be unique and contain no spaces (underscores will automatically be inserted in place of spaces as you type). If you try to enter a model name that already exists, a red “x” will appear next to the name field along with a note indicating the model name is already in use. Once a unique model name is entered into the text field, you can press the Enter key, which will create the new model.

Saving a model [Will be illustrated with a live demonstration]
In Cogulator, every time the application is closed or a new model is opened, the currently open model is saved automatically. You can manually save the model at any time by pressing the save button located to the right of the new model button.

Model status [Will be illustrated with a live demonstration]
Each time a new line is added to the model (i.e., each time the enter key is pressed), the task time estimate and Gantt chart (to be described shortly) is updated. In addition, the model can be updated manually by pressing the refresh button. If the model has been changed (text added or removed), but not updated, the task time fades. If there is an error in the model, the task time will be replaced with “…”.

Model management [Will be illustrated with a live demonstration]
It’s often nice to be able to quickly open other models to borrow commonly used methods. As such, Cogulator takes a slightly different approach to file management. Rather than the traditional File > Open process, all existing models are listed along the left side of the interface (a la Brackets) for easy access to other models. The currently open model is noted with a small arrow indicator. When you first install Cogulator, a default set of models will be included in the Examples collection. To open a model, find it in the list and click it. Models can be marked for deletion by hovering over the model name and then clicking the “x” that appears to the far left. At this point the model has not actually been deleted and you can undo this action by hovering over the name again and click the “u” button (located where the “x” was). Any models marked for deletion will be moved to the trash when the application is closed.

Operators Interface [Will be illustrated with a live demonstration]
Even those familiar with GOMS may have a difficult time remembering all the operators available and their specific formatting requirements. In order to help, we’ve provided an Operators sidebar in the tab menu on the left side of the interface. Influenced by Bret Victor’s “dump the parts bucket on the floor” strategy, the Operators sidebar lists all the operators, grouped by cognitive, perceptual, and motor resources. Hovering over an operator in the sidebar will temporarily insert it into the text editor at the cursor location. If the operator is not clicked, removing the cursor from the operator will remove the inserted text from the editor. Otherwise it will remain.

Creating a model [Will be illustrated with a live demonstration]
To build a new model, click the new model button. Doing so presents a dialogue box with two blank fields. Input into the collection field is optional. Collections allow you to place models into groups (discussed in more detail in the Management section). A model name is required. The name must be unique and contain no spaces (underscores will automatically be inserted in place of spaces as you type). If you try to enter a model name that already exists, a red “x” will appear next to the name field along with a note indicating the model name is already in use. Once a unique model name is entered into the text field, you can press the Enter key, which will create the new model.

Errors & Tips Interface
[Will be illustrated with a live demonstration] Inevitably you’ll make some errors as you begin working with the CMN-GOMS syntax. Cogulator has some initial, rudimentary error color-coding in place to help you along the way. When an error is detected, the text containing the error is colored red. In the example below, the operator has been misspelled and cannot be interpreted. In addition to error color-coding, Cogulator can walk you through both errors in the model and suggest hints for improving it. For example, modelers often forget to use a Hands operator when the user moves their hands from the mouse to the keyboard (or vice versa). Clicking on the hints button (which is only visible when errors/hints exist) will provide suggestions and some cases correct potential issues for you. The line to which current hint is referring is highlighted in the code. For example, clicking the word “Add” in the hint below would insert a Hands operator prior to the Type operator.

Gantt Chart [Will be illustrated with a live demonstration]
At the bottom of the interface is an up arrow which brings up the Gantt chart. The Gantt chart visualizes the model, showing each operator time, what resources it uses, and instances of parallel execution (discussed in the next section). Note that clicking on an operator in the Gantt chart will take you the corresponding line in the model syntax. Clicking the camera icon located at the bottom left of the chart will save a screenshot of the chart to your desktop.

Multitasking [Will be illustrated with a live demonstration]
Borrowing from NGOMSL, Cogulator allows for multitasking via the Also statement. So, should a goal need to be executed in a parallel with another goal: . Goal: Point and Click would be replaced with . Also: Point and Click as Hands Strictly speaking, the “as” is only required if more the one additional thread is going to be used to model multitasking (in most cases, one will be all you need). You can think of a thread as adding a new lane to a highway. Everything that has the same label after the “as” will be in the same lane and therefore will happen serially. Operators in other threads can occur in parallel to the new thread. As with operator labels, the thread label is user-defined. Parallel execution is visualized in the Gantt chart. An example of parallel and serial execution of the same tasks is depicted in the image below. In the example, an imagined telephone operator needs to log into a workstation just as they receive their first call. In the serial example (upper panel), the call is received and then the operator logs in. These tasks happen in parallel in the lower panel. Note that new threads are randomly assigned their own color (green in this example) to distinguish them from the base thread.

Working memory load [Will be illustrated with a live demonstration]
One of the features we’re currently working on in Cogulator is an analysis of Working Memory load. To simulate working memory load, Cogulator adds chunks to working memory each time certain operators are used. Those operators include: Store (which you can use to explicitly force a chunk into working memory), Recall, Look, Search, Perceptual_processor, Listen, or Think. Automated working memory analysis can be disabled by click the underlined “Do” at the bottom left of the chart Each chunk added to working memory is represented as a colored block in the Gantt chart. Over time, those memories begin to decay, until they’re no longer accessible. That decay is symbolized in the chart with the use of transparency - the blocks becoming more and more translucent until they leave memory altogether. The primacy and recency effects of memory are accounted for in the current algorithm.

Example Models [In walking through the example models, I will build the models live and attendees will mimic on their laptops. This will give them more familiarity with the interface and interactions. In the applied exercises, that follow the example models, attendees will generate the model on their own. I will then provide the “answer” and answer questions they encountered during the model building process.]

Example 1: Model of building a KLM model.
[I’ll walk through building the following model] *The Keystroke Level Model is a flat, serial list of all the interactions (operators) you need in order to accomplish some goal. In this example, we're listing the steps necessary to create a new model in Cogulator: ** 1st: Click the '+' button to bring up the new model dialog ** 2nd: Enter a model name ** 3rd: Enter a collection name ** 1st: Click the '+' button, then you enter the collection name Look at 'New' button Point to 'New' button Click 'New' button Look at 'Model Name' Field Think of model name Hands to keyboard Type KLM Verify Correct Keystroke Tab key Look at 'Collection Name' Field Think of collection name Type Ex *Only have to enter Examples' will autocomplete Verify Autocomplete is correct Keystroke Enter key *For comparison, check out the NGOMSL model. It's almost identical, but has goal statements. Whether or not you use goal statements will depend on a few things, including the complexity and depth of the task you're trying to model. As a general rule, if any of your goals have subgoals, you'll probably want to include goal statements throughout.

Example 2: Model of building an NGOMSL model
[I’ll walk through building the following model] *Natural GOMS Language (NGOMSL) allows us to structure our task model around a series of goals to be accomplished to complete some task. In this example, we're modeling someone creating a new model in Cogulator: ** 1st: Click the '+' button to bring up the new model dialog ** 2nd: Enter a model name ** 3rd: Enter a collection name ** 1st: Click the '+' button, then you enter the collection name Goal: Press the 'New' Button .Look at 'New' button .Point to 'New' button .Click 'New' button Goal: Enter model name .Look at 'Model Name' Field .Think of model name .Hands to keyboard .Type NGOMSL .Verify Correct .Keystroke Tab key Goal: Enter collection name .Look at 'Collection Name' Field .Think of collection name .Type Ex *Only have to enter Ex, 'amples' will autocomplete .Verify Autocomplete is correct .Keystroke Enter key *For comparison, you might want to check out the KLM model. It's almost identical, but doesn't have any of the goal statements. Whether or not you use goal statements will depend on a few things, including the complexity and depth of the task you're trying to model. As a general rule, if any of your goals have subgoals, you'll probably want to include goal statements throughout. It'll make your model easier to read and understand. *The CPM-GOMS example models this same task. In it, you'll see a slightly more detailed version of the model and allowances for multitasking. Note, there's no reason you can't use multitasking in simpler, NGOMSL models. Check out the 'Listen to Lecture' goal in Sundry Methods in the Examples collection for an example of multitasking in a simpler task.

Example 3: Model of building a CPM-GOMS model (with multitasking)
[I’ll walk through building the following model] *In the example below - a model of creating a new model in Cogulator - we're using a mixture of NGOMSL and CPM-GOMS operators to complete the following goals: ** 1st: Click the '+' button to bring up the new model dialog ** 2nd: Enter a model name ** 3rd: Enter a collection name * You can see simpler ways to model this task in the 1_KLM and 2_NGOMSL examples Goal: Point and click 'New' button . Attend to Hand position . Initiate Cursor movement .Also: Attend to New Button as eyes .. Attend to 'New' button .. Initiate Eye movement to 'New' button ..Saccade to 'New' button ..Look at 'New' button (100 ms) . Point to 'New' button . Cognitive_processor Verify Cursor is over 'New' button . Attend to Finger . Initiate Click . Click (90 ms) Goal: Enter Model Name .Attend to 'Model Name' Field .Initiate Eye movement to 'Model Name' Field . Also: Move Hands to Keyboard as hands ..Attend to hands ..Initiate move hands ..Hands to Keyboard (300 ms) .Saccade to 'Model Name' Field .Look at 'Model Name' Field (100 ms) . Think of Model Name . Initiate Typing CPM-GOMS . Type CPM-GOMS . Attend to Typed Text . Initiate Eye movement to Typed Text . Saccade to Typed in Text . Look at CPM-GOMS for (150 ms) * about 300 ms to proofread a word, including saccade. So, we subtract out the saccade time of 150 ms, leaving us with 150 ms . Cognitive_processor Verify Correct . Attend to Tab Key . Initiate Tab Enter Key . Keystroke Tab key Goal: Enter Collection Name .Attend to 'Collection Name' Field .Initiate Eye movement to 'Collection Name' Field .Also: Saccade to Collection Field as eyes_too .. Saccade to 'Collection Name' Field .. Look at 'Collection Name' Field (100 ms) . Think of which Collection to place model in .Attend to Typing Examples . Initiate Typing Examples . Type Ex *after typing Ex the user sees the field has autocomplete . Attend to autocompleted text . Initiate saccade to autocompleted text . Saccade to autocompleted text . Look at autocompleted text (150 ms) * about 300 ms to proofread a word, including saccade. So, we subtract out the saccade time of 150 ms, leaving us with 150 ms . Cognitive_processor Verify autocomplete . Attend to Enter Key . Initiate Key Enter Key . Keystroke Enter key *As you build models with multitasking, remember that Cogulator is essentially just a calculator, not a genuine cognitive architecture. One of the ramifications of that is you'll need to check the Gantt chart and make sure the model is generating sensible results. For example, if a multitasked method is not completing before some dependent action in the main method, you'll need to move the multitasked method up a few lines.

Example 4: Model of Working Memory Load
[I’ll walk through the mental math model that comes standard with Cogulator]

Estimating Workload

Let’s talk about estimating workload with Cogulator.

Temporal Workload: A measure of time on task

ACCEPT A HANDOFF VOICE ACCEPT A HANDOFF DATA LINK ~10 seconds
Goal: Accept a Handoff . Goal: Determine Action . . Look at aircraft on display . . Think of appropriate action . Goal: Pilot Call In . . Hear “Center United 6 14 checking in level at 3 3 0” (18 syllables) . Also: Data Entry . . Point to aircraft on display . . Click Trackball Button . Goal: Controller Acknowledgement . . Verify Channel is clear (1000 ms) . . Say United 6 14 denver center good morning (13 syllables) Goal: Accept a Handoff . Goal: Determine Action . . Look at aircraft on display . . Think of appropriate action . Goal: Data Entry . . Point to aircraft on display . . Click Trackball Button . . Search In Box for response . . Verify accepted Here’s an applied example from air traffic control. Today, to accept a handoff the controller must click on the traffic target on the screen and communicate verbally with the pilot who is checking in on the sector. Using a future technology like Data Link, it would be possible to eliminate the verbal communications, replacing them with the equivalent of automated text messages. In these notional models, we see that doing so could save up to 4 seconds each time the controller performs that task. That is, for this task the temporal workload is reduced by 40%. ~10 seconds ~6 seconds

Temporal Workload: A measure of utilization Wickens et al, 2013
Cummings, M.L., Operator Interaction with Centralized Versus Decentralized UAV Architectures, Handbook of Unmanned Aerial Vehicles, Springer, in press. Lee, PJ., Kolling, A., Lewis, M. (2011). Workload Modeling using Time Windows and Utilization in an Air Traffic Control Task. Proceedings of the Human Factors and Ergonomics Society Annual Meeting 55. Wickens et al (2013). Modeling and Evaluating Pilot Performance in NextGen: Review of and Recommendations Regarding Pilot Modeling Efforts, Architectures, and Validation Studies. Technical Report Human Centered Systems Lab (HCSL) # NASA Ames. Wu, Changxu (2007). Queueing Network Modeling of Human Performance and Mental Workload in Perceptual-Motor Tasks (Unpublished dissertation). The University of Michigan.

If a controller does 10 minutes of observable work (600 seconds), not counting handoffs, every 15 minutes (900 seconds). If they accomplish 20 handoffs every fifteen minutes... Assuming 10 seconds/handoff using the voice method handoff workload would be 20 x 10 or 200 seconds total workload would be or 800 seconds utilization would be 800/900 or 0.88 Assuming 6 seconds/handoff using the data link method handoff workload would be 6 x 10 or 60 seconds total workload would be or 660 seconds utilization would be 660/900 or 0.73 [Illustrated via interactive graphic during presentation] Schmidt, D. (1978). A Queuing Analysis of the Air Traffic Controller's Work Load. IEEE Transactions on Systems, Man, and Cybernetics, 8(6). Tatjana Bolic, T., Rakas, J., and Hansen, M. (2005). Controller-Pilot radio channel utilization and cognitive issues. 6th USA / Europe Air Traffic Management R&D Seminar. Baltimore, MD. While it’s nice to know that the task time has been reduced noticeably, the actual impact of that reduction depends a) on how often this particularly task is executed and b) the amount of time available to complete the task. To assess impact, we’ll use a measure called Utilization. In psychology, utilization is simply the time-on-task divided by the amount of time available to accomplish that task. Ideally, observed utilization is less than Here we show the impact of the reduction in task time on the controller’s overall workload The commonly accepted threshold for utilization is 0.8 Schmidt, 1978

Temporal Workload: A measure of time pressure
NASA-TLX classifies temporal workload as a feeling of being under time pressure. To measure time pressure, you have to understand how perceived pressure changes as time becomes less available. We can measure the latter with Cogulator (utilization), but we don’t have a measure of how perception of time pressure varies with utilization. We are conducting research on this topic right now.

The amount of information held in working memory
Working Memory Load: The amount of information held in working memory Estes, 2005 Lerch, Mantei, & Olson, 1989 Yeh & Wickens, 1988 Estes, S.L. (2005). Arriving from Delphi at O’Hare: Predictive Cognitive Engineering in the O’Hare Modernization Project and Beyond. In Proceedings of the 49th Annual Meeting of Human Factors and Ergonomics Society, Orlando, FL Lerch, F. J., Mantei, M. M., & Olson, J. R. (1989). Skilled financial planning: The cost of translating ideas into action. Proceedings of CHI 89, New York, NY: ACM. Yeh, Y.Y. & Wickens, C.D. (1988). Dissociation of performance and subjective measures of workload. Human Factors, 30(1),

[Will bring this model up live during the workshop]
Here we have a model of someone dialing a number as someone speaks the number aloud. You can see that, by the time you get to the end of the number, most of the information has decayed from working memory. This model tells us a couple of things. First, the ten digit number causes overloads, as indicated by the red triangles [latest version has temporarily removed the red triangles, and therefore they are not in this image. When functionality is restored, I’ll update]. Second, by the time you get to the end of the number, most of the information in working memory has decayed to the point that it cannot be recalled. [Bring up alternative model] We can also see that someone who dials more quickly, will have fewer issues with recall all other things being equal. Across the entire model, average working memory load is 4.2 chunks. Generally, sustainable load should average less than 3 or fewer chunks. Further, we observed that the user exceeded the working memory threshold of Together, these pieces of information that working memory load is too high for error free performance of this task. As the modeler and evaluator, it’s up to you decide whether this is problematic. In this case, while not ideal, there’s no safety risk. At worst, I have to ask for the number again.

The availability of information held in working memory
Working Memory Load: The availability of information held in working memory Estes, 2015 Estes, S. (2015). The workload curve: subjective mental workload. Human Factors, 57(7),

[Bring iPhone model back up]
Another way to consider working memory load is a function of the availability of working memory. In my study of the connection between working load and perceived mental workload, I found that perceived workload was best predicted by memory availability rather than memory load. Working memory chunks decay over time. The rate of decay is affected by the number of chunks held in memory: the more chunks in memory, the faster the decay rate. We can illustrate this with a thought exercise. Imagine you’re given two tasks. In the first, you sit in front of a computer and numbers are presented one at a time on the screen. Your only goal is to concentrate on each number while it remains on screen. You would likely perceive the working memory load to be quite low (to the point of boredom). Now imagine your task is the same, except for this time, you have to decide whether the number you’re currently looking is the same as one of the previous two numbers (n-back task). Most folks find this task to be very difficult and rate it as imposing high mental workload. The same numbers are entering memory in both cases. It’s not until we have to recall those numbers that we begin to perceive the task as difficult. That is, the availability of the memory is driving our perception of workload. Cogulator provides an estimate of perceived load based on availability when you model the recall of a chunk from working memory. The estimate is on a scale of 1 to 10 where 1 is low mental workload and 10 is high. Keep in mind that, though this is a function driven by empirical research, it is new and the research has not been subjected to replication.

Perceived mental load is a function of
availability of memory, not the total load. Load is a factor in availability, but not the only factor

Applied Exercises

Exercise 1: Typing on smartphone vs keyboard
Build two models of someone typing “Savannah” into a text field (with a keyboard) To begin, the user must first find the text field and click/touch it In the smartphone model, assume the typist must search for each key before touching it In the second, assume the person is a touch typist If you have questions along the way, don’t hesitate to ask. We’ll compare notes in five minutes. Note: These models exercise a variety of operators. The point is not whether it’s faster to type on an smartphone or keyboard (some folks get to near touch typing speeds on smartphones), but to think about how the task affects operator selection.

Exercise 2: Utilization
Let’s use the two models you just built to compute a utilization score Imagine you completing a task that requires you to perform a map based search 10 times minute What would the utilization score be for each typist? If you have questions, don’t hesitate to ask. We’ll compare notes in five minutes.

Exercise 3: Multitasking
The assistant answers the phone, “Hello, ACME widgets, Shelly Silverstein’s office.” Caller: “Hey, it’s Sarah, is Shelly in?” Assistant: “Sure, let me put you through.” While saying “Sure, let me put you through” the assistant types “32790” into the phone management system. Standard keyboard & phone number field already selected. Right after saying “Sure, let me put you through” the assistant presses the enter key If you have questions, don’t hesitate to ask. We’ll compare notes in five minutes.

Final Exercise: An applied problem and/or Questions?
In the last 15 minutes, I’m going to give you a chance to work on a model that might have relevance to your applied work. As you build the model, feel free to ask questions. If you don’t have anything you’re particularly interested in building a model of, feel free to ask more general questions about Cogulator or modeling workload.

Want the latest version?
Find it at Find a technical problem or bug? Report it at Need a GOMS reference? Start with Card, Moran, & Newell: The Psychology of Human Computer Interaction NGOMSL (Kieras): Need Cogulator reference material? Find it at

Thanks for coming!

Backup

Level of Detail: Unit-task

Unit tasks are subtasks of a larger task that take 10 to 30 seconds to perform

NEWELL’S LEVELS OF ANALYSIS
World (theory) Scale (sec) Time Units System Analysis Social & Organizational decades Technology Culture years Development months Design Education week Task Bounded Rationality 100000 days Traditional Task Analysis 10000 hours 1000 10 min 100 min Subtask Unit Task Analysis Cognitive Band 10 10 sec Unit task Cognitive Task Analysis 1 1 sec Activities Microstrategy Analysis 1/3 sec Embodied cognition Production Rules 0.1 100 ms Production Rule Elements (DME-MA-VA) Biological Band 0.01 10 ms Elements Architectural 0.001 1 ms Parameters NEWELL’S LEVELS OF ANALYSIS

Cogulator & Workload HFES Workshop October XX, 2016 Steven Estes

Similar presentations

Presentation on theme: "Cogulator & Workload HFES Workshop October XX, 2016 Steven Estes"— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

Cogulator & Workload HFES Workshop October XX, 2016 Steven Estes

Similar presentations

Presentation on theme: "Cogulator & Workload HFES Workshop October XX, 2016 Steven Estes"— Presentation transcript:

Similar presentations

About project

Feedback