Key term
CCEA A-Level Software Systems Development CL4
Software and the Development Environment
Topic overviewSystems software and application softwareThe operating system and file managementSource code filesBinary, object and executable filesCompilers, interpreters and the build processXML files and structured dataUtility software and managing files on diskThe integrated development environmentObject oriented development platformsOpen source software and licensing
Defining Data: Types, Variables and Classes
Topic overviewPrimitive types and their storageReference types, objects and nullDeclaring variables, scope and lifetimeType casting and conversionArithmetic operators and expressionsRelational and logical operatorsOperator precedence and evaluation orderObjects as occurrences of a classAbstract, base and inherited classesAttributes and the properties of a classStatic variables in a classInterfaces and class reusability
Program Control Structures
Topic overviewSequence and the order of executionMethods and passing control between themSelection with IF and IF ELSENested IF and multi-way selectionThe switch statementCount-controlled repetition with FORConditional repetition with WHILE and DO WHILENested loops and tracing iterationsBreaking out of loops and avoiding infinite loopsChoosing and evaluating control structures
Objects, Classes and Data Structures
Topic overviewConstructors and creating objectsMethods, parameters and return valuesEncapsulation and access modifiersGetters, setters and validating an object's stateInheritance and the base classOverriding methods and run-time polymorphismOverloading methodsChoosing and organising data structuresStrings and string handlingStatic arrays of simple typesArrays of objects
Exception Handling and Managing Input and Output
Topic overviewWhy errors have to be trappedTypes of error and how an exception is raisedThe try and catch blockCatching more than one kind of exceptionThe finally block and releasing resourcesThrowing exceptions and writing an exception classChecked and unchecked exceptionsReading and validating input from the command lineControlling screen outputText filesBinary filesObject files and serialisation
Testing an Object Oriented Application
Topic overviewWhy an object oriented application must be testedChoosing test data: normal, boundary and erroneousWriting a test plan for a classTesting a class method by methodTesting constructors and object stateTesting inheritance and overridden methodsTesting error handling pathsDry runs and trace tablesTest harnesses, drivers and stubsRecording and interpreting test resultsEvaluating a test plan and re-testing
Graphical User Interface Objects and Events
Topic overviewGraphical user interfaces and console programsForms and their common propertiesLabels, text boxes and text areasButtons, check boxes and radio buttonsLists, combo boxes and other selection controlsProperties, methods and events of a GUI objectContainers, panels and laying out a formThe event loop and the event queueEvent handlers and registering a listenerThe event object and reading it inside a handlerButton, mouse and keyboard triggers
Multiple Forms and Linking to Files
Topic overviewWhy an application needs more than one formCreating, showing, hiding and closing a formModal and modeless formsPassing data between formsMenus, menu items and shortcutsToolbars and navigation buttonsDesigning navigation for a multi form applicationReading and writing text filesBinary files and streamsObject serialisation and object filesChoosing between text, binary and object files
Designing, Testing and Evaluating an Event Driven Application
Topic overviewStoryboards and what they showBuilding a storyboard from user requirementsPrototyping and refining a designError trapping in an event driven applicationUsing try and catch inside an event handlerValidating what a user types into a controlDesigning a test strategy for an event driven applicationTest plans and choosing test dataTesting the paths a user takes through an interfaceDocumenting and interpreting test resultsEvaluating an application against its requirementsEvaluating features, functionality and usability
Reasons for Systems Development and Systems Methodologies
Topic overviewWhy organisations initiate systems developmentAnalysis and design principles for business solutionsRoles in development and the place of the userThe purpose of a methodology and how methodologies evolvedThe waterfall modelIterative, incremental and spiral developmentRapid application developmentThe dynamic systems development methodScrumExtreme programmingPrototyping in the development processUML modelling and simple diagrams
Managing Projects
Topic overviewThe purpose of project managementProject management concepts and the project life cycleRoles and responsibilities in project managementResources needed to develop a projectEstimating effort, duration and costGantt charts and the scheduleMilestones and checkpointsNetwork diagrams and PERTFinding the critical pathFloat and how it is usedMonitoring and controlling progressManaging risk and change
Testing Strategies
Topic overviewWhy testing matters throughout the development cycleTesting at the design stageProgram and unit testingIntegration testingSystem testingWhite box testingBlack box testingNormal, boundary and erroneous test dataUser acceptance, alpha and beta testingThe personnel involved in testingWhat a test plan containsBuilding a test plan for a scenario
Database Concepts and Entity Relationship Modelling
Topic overviewWhat a database is and why one is usedDatabase terminology: fields, records and keysThe relational modelThe hierarchical modelThe network modelEntities and attributes in an ER modelRelationships and their degreeBuilding an ER model for a problemFrom ER model to a working designComparing the three database models
Normalisation and Structured Query Language
Topic overviewWhy data is normalisedUn-normalised data and repeating groupsFirst normal formSecond normal formThird normal formWorking a full normalisation throughThe advantages and limits of normalisationThe principles of SQLSQL commands for defining and changing dataSQL statements for retrieving dataJoining tables and grouping results
Project Management and the Systems Approach in Practice
Topic overviewBreaking a development into tasks and deliverablesEstimating durations, effort and dependenciesDocumenting the plan as a Gantt chartWorking out the critical path and floatMilestones, reviews and user sign-off pointsPlanning people, resources and skillsBuilding a plan capable of reflecting changeRecording progress against the planUpdating the plan to reflect slippageRecording change requests and versions of the planEvaluating different approaches to a business problemSelecting and justifying a specific approach
Defining Requirements and Documenting the Design
Topic overviewEliciting requirements from the userWriting functional requirementsWriting non-functional requirementsSpecifying the software and hardware the solution needsProducing and agreeing the user requirements specificationDesigning the data model and the tablesDesigning the inputs, the screens and the navigationDesigning the outputs and the reportsDocumenting the processes and the logic of the solutionTesting the design against the desired user outcomesPresenting the design and the solution using appropriate media
Building a Desktop Solution with a Database
Topic overviewApplying relational techniques to a real solutionChoosing the database and the development toolConnecting the application to the databaseData adaptorsData setsData commands and parameterised queriesBinding the database to the interfaceMultiple forms and navigationSaving changes and protecting the dataTesting and documenting the built solution
Testing and Evaluating the Solution
Topic overviewPlanning the testing of the finished solutionChoosing test data: normal, boundary and erroneousTesting validation and error handlingTesting the database and its queriesTesting the user interface and the navigationTesting the whole solution and testing with the userDocumenting test outcomes as evidenceDiagnosing failures and retestingEvaluating the test proceduresEvaluating the solution against the user requirementsEvaluating delivery against the project planEvaluating your own performance on the development
Designing, Testing and Evaluating an Event Driven Application
- 12 subtopics
- 36 things to know
- AS Unit 2
What Designing, Testing and Evaluating an Event Driven Application covers
Designing, Testing and Evaluating an Event Driven Application is examined in Unit AS 2, Event Driven Programming — an internally assessed portfolio. It covers storyboards and what they show, building a storyboard from user requirements, prototyping and refining a design, error trapping in an event driven application, using try and catch inside an event handler, validating what a user types into a control, designing a test strategy for an event driven application, test plans and choosing test data, testing the paths a user takes through an interface, documenting and interpreting test results, evaluating an application against its requirements and evaluating features, functionality and usability.
Where it is assessed
AS Unit 2
Event Driven Programming — an internally assessed portfolio.
Check the CCEA specification ↗The 12 subtopics
Each one has its own page.
- Storyboards and what they showStoryboard in the design of an event driven application, four things a storyboard frame should illustrate and low fidelity storyboard.Open →
- Building a storyboard from user requirementsUser requirement, functional requirement and traceability between requirements and a storyboard.Open →
- Prototyping and refining a designThrowaway prototype, evolutionary prototype and horizontal prototype.Open →
- Error trapping in an event driven applicationError trapping, difference between a syntax error and a run time error and logic error.Open →
- Using try and catch inside an event handlerCatching a failure raised by what the user typed, reporting it in a message box rather than to a console, closing anything the handler opened, and the state the form is left in.Open →
- Validating what a user types into a controlPresence check, range check and type check.Open →
- Designing a test strategy for an event driven applicationTest strategy, test that follows one complete user journey called and regression testing.Open →
- Test plans and choosing test dataBoundary test data, invalid or erroneous test data and extreme data.Open →
- Testing the paths a user takes through an interfacePath through an interface, happy path test and tested by clicking a button twice in quick succession.Open →
- Documenting and interpreting test resultsRecording the actual result beside the expected one with evidence, annotating it with the test number, what a failed test must record, and re-running after the change.Open →
- Evaluating an application against its requirementsDifference between testing and evaluating and end user's role in evaluation.Open →
- Evaluating features, functionality and usabilityFeatures of an application, functionality of an application and four criteria used to judge the usability of an interface.Open →
What you need to know
Answer each one before you reveal it.
Your recallNot started
Key term
How is keyboard navigation tested?
Key term
Where does the idea of a storyboard come from?
Key term
What is a user requirement?
Key term
What is a throwaway prototype?
Key term
What is error trapping?
Key term
What does a try block contain?
Key term
What is verification, and how does it differ from validation?
Key term
What is a test strategy?
Key term
What is evidence in the context of testing? Give two forms it can take.
Evaluation
What does it mean to evaluate an application?
Key term
What is meant by the features of an application?
Key term
How does a storyboard help a developer talk to a client?
Key term
How is a user requirement turned into part of a storyboard?
Key term
What is an evolutionary prototype?
Key term
Why is error trapping especially important in an application driven by a user interface?
Key term
What does a catch block do?
Key term
What is a presence check?
Process
Why is an event driven application harder to test than a program that runs one fixed sequence?
Key term
Why does a test plan record the expected result before the test is run?
Key term
What is a path through an interface?
Key term
Why is a screen capture better evidence than a written note of what appeared?
Key term
What is the difference between testing and evaluating?
Key term
What is meant by the functionality of an application?
Key term
What is a low fidelity storyboard?
Key term
What is a functional requirement?
Evaluation
Give one advantage and one disadvantage of prototyping.
Key term
What does it mean to trap an error from an object perspective?
Key term
What is a finally block for?
Key term
What is a range check?
Key term
Why should the code behind a button be written as a separate method?
Key term
Which three categories of test data should be tried on every control of a form?
Key term
Why can an interface not be tested by trying every possible path?
Key term
What does it mean to interpret a test result?
Key term
How is an evaluation against requirements organised?
Key term
Name four criteria used to judge the usability of an interface.
Take Designing, Testing and Evaluating an Event Driven Application further
The same content, four other ways.
Commonly confused
Pairs that lose marks when they are blurred together.
Storyboard vs Prototype
Storyboard: a sketch of the screens and the journey drawn before anything is built. Prototype: a working piece of software people can click.
Invalid data vs Extreme data
Invalid data: a value of the wrong kind, which must be refused. Extreme data: a valid value at the very edge of the accepted range.
Questions from this topic
Each one with the model answer underneath.
- 1
What is a storyboard in the design of an event driven application?
Model answer
A storyboard is a sequence of sketched screens showing what the user sees at each step and how one screen leads to the next.
- 2
Where does the idea of a storyboard come from?
Model answer
A storyboard comes from film and animation, where a sequence of drawn frames plans the shots before anything is filmed.
- 3
Name four things a storyboard frame should illustrate.
Model answer
A storyboard frame should illustrate the layout of the controls, the wording on them, what the user does next, and which screen that leads to.
- 4
Why is a storyboard produced before any code is written?
Model answer
Changing a sketch costs minutes while changing built forms costs hours, so faults in the layout and the flow are found while they are still cheap.
- 5
How does a storyboard help a developer talk to a client?
Model answer
A client who cannot read code looks at a sketched screen and says what is missing, so agreement is reached before the work is done.
- 6
What is a low fidelity storyboard?
Model answer
A low fidelity storyboard is a rough sketch of boxes and captions rather than finished graphics, and the roughness invites criticism of the design.
What is inside Levo
Six ways to work the same material.
Designing, Testing and Evaluating an Event Driven Application revision questions
- What does Designing, Testing and Evaluating an Event Driven Application cover in CCEA A-Level Software Systems Development?
- 12 subtopics: storyboards and what they show, building a storyboard from user requirements, prototyping and refining a design, error trapping in an event driven application, using try and catch inside an event handler, validating what a user types into a control, designing a test strategy for an event driven application, test plans and choosing test data, testing the paths a user takes through an interface, documenting and interpreting test results, evaluating an application against its requirements and evaluating features, functionality and usability. Each one has its own page with questions and model answers.
- How is Designing, Testing and Evaluating an Event Driven Application organised?
- By the CCEA CL4 specification, subtopic by subtopic, so it matches the order you are taught it in.
Every question in Designing, Testing and Evaluating an Event Driven Application, on a schedule.
Attempt a question from memory, write the correct version, then attempt it again. Levo records the jump between your first attempt and your last, and brings each question back on the day you are due to forget it.
Or £46 a year, about £3.83 a month. Cancel anytime.