References

The books behind these questions.

Every Programming practice question links back to the reference you'd use in the real exam.

CHOP

Canadian Handbook of Practice. The core RAIC reference on the programming process and how to analyze a program.

Functional Programming

A short practice primer from the Alberta Association of Architects on preparing a functional program, net and gross areas, and evaluating a program before design.

Mastering the Business of Architecture

Frames programming as a defined service inside the architect's scope of work.

What you'll be tested on

The skills behind Programming questions.

Examitect drills each of these areas. The list below maps to the question categories you'll see inside.

  • Run stakeholder interviews and user-group sessions to capture project goals
  • Document space lists, functional requirements, and adjacency relationships
  • Produce a written program document the client can review and sign off on
  • Test the program against site capacity, budget, schedule, and code constraints
  • Check net-to-gross efficiency, area totals, and program-to-budget alignment
  • Document gaps, tradeoffs, and assumptions in writing before design starts

Why this topic matters. Programming questions test process, not design talent. ExAC examiners want to see that you can structure a project before drawing it, ask the right questions of the client and user groups, and document the assumptions that schematic design will rely on. Skipping programming prep is one of the most common Section 1 mistakes.

Study Notes on Programming.

Programming on the ExAC: the two sub-categories you need to know

Examitect's ExAC study plan splits Programming into two sub-categories. Both appear on the exam in multiple choice, scenario-based, ordering, and short-answer formats. Together, they are the most-tested process topic in Section 1 (Design and analysis).

ExAC sub-categoryPrimary reference(s)Supplementary reference(s)
Understand the process involved in developing an architectural programJumpSub-category 1.1: Understand the process involved in developing an architectural program. Jump to section. Canadian Handbook of Practice (CHOP), Chapter 6.1 Functional Programming; Mastering the Business of Architecture (2004), Vol. 2, Section 2
Analyze an architectural programJumpSub-category 1.2: Analyze an architectural program. Jump to section. CHOP Chapter 2.2; CHOP Chapter 5.2; CHOP Chapter 6.1 Functional Programming; Mastering the Business of Architecture (2004), Vol. 2, Section 2

Programming sits inside the pre-design phase of a typical Canadian architecture project. CHOP describes pre-design as everything that happens after the architect is engaged but before any schematic plan is drawn: programming, site analysis, feasibility, regulatory review, and budget setting. Programming is the most-tested slice of that work because every later phase, from schematic design through construction documents, depends on the program document.

What architectural programming is, and what it produces

Architectural programming is the pre-design process of defining what a building must do before anyone designs it. You work with the client, end users, and consultants to capture goals, facts, concepts, needs, and constraints, then organize them into a written program document the client signs off on. That document drives schematic design, design development, and construction documents.

A finished program is not a design. It does not commit to a massing, a plan diagram, materials, or elevations. It commits to what the building has to do: who uses it, what they do in it, how much space each activity needs, how those activities relate, what the budget and schedule allow, and what sustainability or performance targets must be met. Treat programming questions on the ExAC as process and documentation questions, not design questions.

Key distinction

Brief, program, and functional program overlap but are used differently. The brief is the client's initial statement of intent (often a few pages). The architectural program is the detailed document the architect develops from the brief. The functional program defines the character, services, scope, functions, and space requirements in enough detail for design or approvals; the Functional Programming guide notes the term is also used for design briefs, facilities programs, and space programs.

1.1 Understand the process involved in developing an architectural program

What sub-category 1.1 tests. Sub-category 1.1 of Examitect's ExAC study plan, taken from the official ExAC exam objectives, is "Understand the process involved in developing an architectural program." The primary reference is CHOP Chapter 6.1. The supplementary references are the Functional Programming guide and Mastering the Business of Architecture (2004), Volume 2, Section 2.

Sub-category 1.1 questions check whether you know how to run the programming process: who you talk to, what you collect, in what order, what you produce, and how you hand the result off to schematic design. Expect process questions, ordering questions ("place these steps in the correct sequence"), and "what does the architect do next?" scenarios.

The Problem Seeking method: five steps

The Problem Seeking method was developed by William Pena and Steven Parshall and published in Problem Seeking: An Architectural Programming Primer. CHOP Chapter 6.1 (Predesign) lists it among its programming references, and it remains the academic backbone of architectural programming in North America. Its vocabulary is a useful frame for the process questions the ExAC asks. The method organizes the architect's work into five steps.

  1. Establish goals. Sit down with the client and user groups to define what success looks like. Goals are qualitative and aspirational: "create a welcoming front door for the school", "support flexible learning groups of 6 to 30", "achieve Net Zero carbon by 2030". Goals frame every later decision.
  2. Collect and analyze facts. Gather measurable inputs: site dimensions, zoning rules, code limits, climate data, user head counts, equipment lists, existing-building surveys, market data. Facts are objective.
  3. Uncover and test concepts. Concepts are alternative ways the program could work: open plan versus cellular, single building versus campus, ground-up versus renovation. Test concepts against goals and facts before committing.
  4. Determine needs. Translate goals, facts, and concepts into a space list with quantities (net areas), qualities (acoustic, lighting, security), and relationships (adjacencies). This is the bulk of the program document.
  5. State the problem. Distill the program into a one-page problem statement that hands off to schematic design. It names the unique conditions, the major design directions, and the constraints the design team must respect.

The four considerations: Form, Function, Economy, Time

Problem Seeking organizes every programming decision into one of four columns. The five steps and four considerations form a 5 by 4 matrix that frames the architect's work. ExAC examiners often test whether you can place a given programming input into the correct cell of that matrix.

Consideration What it covers Programming inputs
Form Site, context, environment, image, architectural expression. Site survey, neighbourhood context, zoning, views, climate, soils, heritage.
Function People, activities, and relationships. User counts, organizational structure, adjacencies, workflows, hours of use.
Economy Initial cost, life-cycle cost, operating cost. Construction budget, soft costs, contingency, FF&E, energy targets, maintenance.
Time Past, present, future. Historical context, current need, future change. Heritage constraints, current operations, growth forecasts, phasing.

Stakeholder engagement and information gathering

A program is only as reliable as the people you talked to. CHOP Chapter 6.1 calls out three groups the architect must engage during programming.

  • The client (or project sponsor). The party who signs the contract and pays the bills. The client owns the budget, the schedule, and the final sign-off on the program.
  • The user groups. The people who will occupy and operate the building. They know the activities, the workflows, and the day-to-day frustrations of the current space.
  • Subject-matter experts and consultants. Cost consultants, code consultants, mechanical and electrical engineers, accessibility consultants, sustainability consultants. They confirm what is technically and financially possible.

Typical techniques: kick-off workshops, structured user interviews, questionnaires, observation of the existing facility, precedent tours, and a series of workshop-and-review cycles to converge on the final program. Document every interview. The notes become the audit trail when a future decision is challenged.

Programming deliverables: what an architect actually produces

The output of programming is a written program document the client reviews and signs off on. CHOP Chapter 6.1 lists the contents.

DeliverableWhat it contains
Project goals and success criteriaQualitative aspirations the design must satisfy. Used at every later milestone to test design choices.
Stakeholder and user-group registerWho was consulted, when, and what they contributed. Names, roles, dates.
Space list (functional and space requirements)Every space the building must contain, with net area in square metres, occupant count, equipment, finishes, and special requirements.
Adjacency diagram or matrixHow spaces relate. Bubble diagram or a tabular matrix showing required, preferred, and prohibited adjacencies.
Site and contextual constraintsBuildable envelope, zoning setbacks, height limits, easements, heritage, neighbour issues.
Budget and cost benchmarksConstruction cost target, cost per square metre, soft-cost allowance, contingency, FF&E, escalation.
Schedule and phasingMilestone dates, occupancy date, decanting plan if applicable.
Sustainability and performance targetsLEED, Zero Carbon, WELL, energy use intensity, embodied-carbon ceiling.
Risk and assumptions logWhat was assumed, what is unknown, what could change.
Problem statementOne-page summary that hands the program off to schematic design.
How to spot a 1.1 question

The question describes a phase before drawings exist, names a stakeholder or user-group activity, asks about order or process, or asks "what does the architect do next?" Those are 1.1 territory. The right answer almost always involves consulting a stakeholder, documenting an input, or producing a piece of the program document.

1.2 Analyze an architectural program

What sub-category 1.2 tests. Sub-category 1.2 of Examitect's ExAC study plan, taken from the official ExAC exam objectives, is "Analyze an architectural program." The primary references are CHOP Chapter 2.2 (The Client), Chapter 5.2 (Stakeholder Management), and Chapter 6.1 (Predesign). The supplementary references match 1.1.

Sub-category 1.2 questions check whether you can take a draft program and stress-test it. Expect calculation questions (net to gross, cost per area), scenario questions ("the program totals 3,200 sq m net, the budget allows 4,500 sq m gross, what do you do?"), and multi-select questions about which constraints to flag.

The five constraint tests

When the program lands on your desk, work through five constraint tests in this order. CHOP Chapter 6.1 outlines the logic; Chapter 2.2 grounds it in the client's needs and expectations; Chapter 5.2 ties it to stakeholder management.

1. Budget

Multiply the gross floor area by the regional cost per square metre for that building type, add soft costs, contingency, FF&E, and escalation, and compare to the client's construction budget. RSMeans and Yardsticks for Costing give the cost-per-area benchmarks Examitect's ExAC study plan cites for Section 1, Cost management. If the program does not fit the budget, the architect documents the gap in writing and presents the client with options: cut scope, raise the budget, phase the project, or reduce specification level.

2. Site capacity

Test whether the program fits the buildable envelope after zoning setbacks, height limits, parking ratios, and amenity-space requirements. If the program is 5,000 sq m gross and the buildable envelope only supports 4,200 sq m, the architect flags it. Site analysis (Section 1, Site and Environmental Analysis) is the partner topic.

3. Code

Check occupant load, exit width, barrier-free path, fire separations, and major-occupancy classification against the National Building Code (NBC) 2020. A program that calls for 600 occupants on the third floor of a Group A Division 2 building is testable against NBC 3.4.3 (width of means of egress) before any plan is drawn.

4. Schedule

Test whether the design and construction sequence can hit the client's milestones. Long-lead items, permit cycles, and phasing constraints get checked here. CHOP Chapter 5.2 covers the stakeholder management behind the schedule conversations that happen at program sign-off.

5. Sustainability and performance targets

Confirm that the brief's targets (Net Zero carbon, LEED Gold, WELL, Toronto Green Standard, BC Energy Step Code tier) are achievable with the program as written. A program with a tight construction budget and a deep-glazed perimeter envelope may not reach the energy target without rebalancing.

Net area, gross area, and the efficiency ratio

Programming math on the ExAC almost always involves net area, gross area, and the ratio between them. Memorize the definitions and the benchmarks.

Net assignable area (NSA) = sum of usable program spaces
Gross floor area (GFA) = total enclosed area, walls to walls
Efficiency ratio = NSA / GFA
Gross-up factor = 1 / Efficiency ratio (used to size GFA from a net program)
Building typeTypical net-to-gross efficiencyGross-up factorNotes
Office65 to 75%1.33 to 1.54Open plan trends higher, cellular and high-security lower.
Educational (K to 12, post-secondary)60 to 70%1.43 to 1.67Heavy circulation and shared amenity drive efficiency down.
Healthcare (hospitals, clinics)55 to 65%1.54 to 1.82Mechanical, support, and code-driven corridor widths dominate.
Laboratory (research, teaching)50 to 60%1.67 to 2.00Shafts, headhouses, and equipment-driven services lower efficiency.
Residential (apartment)75 to 85%1.18 to 1.33Stacked units with common corridors are highly efficient.
Retail (big box)85 to 95%1.05 to 1.18Open sales floor with minimal back-of-house pushes efficiency near 1.0.
Museums and galleries55 to 65%1.54 to 1.82Storage, conservation, and circulation are large non-program loads.

Worked example: sizing a building from a net program

A client gives you a net program of 2,400 sq m for a community recreation centre with gymnasium, pool, change rooms, fitness studio, and meeting rooms. Recreation buildings sit at roughly 60 percent efficiency because of pool decks, plant rooms, and double-height volumes. Gross floor area = 2,400 / 0.60 = 4,000 sq m. At a regional construction cost of 5,000 dollars per sq m (from Yardsticks for Costing), construction cost = 4,000 x 5,000 = 20 million dollars. Add 25 percent for soft costs, FF&E, and contingency: total project budget = 25 million dollars. If the client's budget is 18 million, the program is over by 7 million. The architect documents the gap and presents options to the client in writing.

Cost-per-area sanity checks

Examitect's ExAC study plan pairs Programming with Cost management (Section 1, sub-categories 4.1 to 4.4). On Programming questions, you may be asked to apply a cost-per-area benchmark to a program area without doing a full estimate. Memorize the order of magnitude: simple warehouses around 2,000 dollars per sq m, offices around 4,000 to 5,000, schools around 4,500 to 5,500, hospitals around 7,000 to 10,000, and labs around 7,000 to 9,000 (2025 Canadian dollars, varies by region). Yardsticks for Costing is the source the study plan cites.

How to spot a 1.2 question

The question gives you a program total, a budget, a site area, a building type, an occupancy, or a sustainability target, and asks whether they fit together. Expect calculations, "which of the following constraints is binding?" multi-selects, and "what does the architect document next?" scenarios.

The Functional Programming guide (supplementary reference)

Functional Programming is a short practice primer prepared by Justin Saly, MRAIC, and edited by the Alberta Association of Architects (2010), written to supplement the programming material in the Canadian Handbook of Practice. It does not replace architectural programming; it summarizes it. The guide defines functional programming as the decision-making process that clearly defines the problem and scope of work for design, then walks through how a program is prepared, how net and gross areas work, and how to evaluate a program before design starts.

What the program describesWhat it capturesExample
Philosophy, vision, and goalsWhy the facility exists and what the client wants it to achieve."Provide accessible recreation for the residents of the regional municipality."
Services and deliveryThe services the new facility provides and how they will be delivered or operated."Aquatics programs run seven days a week alongside drop-in fitness."
Activities, workload, and peopleActivity volumes, throughput, staffing, and the major equipment that drive space needs."Peak load of 250 visitors with 12 staff on shift."
Space relationships and requirementsRelationships between spaces or groups of spaces, then detailed space requirements."25-metre, 6-lane pool with barrier-free change rooms directly adjacent."

The guide adds that a functional program may also determine the overall implementation schedule, preliminary budgets, the project delivery method, and site evaluation. On the ExAC, remember what a functional program must do: define the character, services, scope, functions, and space requirements in sufficient detail for subsequent design or approvals.

Programming as a service offering (Mastering the Business of Architecture)

Mastering the Business of Architecture, Volume 2, Section 2 treats programming as a defined service the architect bills for. RAIC Document 6 (the standard form of contract for architectural services) lists programming as an additional service rather than a basic service. Basic services are schematic design, design development, construction documents, bidding, and contract administration. Programming sits before basic services and needs its own scope, fee, and sign-off in the contract.

ScenarioWhat the architect should do
Client hands you a finished program written by someone else.Review the program for completeness and feasibility. Document gaps. Confirm in writing that you are working from this program before starting schematic design.
Client wants you to write the program.Add programming to the contract as an additional service with its own scope and fee. Define deliverables and a sign-off milestone before starting.
Client wants you to start schematic design without a signed program.Decline. Confirm the program with the client in writing first. Starting design without a signed program is a leading cause of scope creep and fee disputes.
Program changes after sign-off.Document the change as an additional service. Issue a change in services with revised scope and fee.

How each reference fits the two Programming sub-categories

Examitect's ExAC study plan pairs specific chapters with each sub-category. Read in the order below.

ReferenceScopeSub-category
CHOP Chapter 6.1, PredesignThe core process: stakeholders, program document contents, deliverables, sign-off.1.1 and 1.2
CHOP Chapter 2.2, The ClientUnderstanding the client: who they are, what they need, and the expectations the program must satisfy.1.2
CHOP Chapter 5.2, Stakeholder ManagementIdentifying and managing stakeholders: who has an interest in the project and how their input shapes the program.1.2
Functional Programming (Alberta Association of Architects)Practice primer: how a functional program is prepared, net and gross areas, grossing factors, program evaluation.1.1 and 1.2
Mastering the Business of Architecture, Vol. 2, Sec. 2Programming as a billable service. Fee, scope, sign-off, additional services.1.1 and 1.2

Key Programming terms (glossary)

Architectural program
The written document an architect develops that defines what a building must do. Lists goals, facts, concepts, needs, and a problem statement. CHOP Chapter 6.1.
Brief (project brief)
The client's initial statement of intent. The architect develops the brief into the architectural program. Often a few pages versus a full program document.
Functional program
The decision-making document that defines the problem and scope of work for design: character, services, scope, functions, and space requirements. Also referred to as a design brief, facilities program, or space program.
Pre-design
The umbrella term for everything before schematic design: programming, site analysis, feasibility, regulatory review, budget setting.
Problem Seeking method
The five-step programming framework by Pena and Parshall. Steps: establish goals, collect and analyze facts, uncover and test concepts, determine needs, state the problem.
Form, Function, Economy, Time
The four considerations Problem Seeking uses to organize programming inputs. Each programming input belongs in one of these four columns.
Goals
Qualitative aspirations the design must satisfy. The first information category collected.
Facts
Measurable, objective inputs. Site dimensions, code limits, user counts, climate data.
Concepts
Alternative programmatic strategies, tested before they are committed to. Not design concepts.
Needs
Translation of goals, facts, and concepts into space lists with quantities, qualities, and relationships.
Problem statement
The one-page summary that hands programming off to schematic design.
Net assignable area (NSA, net area)
The floor area listed in the program as usable. Offices, classrooms, exam rooms, sales floor.
Gross floor area (GFA)
The total enclosed area of a building, walls to walls. Includes circulation, washrooms, mechanical, structure, and walls.
Efficiency ratio (net to gross)
NSA divided by GFA. Expressed as a percentage. Driven by building type.
Gross-up factor
1 divided by the efficiency ratio. Multiplied by net area to estimate gross area when sizing a building.
Adjacency matrix
A tabular tool showing required, preferred, and prohibited adjacencies between program spaces.
Bubble diagram
A graphic tool showing program spaces and their relationships. Used in late programming and early schematic design.
Stakeholder
Any party with an interest in the project: client, end users, neighbours, authorities having jurisdiction, regulators, funders.
User group
The end users who will occupy and operate the building. Consulted directly during programming.
Performance objective
A measurable target the space must meet. Acoustic separation in decibels, lighting in lux, indoor air quality, daylight factor.
Mission statement
A statement of why the building or organization exists. A functional program opens by describing the client's philosophy, vision, and goals.
Basic services
The architect's core scope of services under RAIC Document 6: schematic design, design development, construction documents, bidding, contract administration.
Additional services
Services outside the basic-services scope, including programming, feasibility studies, post-occupancy evaluation, and renderings. Need their own scope and fee.
Feasibility study
A pre-design study testing whether a project is achievable on a given site at a given budget. Often precedes programming.
Post-occupancy evaluation (POE)
The structured review of a finished building against the original program. Feeds learnings back into future programming.

How Programming questions are asked on the ExAC

Programming questions show up in every Section 1 sitting in multiple formats. Recognizing the format is half the work.

Question formatTypical 1.1 wordingTypical 1.2 wording
Multiple choice (single answer)"Which of the following is the FIRST step in the programming process?""A net program of 2,000 sq m for an office building yields a gross floor area closest to:"
Multi-select (choose all that apply)"Which of the following are deliverables of the programming phase?""Which constraints would you flag for a program that is over budget by 15 percent?"
Ordering"Place these programming activities in the correct sequence."(rare in 1.2)
Scenario-based"A client signs the brief but refuses to meet with user groups. What does the architect do next?""The program totals 4,500 sq m gross. The buildable envelope supports 3,800 sq m. What is the architect's first step?"
Calculation(rare in 1.1)"Calculate the gross floor area required for a net program of 2,400 sq m at 60 percent efficiency."
Definition"What is a problem statement in the programming context?""Define net-to-gross efficiency ratio."
Short answer (paid)"Describe the programming process you would follow for a small library.""List three constraints you would test a draft program against, and the source of each benchmark."

Common ExAC traps in Programming questions

Five trap patterns show up regularly. Recognize them in the options before you pick.

  1. Distractors that jump to schematic design. Options that pick a massing strategy, a plan diagram, or a structural grid before the program is set are wrong. Programming questions stay in the consultative, list-driven, document-producing world.
  2. Net versus gross confusion. The question gives you one and asks for the other. Always read carefully which is which. Watch for clues: "useable", "assignable", "program total" mean net; "footprint", "enclosed", "permit area" mean gross.
  3. Missing the consultative answer pattern. Options that say "verify with the user group", "document the assumption", "review with the client", or "confirm with the consultant" usually win in 1.1 questions. The architect's job in programming is consultative, not unilateral.
  4. Basic services versus additional services. Programming is an additional service under RAIC Document 6. Options that assume programming is automatically included in basic services are wrong.
  5. Brief versus program versus functional program. The terms overlap in practice, but the exam expects you to know how each is used. Use the glossary above to keep them straight.

Tips for Intern Architects studying Programming

  • Read CHOP 6.1 first, all the way through. It is the single most important reference for both sub-categories. Read it once at speed, then re-read while tabbing the process sequence, the deliverables list, and the stakeholder roles.
  • Memorize the 5 by 4 matrix. Five steps across the top, four considerations down the side. Practise placing example inputs into the right cell.
  • Learn three efficiency benchmarks by heart. Office (65 to 75%), school (60 to 70%), and lab (50 to 60%) cover the most common calculation questions. The rest you can interpolate.
  • Practise the calculation in both directions. Net to gross, and gross to net. The ExAC tests both.
  • Read the Functional Programming guide once. It is only five pages, and it is the fastest way to lock in the net and gross area definitions, grossing factors, and program-evaluation questions.
  • Skim Mastering the Business of Architecture, Vol. 2, Sec. 2. Programming as a billable service is short but tested.
  • Practise scenario questions out loud. Programming questions reward articulating the next step, not picking a design.
  • Tab CHOP Chapter 2.2 and 5.2. They surface in 1.2 questions less often than 6.1, but when they do, you want the tabs.

How to study Programming in 8 to 12 hours

  1. Hour 1 to 3: Read CHOP Chapter 6.1 in full. Take notes on the process, the deliverables list, and the stakeholder roles, then map them to the five steps and four considerations from Problem Seeking.
  2. Hour 4: Read CHOP Chapter 2.2 and Chapter 5.2. Focus on the client relationship and the stakeholder management that program analysis depends on.
  3. Hour 5 to 6: Read the Functional Programming guide. Learn how a functional program is prepared, the net and gross area definitions, and the program-evaluation questions.
  4. Hour 7: Read Mastering the Business of Architecture, Vol. 2, Sec. 2. Focus on programming as an additional service.
  5. Hour 8 to 10: Drill Examitect Programming practice questions for both 1.1 and 1.2. Time yourself on calculations.
  6. Hour 11 to 12: Review trap patterns, the glossary, and any practice questions you missed. Revisit the efficiency table.
One-line summary

Programming is the pre-design phase where you turn a client's brief into a signed-off program document. CHOP Chapter 6.1 is the core; Chapters 2.2 and 5.2 cover the client and stakeholder management; Functional Programming covers preparing, sizing, and evaluating the program; Mastering the Business of Architecture frames it as a billable additional service. Sub-category 1.1 tests process; sub-category 1.2 tests analysis. Both reward consultative, documentation-driven answers.

Estimated study time. Most candidates spend 8 to 12 hours on Programming. Adjust up if you don't see programming work in your day job, down if you've drafted programs on live projects.

FAQ

Programming FAQ

Programming is the pre-design phase where you define what the building has to do, who it serves, and what constraints it operates under. The output is a written program document that lists project goals, space needs with areas and adjacencies, budget, schedule, and assumptions. Every later phase of the project pulls from it. CHOP Chapter 6.1 is the primary Canadian reference.

Examitect's ExAC study plan splits Programming into two sub-categories: 1.1 Understand the process involved in developing an architectural program, and 1.2 Analyze an architectural program. Sub-category 1.1 tests process knowledge (CHOP 6.1 is the primary reference). Sub-category 1.2 tests analysis and calculation (CHOP 2.2, 5.2, and 6.1).

Pre-design is the umbrella term for everything that happens before drawing starts: programming, site analysis, feasibility, and zoning review all live there. Programming is one piece of pre-design. Schematic design starts when the program is signed off, and you can begin testing massing, plan diagrams, and elevations against it.

The brief is the client's initial statement of intent, often a few pages. The architectural program is the detailed document the architect develops from the brief, with goals, facts, concepts, needs, and a problem statement. The functional program defines the character, services, scope, functions, and space requirements in enough detail for design or approvals; the Functional Programming guide notes the term is also used for design briefs, facilities programs, and space programs.

The Problem Seeking method, developed by William Pena and Steven Parshall, has five steps: establish goals, collect and analyze facts, uncover and test concepts, determine needs, and state the problem. CHOP Chapter 6.1 (Predesign) lists Problem Seeking among its programming references, and the five-step vocabulary is a useful frame for ExAC process questions.

The four considerations are Form, Function, Economy, and Time. Form covers site and context. Function covers people and activities. Economy covers initial and life-cycle cost. Time covers past, present, and future (heritage, current use, growth). Combined with the five steps, they form a 5 by 4 matrix that organizes every programming input.

CHOP Chapter 6.1 (Predesign) is the primary reference for the programming process. Chapters 2.2 (The Client) and 5.2 (Stakeholder Management) cover the client relationship and stakeholder engagement that program analysis depends on. The Functional Programming guide covers how a functional program is prepared, net and gross areas, and how to evaluate a program. Mastering the Business of Architecture Volume 2, Section 2 frames programming as a billable service. All three appear in Examitect's ExAC study plan for Programming.

Net-to-gross efficiency is the net assignable floor area divided by the gross floor area. It tells you how much of the building footprint is usable space versus circulation, walls, washrooms, and mechanical. Examiners use the ratio to test whether you can sanity-check a program against a gross floor area target. Office buildings sit at roughly 65 to 75 percent, schools at 60 to 70 percent, hospitals at 55 to 65 percent, and laboratories at 50 to 60 percent. Residential apartments are highest at 75 to 85 percent.

Divide the net assignable area by the efficiency ratio for the building type. For example, a 2,400 sq m net program for a recreation centre at 60 percent efficiency gives a gross floor area of 4,000 sq m (2,400 / 0.60). Multiply by the regional cost per square metre to estimate the construction budget. Yardsticks for Costing and RSMeans are the cost-per-area sources Examitect's ExAC study plan cites.

Programming is an additional service under RAIC Document 6, not a basic service. Basic services are schematic design, design development, construction documents, bidding, and contract administration. If the client wants the architect to write the program, the contract must include programming as an additional service with its own scope, fee, and sign-off. This appears in Mastering the Business of Architecture, Vol. 2, Sec. 2.

The architect documents the gap in writing and presents the client with options: cut program scope (reduce areas or eliminate spaces), raise the construction budget, phase the project, reduce specification or finish quality, or extend the schedule to allow value-engineering. The architect does not silently absorb the gap or proceed to schematic design hoping the budget will work out. This is a sub-category 1.2 scenario and the right answer is almost always to document and present options.

Plan for 8 to 12 hours: 3 hours on CHOP 6.1, 1 hour on CHOP 2.2 and 5.2, 2 hours on the Functional Programming guide, 1 hour on Mastering the Business of Architecture Vol. 2 Sec. 2, and 3 to 5 hours on Examitect practice questions for both sub-categories. Adjust up if you do not see programming work in your day job, down if you have drafted programs on live projects.