Skip to topic
    ← Back to course topics

    Applications Generation — OCR A-Level Computer Science

    Applications Generation explained

    Applications Generation covers 6 specification points, including (a) The nature of applications, justifying… and (b) Utilities..

    Read the full explanation

    Open a point below for its explanation and revision guidance.

    (a) The nature of applications, justifying suitable applications for a specific purpose.

    This statement covers two skills: explaining the nature of applications and justifying which one suits a specific purpose. An application is software that helps a user carry out a particular task, such as word processing or image editing. To justify a choice, first state the purpose and its requirements, for example a school needs printed reports with tables and charts. Next match each requirement to a candidate's features: a spreadsheet handles calculations well, whereas a word processor suits plain text. Compare at least two candidates on criteria such as functionality, cost and ease of use. Finish by recommending one application and explaining why the alternatives fall short.

    (b) Utilities.

    This statement names a category of software: utilities. Utility software is system software that maintains, manages or optimises a computer, rather than meeting a user's main task directly. Common examples include anti-malware, backup software, disk defragmentation, file compression and disk formatting. To explain a utility, name it, state what it does and say what it benefits. For example, a backup utility copies files to a separate location so that data can be restored after accidental deletion or hardware failure. Utilities are often supplied with the operating system, but many are third-party products. Distinguish them from applications by focusing on their role in supporting the system.

    (c) Open source vs closed source.

    This statement asks you to compare open source and closed source software. Open source software makes its source code available so users can read, modify and redistribute it, usually under a licence such as the GNU GPL. Closed source (proprietary) software keeps its source code confidential; users receive only a compiled program under a licence that normally forbids modification. Compare the two on a named factor such as cost, control, security review or support. Open source allows independent inspection and community fixes, whereas closed source gives one vendor responsibility for updates and formal support contracts. Ground your comparison with examples such as Linux against Microsoft Windows.

    (d) Translators:Interpreters, compilers and assemblers.

    This statement asks you to distinguish three translators. A translator converts code in one language into another form, usually machine code, so the processor can run it. An assembler converts assembly language into machine code, usually one assembly instruction for one machine code instruction. A compiler translates the whole high-level program before running it, producing an executable file and reporting errors after checking. An interpreter translates and runs a high-level program one statement at a time, so it stops at the first error and creates no separate executable. Explain how translation timing and error reporting differ, using an example such as a C compiler.

    (e) Stages of compilation (lexical analysis, syntax analysis, code generation and optimisation).

    This statement covers the stages a compiler moves through when translating high-level source code into code a machine can execute. Lexical analysis reads the source characters and groups them into tokens such as keywords, identifiers, operators and literals, discarding whitespace and comments. Syntax analysis checks that the token sequence follows the grammar of the language, typically building a parse tree and reporting syntax errors. Code generation translates the checked structure into target code, such as intermediate code or machine code. Optimisation then improves the generated code, for example by removing redundant instructions, while preserving its meaning. Learn the order, because each stage uses the output of the previous one: the token stream feeds the parser, and the parse tree feeds code generation.

    (f) Linkers and loaders and use of libraries.

    This statement covers how separately compiled code becomes a runnable program. A linker combines object files and library modules into a single executable, resolving external references so that a call in one module reaches the correct routine in another, and adjusting addresses where needed. A loader is part of the operating system; it copies the executable into main memory, allocates the memory it requires and starts execution. Libraries are collections of pre-written, tested routines that programmers reuse instead of rewriting them. With static linking, library code is copied into the executable; with dynamic linking, it is joined at run time, which can save memory when several programs share one library.

    Your focus

    1. Explain the nature of an application using a correct definition and a named example.
    2. Justify the choice of a suitable application for a stated purpose by linking requirements to features.
    3. Compare two candidate applications and identify which is less suitable, giving a reason.
    Show all 18 objectives
    1. Define utility software accurately and distinguish it from application software.
    2. Identify named examples of utilities and state the function of each.
    3. Explain the benefit of a specific utility in a given scenario.
    4. Define open source and closed source software using the terms source code, licence and compiled program.
    5. Compare open source and closed source software on at least two named factors.
    6. Justify a judgement about which model suits a given situation, supported by a named example.
    7. Define a translator and identify its input and output.
    8. Distinguish between assemblers, compilers and interpreters using when translation happens and whether an executable is produced.
    9. Explain how each translator reports errors and give a suitable example.
    10. State the four stages of compilation in their correct order.
    11. Describe the input and output of lexical analysis and syntax analysis.
    12. Explain why optimisation must preserve the meaning of the translated program.
    13. Describe the roles of the linker and the loader in preparing a program to run.
    14. Explain the purpose of libraries in program development.
    15. Distinguish between static linking and dynamic linking.

    Applications Generation exam tips

    Marking Points
    • Defines an application as software designed to help a user complete a specific task.
    • Names a suitable application and states the purpose it serves in the scenario given.
    • Links each stated requirement of the purpose to a specific feature of the chosen application.
    • Compares at least two candidate applications against clear criteria such as functionality, cost, compatibility or ease of use.
    • Rejects an alternative by naming the specific requirement it fails to meet.
    • Defines utility software as system software that maintains, manages or optimises a computer.
    • Names a utility such as anti-malware, backup software, disk defragmentation or file compression.
    • Explains what a named utility does to the computer or its data.
    • Distinguishes a utility from an application by its role in supporting the system rather than the user's task.
    • Describes a realistic situation in which a named utility is needed, such as recovering data after accidental deletion.
    • Defines open source software as software whose source code is publicly available for inspection, modification and redistribution.
    • Defines closed source software as software whose source code is kept confidential and supplied only as a compiled program.
    • Explains that open source licences set the conditions under which users may modify and redistribute the code.
    • Compares the two models on at least one named factor, such as cost, control, security review or support.
    • Gives a justified evaluative point, for example that open source permits independent code review while closed source gives a single vendor responsibility for fixes.
    • Uses a specific example of each model, such as Linux or Firefox for open source and Microsoft Windows or Adobe Photoshop for closed source.
    • Defines a translator as software that converts source code into machine code or another form the computer can execute.
    • Identifies an assembler as translating assembly language into machine code, usually with one assembly instruction corresponding to one machine code instruction.
    • Explains that a compiler translates the entire high-level program before execution and produces an executable file that can be run separately.
    • Explains that an interpreter translates and executes code one statement at a time, so execution begins before the whole program is translated.
    • Contrasts the translators on error reporting, for example a compiler reports errors after checking the whole program while an interpreter stops at the first error it meets.
    • Uses a concrete example of a translator, such as a C compiler or a Python interpreter, to show where the method applies.
    • Identifies lexical analysis as the stage that converts source characters into tokens.
    • Identifies syntax analysis as the stage that checks the token sequence against the language grammar.
    • States that code generation produces target code, such as intermediate or machine code, from the checked structure.
    • Explains that optimisation improves the generated code while keeping its meaning unchanged.
    • Places the four stages in the order lexical analysis, syntax analysis, code generation and optimisation.
    • Identifies the linker as the tool that combines object files and library modules into one executable.
    • Explains that a linker resolves references between modules so that calls reach the correct routine.
    • Identifies the loader as the part of the operating system that loads the executable into main memory and starts it.
    • Describes a library as a collection of reusable, pre-written routines.
    • Distinguishes static linking, where library code is copied into the executable, from dynamic linking, where it is joined at run time.
    Examiner Tips
    • 💡Underline the purpose and its requirements in the question before choosing any application.
    • 💡Write one linking sentence per requirement, in the form: this requirement is met because the application provides this feature.
    • 💡Finish with a clear recommendation and one reason why each rejected option is less suitable.
    • 💡Give a named example, then state its function and the benefit it provides in one sentence.
    • 💡Contrast the utility with an application by stating which one supports the system and which one serves the user's task.
    • 💡Use a concrete scenario, such as a computer infected by malware or a disk that is running slowly, to show why the utility is needed.
    • 💡Define each model first using the terms source code, licence and compiled program, then move on to comparison.
    • 💡Compare the two models directly within the same sentence on a named factor so the comparison is explicit.
    • 💡Support each judgement with a named example, such as Linux or Adobe Photoshop, so the point is grounded in a real product.
    • 💡Build a comparison table with rows for when translation happens, the output produced and how errors are reported, then complete it for each translator.
    • 💡Keep the assembler point linked to instruction correspondence and machine code rather than describing it as a high-level method.
    • 💡Include a concrete example, such as a C compiler or a Python interpreter, to show how the translator is used in practice.
    • 💡Link each stage to its input and output, such as characters in and tokens out for lexical analysis, so you can recall the stage from its job.
    • 💡Remember the dependency chain: each stage relies on the previous stage's output, which helps you eliminate wrong options quickly.
    • 💡When a question offers a list of stages, check whether each description matches the stage's purpose rather than its name alone.
    • 💡Use the order of events to separate the two tools: linking happens before the program runs, and loading happens when it is started.
    • 💡Name the role of each tool precisely, for example 'resolves references' for a linker and 'allocates memory' for a loader.
    • 💡When comparing static and dynamic linking, state where the library code sits at the point it is used to make your answer specific.
    Common Mistakes
    • Lists application names without explaining what each one does for the stated purpose; describe the function that matches the need.
    • Chooses the most advanced or most popular application regardless of the scenario; select the one whose features fit the stated requirements.
    • Gives general advantages of an application with no link to the specific purpose; tie each advantage to a requirement from the scenario.
    • Treats a utility as a user application such as a word processor; state that utilities support the system rather than performing the user's main task.
    • Names a utility without stating what it achieves; add the function and its benefit to the system or data.
    • Assumes every utility comes from the operating system; note that many utilities are supplied by third-party developers.
    • Treats all free software as open source; free-of-charge software can still be closed source, so separate the cost of a program from access to its source code.
    • Claims open source software is always more secure; security depends on review practice and maintenance, so give a balanced judgement with a reason.
    • Describes closed source software as unusable by customers; it runs normally, but its code is not shared and users cannot legally change it, so state the restriction accurately.
    • Treats assemblers as high-level translators; assembly language is low-level, so the assembler's output is machine code specific to a processor.
    • Says interpreters produce a separate executable file; an interpreter runs the program without generating one, which is the key contrast with a compiler.
    • Describes compilers as running the program line by line; a compiler translates the whole program first and only then runs the resulting executable.
    • Assigns the conversion of characters into tokens to syntax analysis; correct this by stating that lexical analysis performs that task.
    • Describes optimisation as the stage that checks grammar; correct this by stating that syntax analysis checks grammar and optimisation improves efficiency.
    • Treats optimisation as changing what the program does; correct this by stating that optimisation must preserve the meaning of the code.
    • Reverses the order of the stages, placing code generation before syntax analysis; correct this by stating that the parse tree must exist before code can be generated.
    • Assigns the copying of an executable into main memory to the linker; correct this by stating that the loader performs this task.
    • Describes a library as a complete program that runs on its own; correct this by stating that a library holds reusable routines that other programs call.
    • Treats dynamic linking as copying library code into the executable at compile time; correct this by stating that dynamic linking joins the library at run time.
    • Presents the linker and loader as the same process; correct this by stating that the linker combines modules before execution and the loader prepares the program to run.