Study guide

11.1 Event-Driven Programming, Asynchronous Events, and Concurrency

Praxis Computer Science 5652

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Praxis 5652 Exam Overview and ETS Pseudocode

1.1 Praxis 5652 Test Facts, Scoring, and Registration 1.2 Official ETS Pseudocode Notation and Tracing Strategy

2 Chapter 2: Impacts of Computing: Innovation, Access, and Effects

2.1 Computing for Creativity, Problem Solving, Communication, and Innovation 2.2 Equal Access, the Digital Divide, and Accessibility 2.3 Beneficial and Harmful Effects of Computing Innovations

3 Chapter 3: Impacts of Computing: Intellectual Property, Ethics, Privacy, and Security

3.1 Intellectual Property: Copyright, Open Source, and Creative Commons 3.2 Ethical and Unethical Computing Practices and Their Implications 3.3 Privacy, Security, Data Collection, and Local vs. Cloud Storage

4 Chapter 4: Algorithms and Computational Thinking: Abstraction, Decomposition, Number Bases, and Representation

4.1 Abstraction and Abstraction Hierarchies 4.2 Decomposition, Pattern Recognition, and Developing Algorithms 4.3 Number Bases: Binary, Octal, Decimal, and Hexadecimal 4.4 Algorithm Formats: Natural Language, Flowcharts, Pseudocode, and Tracing

5 Chapter 5: Algorithms: Efficiency, Limits of Computing, and Randomization

5.1 Algorithm Efficiency: Linear, Quadratic, Exponential, and Logarithmic Growth 5.2 Limits of Computing: Unsolvable Problems, Intractability, and Heuristics 5.3 Randomization, Random vs. Pseudorandom Numbers, and Scaling to a Range

6 Chapter 6: Algorithms: Searching, Sorting, and Recursion

6.1 Searching Algorithms: Linear Search and Binary Search 6.2 Sorting Algorithms: Tracing, Comparisons, Correctness, and Efficiency 6.3 Recursion: Base Cases, Tracing, Errors, and Iterative Equivalents

7 Chapter 7: Programming: Variables, Data Types, Strings, and Expressions

7.1 Variables, Data Types, and Type Conversion 7.2 Strings and String Operations 7.3 Operators, Precedence, Expressions, and Formulas 7.4 Boolean Expressions, Truth Tables, and Boolean Algebra

8 Chapter 8: Programming: Selection, Iteration, and Writing Code

8.1 Sequence and Selection: if, else, Chained and Nested Conditions 8.2 Iteration: for, while, do … while, and repeat … until Loops 8.3 Reading, Completing, and Modifying Code

9 Chapter 9: Programming: Procedures, Arrays, and Data Structures

9.1 Procedures, Parameters, Return Values, Nested Calls, and Scope 9.2 Arrays, Lists, and Two-Dimensional Arrays 9.3 Stacks, Queues, and Dictionaries (Maps)

10 Chapter 10: Programming: Correctness, Errors, Testing, and Code Quality

10.1 Program Correctness: Preconditions, Postconditions, Invariants, and Testing vs. Proof 10.2 Error Types and Debugging Techniques 10.3 Choosing Useful Test Cases: Boundaries, Partitions, Coverage, and Regression 10.4 Extensibility, Modifiability, and Reusability: Constants and Parameterization 10.5 Documentation, Code Reviews, Peer Feedback, and End-User Feedback

11 Chapter 11: Programming: Events, Usability, Input Validation, and APIs

11.1 Event-Driven Programming, Asynchronous Events, and Concurrency 11.2 Usability, Meaningful Error Messages, and Input Validation vs. Verification 11.3 Libraries and APIs: Reading Definitions, Making Calls, and Weighing Trade-offs

12 Chapter 12: Programming: Languages, Tools, Paradigms, and Object-Oriented Design

12.1 Low- and High-Level Languages, Compilers and Interpreters, and IDEs 12.2 Programming Paradigms: Procedural, Object-Oriented, and Others 12.3 Classes, Objects, Instance Variables, Methods, and Encapsulation 12.4 Inheritance, Polymorphism, and Overloading vs. Overriding

13 Chapter 13: Data: Bits, Encoding, Compression, and Encryption

13.1 Bits and Bytes: Why Binary, Storage Calculations, and Signed Integers 13.2 Encoding Text, Images, and Sound 13.3 Lossless and Lossy Compression: Run-Length Encoding, Huffman Coding, and Media Formats 13.4 Encoding vs. Encryption, Symmetric and Public-Key Encryption, and Their Trade-offs

14 Chapter 14: Data: Analysis Tools, Simulation, Storage, and Collection

14.1 Analyzing Data with Spreadsheets: Cleaning, Transforming, and Visualizing 14.2 Simulation and Modeling 14.3 Files, Databases, and Storage Requirements: Scale, Redundancy, and Backup 14.4 Collecting, Aggregating, and Generating Data: Public Data Sets, Surveys, Sensors, and Crowdsourcing

15 Chapter 15: Computing Systems: Hardware, Operating Systems, and Computing Environments

15.1 Hardware Components and the Fetch–Decode–Execute Cycle 15.2 Operating Systems, Software Components, and Resource Issues 15.3 Embedded Systems, the Internet of Things, and Types of Computing Systems 15.4 Local, Network, and Cloud Computing and Storage; How Binary Data Are Stored

16 Chapter 16: Networks, the Internet, the Web, and Cybersecurity

16.1 Network Types and Wired and Wireless Communication 16.2 Network Hardware and Layered Network Models (OSI and TCP/IP) 16.3 Network Performance: Bandwidth, Latency, Load, and Estimating Needs 16.4 How the Internet Works: Protocols, IP Addressing, DNS, URLs, and Reliability 16.5 The Web: HTTP, HTML and Markup Languages, Browsers, Servers, and Clients 16.6 Cybersecurity: The Five Pillars, Strong Passwords, Security Strategies, and Trade-offs

11.1 Event-Driven Programming, Asynchronous Events, and Concurrency

Key Takeaways Explain This Topic AI

In an event-driven program, an event loop waits for events and calls the handler registered for each one, so the order of execution depends on the order of events.

To trace event-driven code, apply the handlers one at a time in the order the events occur, carrying shared state from one handler to the next.

Asynchronous events can arrive at any time and in any order, causing bugs such as processing a double click twice or using data before a request has finished.

A race condition occurs when concurrent code reads and writes shared data and the result depends on timing; two updates to count ← count + 1 can overlap so that one is lost.

Fixes include disabling a control while it is being processed, checking state before acting, making updates atomic with locks, and handling events through a queue.

Last updated: September 2026

What this competency asks

ETS asks you to know the concepts of event-driven programs that respond to external events (for example, sensors, messages, and clicks). Beyond tracing, finding inputs for given outputs, describing purpose, and supplying missing code, you should be able to:

Identify possible errors due to asynchronous events.

Identify aspects of concurrency in event-driven programming.

How event-driven programs work

A traditional program runs from top to bottom. An event-driven program instead waits for events and reacts to them.

  • Part Role
  • Event Something that happens: a click, a key press, a timer tick, a sensor reading, an arriving message
  • Event handler (callback) The procedure that runs when a particular event occurs
  • Registration Connecting a handler to an event source, such as "when this button is clicked, call onSubmit "
  • Event loop Runs continuously, takes the next event (often from a queue), and calls its handler
  • Examples
  • Scratch: when green flag clicked , when this sprite clicked , when I receive [message]
  • JavaScript: button.addEventListener("click", handleClick)
  • A microcontroller: when the motion sensor detects movement, turn on the light
  • A chat app: when a new message arrives, display it

Games, graphical interfaces, web pages, mobile apps, and Internet of Things devices (Section 15.3) are all event-driven.

Tracing event-driven code

Handlers share state through variables. To trace, apply the handlers in the order the events occur . int count ← 0

  • void onAddClick ( )
  • count ← count + 1
  • print count // print a space after the value
  • end onAddClick
  • void onResetClick ( )
  • count ← 0
  • end onResetClick

Events: Add, Add, Reset, Add, Add.

  • Event Handler count after Printed
  • Add onAddClick 1 1
  • Add onAddClick 2 2
  • Reset onResetClick 0 —
  • Add onAddClick 1 1
  • Add onAddClick 2 2

Output: 1 2 1 2 . A different event order gives different output from the same code. That is the defining feature of event-driven programs.

Working backward: to produce the output 1 2 3 , the events must be three Add clicks with no Reset between them.

Errors caused by asynchronous events

Events are asynchronous : they can arrive at any time, in any order, and sometimes while other work is still in progress.

Problem What happens Typical fix

Double submission A user clicks "Pay" twice quickly, and two orders are charged Disable the button while processing; ignore repeats with a state flag

Using data before it arrives A handler displays results before a network request finishes, showing empty or old data Update the display in the handler for the "data loaded" event

Unexpected order A "Stop" event arrives before "Start" has finished setting up Check the current state in every handler

Event during a long task The interface freezes, or events pile up Keep handlers short; move long work to a background task

Stale sensor readings A value changes between being read and being used Read once into a local variable, then use that copy

Missed or dropped events Events arrive faster than they can be handled Queue events; limit how often they are sampled

Concurrency

Concurrency means several tasks are in progress during the same period. They may be interleaved on one processor or run truly in parallel on several cores. Event handlers, timers, background downloads, and threads can all run concurrently and share data.

Race conditions

A race condition occurs when the result depends on the unpredictable timing of concurrent operations on shared data. The statement count ← count + 1 is really three steps: read count, add 1, write the result.

  • Time Task A Task B count in memory
  • 1 reads 5 5
  • 2 reads 5 5
  • 3 writes 6 6
  • 4 writes 6 6

Two increments ran, but count rose by only 1. One update was lost . Run 1,000 increments in each of two tasks, and the total may come out below 2,000, and differently each time.

Preventing concurrency errors

Mutual exclusion (locks): only one task at a time may run the code that updates shared data.

Atomic operations: use an increment that the system guarantees cannot be interrupted.

Avoid shared mutable state: give each task its own data, or pass messages instead of sharing variables.

Single-threaded event queues: many interface frameworks run all handlers one at a time on a single thread, which avoids races among handlers but makes long handlers freeze the interface.

Deadlock is another concurrency hazard: two tasks each hold a resource the other needs and wait forever. Acquiring resources in a consistent order prevents it (Section 15.2).

Classroom connection

Block-based environments make event-driven ideas concrete. Two sprites that both respond to "when green flag clicked" run concurrently . Students quickly see that the result can depend on which script runs first, which is a natural first encounter with race conditions.