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
Building a Desktop Solution with a Database
- 10 subtopics
- 30 things to know
- A2 Unit 2
What Building a Desktop Solution with a Database covers
Building a Desktop Solution with a Database is examined in Unit A2 2, Implementing Solutions — an internally assessed portfolio. It covers applying relational techniques to a real solution, choosing the database and the development tool, Connecting the application to the database, data adaptors, data sets, data commands and parameterised queries, binding the database to the interface, multiple forms and navigation, saving changes and protecting the data and testing and documenting the built solution.
Where it is assessed
A2 Unit 2
Implementing Solutions — an internally assessed portfolio.
Check the CCEA specification ↗The 10 subtopics
Each one has its own page.
- Applying relational techniques to a real solutionDeriving the structure from the client's data rather than from the screens, enforcing keys and integrity in the database itself, the order the parts are built in, and testing the structure before the interface is built on it.Open →
- Choosing the database and the development toolDifference between a file-based and a server-based database, database driver or provider and data source in a desktop application.Open →
- Connecting the application to the databaseConnection in a database application, connection string and steps in using a connection.Open →
- Data adaptorsData adaptor and adaptor's role in a disconnected design.Open →
- Data setsThe in-memory copy that holds tables, relationships and the state of every row, why it works without a connection, what accepting and rejecting changes do, and how it differs from a forward-only reader.Open →
- Data commands and parameterised queriesData command, three ways a command's result is used and stored procedure.Open →
- Binding the database to the interfaceBinding source, grid control used for in a database application and most common fault when saving from a bound form.Open →
- Multiple forms and navigationSwitchboard or main menu form, difference between a modal and a modeless form and wrong with an application in which every form is modal.Open →
- Saving changes and protecting the dataOptimistic concurrency and pessimistic concurrency.Open →
- Testing and documenting the built solutionTesting the connection, referential integrity, concurrency and transactions, recording each test with its evidence, and what the technical and user documentation must contain.Open →
What you need to know
Answer each one before you reveal it.
Your recallNot started
Key term
What must be documented for each table in the built solution?
Key term
What integrity rule should be chosen for each relationship, and why is it a decision?
Key term
Why should the choice of tool be justified in the documentation?
Key term
What is a connection in a database application?
Key term
What does filling a data set actually do?
Key term
How does the adaptor know which rows to update when changes are sent back?
Key term
How are parameters supplied to an adaptor's select command?
Key term
Why is a parameterised statement safer than building the statement by joining strings?
Key term
How are dates and numbers handled correctly by parameters?
Key term
What is a binding source, and what does it add?
Key term
What is the most common fault when saving from a bound form?
Key term
How is a calculated value shown on a bound form?
Process
How does a form know which record to display when it is opened from another form?
Key term
Why should a save of several related tables run inside a transaction?
Key term
What must be done to protect the data before the solution is handed over?
Key term
How is the evidence of testing recorded?
Key term
What must the technical documentation record about the data access?
Key term
What must the user documentation cover for a database solution?
Key term
What is a data set?
Key term
What is the difference between a file-based and a server-based database?
Key term
Why should database credentials not be written into the source code?
Key term
Why is a data set described as a disconnected copy?
Key term
How should navigation be designed for a database application?
Key term
When is a file-based database the right choice?
Key term
Why must a connection be closed as soon as the work is done?
Key term
What states can a row in a data set be in?
Key term
What is a data command?
Key term
What is a switchboard or main menu form?
Key term
What happens when a user presses Save on a bound form?
Take Building a Desktop Solution with a Database further
The same content, four other ways.
Commonly confused
Pairs that lose marks when they are blurred together.
A modal form vs A modeless form
A modal form: a window that must be dealt with before the one behind it can be used. A modeless form: a window that leaves both itself and the one behind usable at once.
Questions from this topic
Each one with the model answer underneath.
- 1
What does it mean to apply relational database techniques to a business problem?
Model answer
It means deriving the tables from the client's own data rather than from the screens, normalising them so each fact is held once, enforcing the keys and relationships in the database itself, and then building the application on that structure.
- 2
Why is the database structure settled before any form is built?
Model answer
Forms and reports are bound to fields, so a change to the structure means rebuilding them. Settling the tables first means the interface is built once, and it stops the structure being shaped by whatever screens happened to be drawn.
- 3
In what order are the parts of a database solution built?
Model answer
The tables and their data types come first, then the keys and relationships, then the validation on each column, then the queries the interface depends on, then the forms, and last the reports.
- 4
Why should validation be enforced by the database and not only by the form?
Model answer
A rule on the form applies only to data arriving through that form. A rule on the table applies however the data arrives, including through an import, a direct statement or a second application added later.
- 5
How are the entities for a solution identified from a client's description?
Model answer
The entities are the things the client keeps records about, which usually appear as the nouns that recur in the description and on the forms and files the client already uses.
- 6
What must be documented for each table in the built solution?
Model answer
Each table needs its name and purpose, every column with its data type, size, format, validation and default, the primary key, every foreign key with the table it refers to, and any index created on it.
What is inside Levo
Six ways to work the same material.
Building a Desktop Solution with a Database revision questions
- What does Building a Desktop Solution with a Database cover in CCEA A-Level Software Systems Development?
- 10 subtopics: applying relational techniques to a real solution, choosing the database and the development tool, connecting the application to the database, data adaptors, data sets, data commands and parameterised queries, binding the database to the interface, multiple forms and navigation, saving changes and protecting the data and testing and documenting the built solution. Each one has its own page with questions and model answers.
- How is Building a Desktop Solution with a Database organised?
- By the CCEA CL4 specification, subtopic by subtopic, so it matches the order you are taught it in.
Every question in Building a Desktop Solution with a Database, 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.