Avery’s Gym wants to automate a simple but commonly used feature:
When a gym member attempts to register for a class, the system must check whether space is available. If the class is full, the system must send a rejection message. If space is available, the system must enroll the member and send a confirmation.
Avery provides this logical description for you to begin the program design:
Member requests registration for a specific class.
System retrieves the class’s maximum capacity and current enrollment count.
If space remains, the system adds the member to the class roster and returns a confirmation message.
If the class is full, the system returns a message indicating that registration cannot be completed.
You may add reasonable assumptions as needed, but explain any modifications you make.
Assignment Instructions
Part 1: Structured English or Pseudocode
Rewrite the scenario above in structured English or pseudocode.
Your version should demonstrate:
Clear sequence
Selection (decision logic)
Modularity (group related steps or create named blocks)
Explicit inputs and outputs were appropriate
Your goal is to turn a high-level logical description into something a programmer or automated tool could interpret reliably.
Part 2: Structure Chart
Using your pseudocode as the basis, create a structure chart in Microsoft Visio that represents the program’s module hierarchy.
Your diagram must include:
A top-level control module
At least two subordinate modules
At least one data couple
At least one control couple
Appropriate fan-in or fan-out relationships
Correct notation for module connections
Part 3: Program Specification
Write a program specification (10–14 sentences) describing:
The purpose of the program
The purpose of each module
Required inputs and expected outputs
Processing is performed within each module
Error or exception handling considerations
Assumptions the programmer must know before implementing the logic (for example, expected data formats or validation rules that are not yet finalized)
DevOps Operational Requirements (IaC):
Because modern systems must run reliably in automated deployment environments, add a short subsection (2–3 sentences) that identifies the explicit DevOps-related operational requirements needed for this program.
Your answer should reflect the principles from this unit’s DevOps readings, including the role of Infrastructure as Code (IaC) in creating consistent, testable environments.
In this subsection:
Identify at least two environments or deployment requirements that must be encoded in IaC (for example, required database connections, API endpoints, resource allocation limits, logging or monitoring configurations, or security-related parameters).
Clearly distinguish between requirements (which must be implemented in the IaC scripts) and assumptions (details that must be confirmed later with the DevOps or operations team).
Your goal is to create a document that clearly communicates what developers must build.
Part 4: DevOps, AI, and Automated Checks (Reflection)
Based on your design from Parts 1–3, list three specific checks you would want to run automatically in a build or deployment pipeline for this module.
At least one check should validate that the module’s core logic behaves correctly (for example, correct handling of a key decision or edge case).
At least one check should relate to safety or reliability (for example, input validation, prevention of invalid data, or a basic performance expectation).
The third check can be any other automated verification you consider important (for example, ensuring required configuration values are present before deployment).
These automated checks become part of a continuous integration (CI) pipeline.
Then write a short reflection paragraph (5–7 sentences) that:
Explains how clear program design (logical vs. physical DFDs, structure charts, and specifications) helps DevOps teams build reliable automated pipelines.
Describes how ambiguity in your pseudocode or specification could cause problems for either an automated pipeline or an AI assistant that is helping generate or review code.
Connect at least one idea from the IaC reading (such as consistent environments, idempotent scripts, or avoiding infrastructure drift) to your design work in this assignment.
This programming assignment asks you to design a class-registration capacity check for Avery’s Gym — structured English (pseudocode) and program logic that checks capacity, enrolls or rejects, and returns the right message. The skill is translating the logical description into clear, correct program design.
Key takeaways
- Model the process: get capacity and enrollment, compare, enroll or reject.
- Write structured English/pseudocode with clear conditional logic.
- Handle both branches: space available (confirm) and full (reject).
- State any reasonable assumptions you add.
- Consider edge cases (exactly at capacity, concurrent requests).
Define inputs and logic
Inputs: the member, the requested class, the class’s maximum capacity, and current enrollment count. Core rule: if current enrollment < capacity, enroll and confirm; otherwise reject.
Structured English / pseudocode
Write it clearly, for example:
GET maxCapacity, currentEnrollment for requestedClass
IF currentEnrollment < maxCapacity THEN
ADD member to class roster
currentEnrollment = currentEnrollment + 1
RETURN "Confirmation: you are enrolled"
ELSE
RETURN "Registration failed: class is full"
ENDIF
Assumptions and edge cases
State assumptions you add (e.g., the member isn’t already enrolled; capacity is a positive integer). Note edge cases — exactly at capacity should reject, and concurrent registrations need a check to avoid overbooking.
Format
Follow the assignment’s structured-English and design requirements, and explain any modifications you make.
The post Class Registration Capacity Check appeared first on Writeden.