Computing: Application Development

What application development means in a real software team

Difference between an application, a platform, and a service

Choosing software tools for application design

When to use wireframes vs prototypes in design

When to use diagrams vs written specifications

Representing ideas with flowcharts and what they show well

Representing ideas with pseudocode and what it shows well

Why consistent conventions matter in designs

Version control basics for collaborative development

Why documentation quality affects time and risk

Stages of a typical software development life cycle

Waterfall: stages, strengths, and weaknesses

Iterative development: what changes between iterations

Agile development: how it differs from waterfall

Choosing a development model for a project context

How models affect testing and feedback cycles

How models affect cost, deadlines, and scope control

Turning a client brief into a clear problem statement

Identifying stakeholders and end users

Gathering requirements from a client brief

Writing testable functional requirements

Writing measurable non-functional requirements

Identifying constraints (time, budget, skills, tools, policies)

Defining success criteria matching client priorities

Designing an initial development plan from requirements

Prioritising requirements (must/should/could)

Planning for iteration and change requests

Planning testing from the start (testability as a requirement)

Scoping an application: in scope vs out of scope

Defining the minimum viable product (MVP) for a brief

Identifying inputs, processes, and outputs

Identifying data requirements from the brief

Identifying user journeys the application must support

Recognising scope creep and controlling it

Making trade-offs between features, time, and quality

User interface vs user experience

Common UI components and their uses

Designing for different devices and screen sizes

Navigation structures and why they matter

Interaction methods and implications (touch, keyboard, mouse, voice)

Designing for accessibility needs (visual, motor, cognitive, hearing)

Consistency and standards in interface design

Feedback, error messages, and recovery in interfaces

Designing layouts for clarity and low cognitive load

Testing interface ideas with users (quick usability checks)

Problem-solving skills in software development roles

Breaking down a problem into smaller tasks (decomposition)

Generating and comparing solution options

Choosing tools and techniques that fit the problem

Using constraints to guide solution decisions

Communication in software development roles

Explaining technical ideas to non-technical audiences

Clear written communication in documentation

Using visuals and examples to support understanding

Planning and delivering a structured update/presentation

Collaboration in software development roles

Working effectively in a team with different roles

Giving and receiving feedback constructively

Managing disagreements and reaching decisions

Sharing progress using collaborative workflows and tools

Types of applications and how requirements differ

Choosing an application type for user needs and context

Choosing hardware/devices to match requirements

Performance: responsiveness and resource usage

Storage considerations: what needs storing and why

Selecting suitable storage approaches

Designing for offline use vs always-online use

Designing for scalability (users, data, features)

Data inputs: what is needed and where it comes from

Data validation: preventing incorrect entry

Data verification: checking entry is correct

Managing state in an application

Modelling user journeys as application flows

Using data flow thinking to reduce errors/confusion

Error handling strategies for reliability and usability

Storing and retrieving data safely

What an API is and why developers use APIs

Different ways APIs are used in development

Choosing APIs vs building from scratch

Protocols used by applications and what they do

Matching protocols to needs (security, speed, reliability)

Using APIs safely (keys, permissions, limits, reliability)

Handling API failures and degraded service

Common security risks to application software

Threats from malware and compromised devices

Threats from weak authentication and access control

Threats from insecure storage and transmission

Social engineering risks affecting software security

Security mitigations and why they work

Authentication methods and when to use them

Authorisation and least-privilege access

Encrypting data in transit and at rest

Backups and recovery planning for application data

Secure updates and patch management basics

Planning tests that match requirements

Choosing test methods (dry run, iterative testing, test plans)

Writing test cases with clear expected results

Using test data effectively (normal, boundary, invalid)

Installation considerations (setup, configuration, updates)

Operational policies affecting applications (security, usage, data)

Monitoring and maintenance after deployment

Legal considerations in application development

Data protection responsibilities for user data

Copyright, licensing, and third-party assets/code

Accessibility responsibilities and why they matter

Computer misuse risks and acceptable use expectations

Keeping evidence that legal requirements were considered

UX design vs UI design: roles and relationship

Why UX/UI matters to successful development

User experience levels and design implications (novice to expert)

Hardware constraints (input devices, screen size, device type)

Accessibility needs and impacts on design decisions

Perception in UX/UI and why it matters

Navigation design: hierarchy

Navigation design: menu selection

Navigation design: recognition vs recall

Shneiderman’s 8 Golden Rules: applying each rule

Layout: above vs below the fold

Layout: colour theory for usability and meaning

Layout: information visualisation for clarity

UI types: GUI and when it fits

UI types: menu-driven and when it fits

UI types: natural language and when it fits

UI types: touch UI and when it fits

UI types: voice UI and when it fits

Interaction types: function keys, gestures, voice, WIMP

Interface standardisation: cross-platform standards and widgets

UX/UI requirement types (client, user, solution)

Functional vs interface vs non-functional UX/UI requirements

Finding requirements from briefs and existing sources

Writing a requirements specification for UX/UI work

Use case diagrams: actors and interactions

Generating ideas: mind maps, mood boards, spider diagrams

Low-fidelity prototyping with wireframes

Paper prototyping for fast iteration and feedback

Using sketches/diagrams to develop concepts

Diagram types (flow, navigation, task flows, wireflows)

Showing interaction flows and user steps clearly

High-fidelity prototypes (mock-ups, flows, interactive)

Including navigation aids, house style, and layout in designs

Checking designs with a checklist

UI audit metrics: branding, bottlenecks, inconsistencies

UI audit checks: usability, accessibility, heuristics

Interface metrics: configuration, navigation, keystroke effort

Purpose of a UX/UI solution showcase

Choosing showcase formats (live, slideshow, video)

Choosing showcase content: type, depth, relevance

Designing a showcase: colour, language, layout, style

Adapting a showcase for the audience

Resources to deliver a showcase (hardware/software)

The 7Cs for effective communication in showcases

Reviewing fitness for purpose against requirements

Reviewing how well UX/UI principles were applied

Identifying strengths and weaknesses in UX/UI solutions

Proposing UX improvements (not implementing)

Proposing improvements using psychology and standards

Reviewing planning/design/communication effectiveness

Types of games: 2D vs 3D vs immersive vs MMO/MMORPG

Game genres and how genre affects design decisions

Defining a game concept: purpose, audience, story, USP

Making a concept engaging and marketable

Game elements: goals, aesthetics, world dimensions, theme/story

Gameplay: competition, feedback, immersion, interaction

Progression, rewards, scoring, strategy vs chance

Game mechanics: movement and navigation

Game mechanics: actions/events and controls

Game mechanics: start/end mechanisms and I/O

Collision detection and gameplay impact

Player interaction and feedback loops

Timing and scoring mechanisms supporting objectives

Game Design Documents: purpose, audience, effectiveness

Writing requirements, success criteria, concept summaries in a GDD

Planning visuals: concept art, storyboards, asset lists

Planning mechanics: decision trees, flowcharts, pseudocode

Sourcing assets from the internet and stock libraries

Preparing assets: size, crop, resolution, duration changes

Choosing file formats/properties for game assets

Naming conventions for identifiable assets

Game engine tools: assets, physics, rendering, sound

Scripting environments and libraries in game engines

Programming techniques: logic, loops, functions

Building scenes/rooms/environments in an engine

Implementing functionality (not language-specific)

Testing: dry runs, iterative testing, test plans, trace tables

Testing types: functionality, performance, play, compatibility

What to test: controls, progression, UI, scoring, feedback

Analysing test results and remedial actions

Reviewing fitness for purpose: requirements and engagement

Suggesting improvements: audio, gameplay, graphics, progression

Suggesting further development: communities and opportunities

Domain names and URL structure

Platform, browser, and device compliance

W3C compliance and WCAG accessibility guidance

Site structures: index pages and sitemaps

Web 2.0 vs Web 3.0 expectations

Website purposes and impact on content/layout/style

Website types: static vs dynamic vs CMS

Website types: responsive, single-page, interactive, multimedia

Combining website types to meet user needs

Semantic webpage components and structure

HTML5 roles in structure and meaning

CSS3 roles in layout, styling, and consistency

Client-side scripting and where it fits

Navigation components: links, hotspots, nav bars

Responsive design: fluid grids, breakpoints, relative sizing

Libraries and frameworks (HTML/CSS/JS/PHP-based)

SEO basics: crawling, indexing, keywords, metadata, ranking

Planning: purpose, audience, type, content

User requirements and navigation planning

Planning interactive components: buttons, media, rollovers

Planning assets and a consistent house style

Hosting: cost, location, security, domain choices

Documenting ideas: mind maps and mood boards

Documenting plans: site plans, diagrams, wireframes, storyboards

Producing an asset list and house style sheet

Creating a website folder structure (templates/assets/pages)

Finding index page location and linking strategy

Sourcing assets (internet/stock libraries)

Preparing assets: removal, sizing, cropping, animation

Selecting formats and properties for web performance

Asset naming conventions for maintainable sites

Using authoring tools: templates, box model, forms, publishing

Implementing W3C and accessibility compliance in a prototype

Applying SEO techniques to webpages

Using libraries/frameworks appropriately in a prototype

Testing: dry runs/trace tables, iterative, test plans

Testing types: technical, viewpoint, user testing

What to test: navigation, interactivity, readability, compatibility

Analysing outcomes and remedial actions (not implementing)

Reviewing effectiveness: accessibility, compatibility, SEO

Constraints limiting improvements (time, skills, law, tools)

Suggesting improvements: security, SEO, content, accessibility

Suggesting further developments: hosting, payments, features

AR vs VR vs MR: key differences and features

Advantages and disadvantages of AR

Advantages and disadvantages of VR

Advantages and disadvantages of MR

How sectors use immersive technologies

AR types: marker, markerless, location-based, superimposed

AR components: lenses, processing, sensing

AR interaction layers: static vs interactive

AR devices and how features affect design

VR types: non-, semi-, fully immersive

VR characteristics: world, interactivity, sensory feedback

VR interactions: tracking, controllers, audio

MR concepts and user interaction with MR solutions

MR displays: HMDs, monitor-based, optical see-through

Degrees of freedom and immersion

Field of view, FPS, latency in immersive design

Supporting tech: 3D modelling/scanning, tracking, sensors

Planning: client, user, technical requirements

Design: layout, assets, triggers, layers, interaction

Designing triggers (marker/object, markerless, geo-based)

Designing single vs multiple layers

Designing action flow and static vs interactive experiences

Planning for hardware constraints and impact

Setting prototype success criteria and content lists

Documenting ideas and designs with appropriate tools

Sourcing and selecting assets for immersion

Preparing assets and choosing formats/properties

Naming conventions for asset management

Using software features to build prototypes

Implementing degrees of freedom and interactive objects

Using lighting/effects and overlays

Testing: dry run/trace table, iterative, test plan

Testing: functionality, usability, accessibility, hardware, security

What to test: triggers, layers, tracking, immersion, battery use

Analysing results and remedial actions (not implementing)

Reviewing effectiveness: usability, immersiveness, engagement

Suggesting improvements: compatibility, security, features

Suggesting further development: repurposing and new resources

Stepwise refinement and clear problem steps

Abstraction: functional, data, and control

Decomposition and manageable components

Modularity and maintainability

OOP fundamentals for software design

Encapsulation using modules, procedures, functions, classes

Properties and methods for structuring code

Maintainability as a design goal

Language types: procedural, OOP, functional, scripting

Comparing language types: strengths and limitations

Choosing a language type for a solution

Software Design Specifications: purpose, layout, key sections

Capturing requirements in an SDS

Identifying constraints and design impacts

Software Design Documentation and why it matters

Data structure design in SDD

Data flow diagrams (Level 0 and Level 1)

Architectural design: components and interfaces

Interface design: navigation, response, help, errors

Algorithm design: input/process/storage/output

Using flowcharts and pseudocode to design algorithms

Variables vs constants and why it matters

Naming conventions: kebab case vs camel case

Data types: integer, float, string, boolean

Type conversion and why it’s needed

Operators: arithmetic, boolean, relational

Selection structures: if/else and switch/case

Fixed loops and conditional loops (pre/post condition)

Passing data between modules/procedures/functions/classes

File manipulation: open/close, read/write, manage files

Data structures: arrays, linked lists, stacks, queues

Inputs/outputs: user, file, module outputs

Searching and sorting as reusable routines

Error handling: try/exception and validation rules

Using development environments effectively

IDE tools: editor, autocomplete, syntax checking, debugger

Version control: what to record and why

Writing useful code comments (header and inline)

Indentation style and readable conventions

Testing: dry run/trace table, iterative, test plan

Testing types: requirements, component, integration, system

What to test: input, output, navigation, errors, storage

Analysing test results and remedial actions (not implementing)

Reviewing fitness for purpose against requirements

Reviewing maintainability and robustness

Proposing improvements and future developments