Component 1

Question 1

Data Structures

Answer 1

Characteristics of a linked list:
- Dynamic data structure as it can grow and shrink in size after declaration.
- Each element is known as a node, the first element is the head node.
- Each node consisted of the data itself and the address to the next node.
- The last node references null.
- Uses more memory than an array as it needs to store the address of the next node in addition to the data.
- A node cannot be directly accessed and each node needs to be traversed until the correct node is accessed (sequential access).

In-order:
- In-order traversal is applied by visiting the left subtree first, then root and finally the right subtree. This method could be when searching for a file in the file system.
- Search a binary tree, traversing alphabetically in sorted order.

Post-order:
- Post-order traversal is applied by visiting the left subtree first, then right subtree and finally the root. This method could be used to delete all files in the file system.

Pre-order:
- Pre-order traversal is applied by visiting the root first, then left subtree and finally the right subtree. This method could be used to create a copy files in the file system.

Queue:
- A queue uses the first in first out (FIFO) principle. In a queue the most recent item of data added to a queue is the last to be removed.
- Data is added (enqueuing) at the rear end of the structure.
- Data is accessed and removed (dequeuing) from the front of the structure which is suitable for storing a sequential playlist.

Stack data structure:
- It is a limited access data structure - elements can be added and removed from the stack only at the top
- A stack can be used as a recursive data structure.
- A stack is either empty or it consists of a top and the rest which is a stack
- Underflow occurs when an attempt is made to pop an empty stack
- overflow occurs when an attempt is made to add to a full stack
- A stack uses the last in first out (LIFO) principle.
- In a stack the most recent item of data added to the stack is removed first.
- Adding data to a stack is known as pushing, whilst removing data from a stack is known as popping.

Ordered vs Unordered list:
- When searching an ordered list the search can be terminated when an item greater than or less than the search value is reached
- When searching an unordered list the search cannot be terminated until the last item has been reached.
- For an ordered list a binary search can be used.

Question 2

Logical Operators

Answer 2

• No Memorization
• Drawing Dates
• Truth tables
• Simplifying Expressions
• Bitwise manipulation (Masks) (AND, OR, XOR)

Question 3

Algorithms and Programs

Answer 3

Use of print() here

Quick sort, Binary Search,

Characteristics of a recursive sorting algorithms
- A recursive algorithm calls itself using a parameter and has a stopping condition
- example is a quick sort algorithm
- allowed for simpler design and for the original complex problem of sorting an array to be solved in a shorter time span than a non-recursive sorting algorithm.
- The algorithm is very compact
- The algorithm uses a divide and conquer design where the main problem is recursively broken into sub problems.
- The solutions of the sub problems are then combined to produce a solution for the original problem.

Advantages of non-recursive algorithms
- useful when a data structure is fixed in size like an array.
- can reduce time complexity in sorting algorithms if implemented efficiently.
- require less memory than recursive solutions reducing the demand on resources.
- Non-recursive solutions are easier to write.

Self-Documenting Identifiers
- allows code to be followed and understood more easily.
- reduces the need for additional documentation to be produces such as additional annotation or software manuals.
- An example of a self-document identifier would be using an appropriate variable name such as:
int VAT = 20’.
float f = 23.0
String s = “Hello World”

Program Layout
- allows blocks of code and constructs to be followed and identified more easily.
- A consistent program layout allows developers to maintain quality and standard of software.
- An example could be correctly using indentation to identify the start and end of constructs such as:
IF statements
Loop / nested loop structures
String s = “Hello World”

Annotation
- allows developers to record the development process and logic within the actual code.
- This is important as many developers could be working on the one project and each developer needs to understand the logic between each others code.
- An example of annotation would be to demonstrate logic such as:
‘X DIV 2 //calculate if X is even/odd’
/* Person Class @return String name */

Validation
- process of checking if the data entered is sensible in the context in which it is being used.
- reduces the possibility of entering invalid data into a system.
- An example of a validation is a range check on dates.

Verification
- checking to see if the data being entered is consistent.
- reduces the chance of incorrect data being entered into a system.
- An example of a verification is duplicate entries of data.

Shortest Path
- Purpose is to find the shortest path between two vertices on a graph.
- Each path between adjacent vertices is weighted with a cost.
- These weightings are used to calculate the total costs of different paths between two vertices.
- The path with the smallest cost is the shortest path.
- A shortest path algorithm will analyse a weighted network to identify the shortest route between two given vertices or nodes

Code Optimisation
- high-level general programming constructs are replaced by codes.
- The replacement codes are very efficient low-level programming codes.
- The objectives of code optimization are to:
Achieve the required output of the program.
Increase the speed of the program
Decrease demand on resources.
Not delay the overall compilation process.

Selection Construction
- use a logical condition to determine which line of code is to be processed next.
- If the condition is true then action 1 will be carried out. If the condition is false then action 2 will be carried out.

Nesting
- when one selection statement is contained by another selection construct.
- If a logical condition is true, action 1 is carried out and then a second selection condition will govern whether action 3 or action 4 should be executed next.

Hash Tables
- stores data in an associative array and uses a hash technique to generate an index where details of items are to be inserted into the table.
- The index is a numeric value calculated from the item’s key value.
- The hash table provides direct access to the stock item via its index and therefore performance is not affected by the number of items stored.

Iteration
- repeating a set of instructions a set number of times or until a logical condition is satisfied
- Iterative solutions tend to be:
- Easier to program
- Easier to understand and maintain.
- Functions that just iterate make no demands on stack space (a block of memory used to store temporary data), and may be more efficient where memory is limited.
- Each time a recursive function is called, certain values are placed onto the stack - this takes time and uses memory and if not terminated could use all stack space causing the program to crash.

Value Parameter (ByVal)
- Value parameter is used in a calculation within a subprogram when you want to retain the original values

Parameter passing by reference and by value
- by reference is where a value (address) is passed via a parameter into a subroutine and the original value is passed and used by that subroutine.
-This is used if any changes made in the subroutine needs to be stored in the original variable outside the subroutine.
- by value is where a value is passed via a parameter into a subroutine and a copy of the value is created for the duration of the subroutine call.
-This ensures that the original value passed to the subroutine cannot be changed.

Question 4

Principles of Programming

Answer 4

Programming Paradigm
- different approaches in programming languages that are needed to solve different problems more effectively.

Procedural Programming Paradigm
- follows a top down approach (breaking bigger problems into lots of little sub problems)
- Allows programmer to define precisely each step when performing a task
- Allows close control over the underlying operation of hardware
- Examples include Pascal and C
- solve a problem in a linear fashion through a sequence of step-by-step instructions
- involve the use of selection, iteration and callable procedures.
- more suited to problems that require a linear algorithm solution.
- Algorithms can be broken down in to smaller parts.
- Programs are divided into functions
- These are named reusable pieces of code that can be called any number of times within an algorithm to perform a specific task.
- Procedures are used to avoid the duplication of code.
- Procedures are used to make an algorithm more efficient and secure.
- Each procedure can be individually tested
- They obey ordered instructions
- Used in large complicated programs where similar operations may be carried out at varying stages of the program execution

Object Orientated Porgramming Paradigm
- divided into objects, classes and methods
- use inheritance to reduce code duplication
- Allows data to be encapsulated making data more secure
- Easier to expand programs
- multiple developers can work on one project without affecting others code.
- Examples are C++ and Java
- Improved productivity when developing software due to the flexible and extendable nature.
- Software is easier to maintain as OOP is modular and reusable.
- Development is faster due the reusable code and libraries.
- Development is cheaper.
- Software can be tested more easily making it more high quality.
- Software is easier to design as it models the real world.
- OOP is difficult and not as logical to some developers and so it is complex to create applications in.
- Software can become larger due to more code than procedural programs.
- OOP programs can run slower than PP as there is more code to execute.
- OOP cannot be used for all types of software application such as machine learning and AI.
- OOP can be difficult to debug.
- A class is a template for a specific object. It defines an object’s properties and methods. An object is an instance of a class.
- A method is a programmed subroutine that is included in an object of a class. A method can only access data within its own object, this is known as encapsulation.
- Abstraction
- Encapsulation
- Polymorphism
- Object Hierarchy

Functional Programming Programming Paradigm
- Functional programming uses a series of function definitions which are evaluated as mathematical expressions to solve a problem
- Functional programming is a declarative language which works by programmers coding what problem they want to solve rather than how they are going to solve a specific problem
- Functional programming is used in research and testing
- An example of a functional programming language is Haskell or SQL

Logic Programming Paradigm
- Logic programming is used to solve programming problems used specific knowledge base
- Logic programming takes a problem or question and will produce a solution based on this knowledge base
- Logic programming is used in expert systems, machine learning and artificial intelligence
- An example of a logic programming language is PROLOG or mercury

event-driven paradigms
- Event-driven programming is used to solve problems that require heavy user interaction through a graphical interface. Listeners are attached to objects i.e. buttons, which in turn will execute a subroutine based on the type of event triggered i.e. a single click.
- Event-driven programming language are more suited to problems that require rapid application development and a graphical user interface

Need for standardisation of computer languages
- When new hardware or software is developed it needs to ensure it is compatible with existing hardware and software
- Products developed by different companies need to meet standards to ensure compatibility across platforms.
- There must be interoperability (exchange and make use of information) between new products and with existing products to exchange and use data
- Using standards ensures products can work as part of larger system or network
- Examples of standardised computer languages are HTML5, CSS3 and JavaScript which are maintained by W3C (World Wide Web Consortium)

Difficulties involved in agreeing these standards
- All standards must be very detailed to ensure consistency in their implementation which has high costs in terms of time and money
- companies and businesses will only agree to standards when they are in their best interests
- Many companies have different targets and goals, and this can cause difficulties when agreeing on unified standards (need to meet requirements)
- Standards need to be broad enough to ensure they meet the demands of a wide range of complex problems but specific enough that they are implemented correctly

High level and low level languages
- High level languages are closer to the semantics of spoken language.
- Each line of high level language translates in to multiple lines of machine code.
- Low level languages such as assembly language uses mnemonics.
- Each line of low level language is translated into one machine code instruction.
- Identifiers can be long and meaningful
- They allow use of more powerful commands that perform quite complex tasks
- Allows the creation of modules that can be re-used and accessed by other parts of the program.

Use of low level language
- Device drivers - low level language must be used to directly access memory addresses to fully control hardware.
- Embedded software – software that runs on simple devices using simple microprocessors such as washing machines and microwaves will need direct access to the hardware
- Real-time software – simulators or fly-by-wire systems that require precise processing, timings or accuracy could potential benefit from using a low-level language.
- Assembly language can produce more compact code which can be important when placing on a chip.

Uses of different paradigms
- Object orientated programming could be use the development of a large distributed software application that requires a large team of developers.
- Event driven programming could be use the development of a graphical user interface software application.
- Logic programming could be use the development of artificial intelligence software.
- Functional programming could be use the development of software applications requiring complex mathematical transformations.
- Procedural programming could be use the development of command line interface software applications.

Inheritance
- Inheritance enables new objects to take on the properties of existing objects.
- A superclass is used as the basis for inheritance. A class that inherits from a superclass is called a subclass.
- Inheritance defines relationships between classes and organises classes into groups.
- Inheritance enables classes that are similar to existing classes to be created by indicating differences (rather that starting again) and thereby allows code to be organised and re-used effectively

Non-Procedural languages
- Non-procedural programming languages allow programmers to specify the results they want without specifying how to solve the problem
- Non-procedural languages are to do with rules / making queries / facts
- Used in database interrogation where retrieving answers are more important than the exact steps required to calculate the result
- Artificial intelligence, grammar checking and language translation applications are often written in a non-procedural language

Standardisation of computer languages
- Standardisation allows changes and enhancements to be
incorporated in a controlled manner. Programming languages are subject to continuous development resulting in multiple versions that are often not fully compatible with each other. Standardisation aims to avoid these incompatibilities and provide advantages in design and programming such as;

Portability of programs. There is a high possibility that
applications written for a particular hardware platform may be used on different platforms if the applications were developed in a standardised language because compilers/interpreters for standardised languages exist for diverse hardware platforms.

Portability of programmers. A programming language is an
interface between the programmer and the computing system or a hardware platform. If the different platforms support a standard programming interface, then the skills of the programmer is portable across these platforms.

Easier to maintain the software. Most software requires
continuous maintenance and enhancements after the original release. Most of the time, different programmers work on such maintenance tasks. A standardised language ensures that there will be sufficient skilled programmers available to carry out maintenance tasks.

Acceptability. Most business organisations would not
consider using a programming language that is not
standardised. A non-standardised language is a big risk for
business-critical software development.

Faster development. Standardisation promotes standard
ways of working and therefore speeds up team working in
development.

Standard library. In addition to the particular programming
language, a common set of library functions for that language
may be standardised, to support “generic programming”. This
provides a language abstraction a level above the language
itself, promoting re-use and faster programming. Libraries have been written by experts and thoroughly tested.

Standard algorithms, reference to binary search, quick sorts
etc. and benefits arising in design time and accuracy.

Question 5

System Analysis

Answer 5

User documentation
- Straight forward and targeted specially for the end user
- must contain instructions on how to undertake any task
- must not contain technical information and should be user friendly
- should be an accompanying manual for after the end user has undertaken appropriate training
- Tutorials and step by step instructions on how to perform tasks
- Referencing manual and glossary
- Trouble shooting guide, common errors and problems
- frequently asked questions

Maintenance documentation
- technical documentation aimed at the person who manages and configure the software or system
- This could include IT technicians who understands all aspects of the system including the software and hardware used
- Pseudocode and annotated listings
- Diagrams such as UML
- Data structure documents
- Algorithm designs including flowcharts
- variable lists
- data dictionaries
- design documents
- installation and configuration instructions and support
- Hardware and software requirements

Waterfall
- Developers draft the design of a system up front and it does not change.
- once the analysis and design stages are complete, developers cannot go back to a to make any changes.
- If the analysis or design of the project are inaccurate or incorrect in any way, the project will fail due to the rigidness of the waterfall methodology.
- Requires less communication between the client and the developer.
- Client input is only required during analysis and at times the design stage.
- Sequential process

Agile
- Incremental approach to development
- Developers start with a simple project design and requirements.
- Iterative approach as analysis and design relies on each other.
- Analysis informs design and the design informs further analysis to be undertaken.
- Changes can be made after each phase of development, analysis can be revisited, and designs changed.
- Strong communication between the client and the developer should be regular
- Clients are involved during all stages of development.

Documents produced during analysis
- Questionnaires, These should be undertaken by a variety of stakeholders to support the analysis of the existing system. These questionnaires should measure the effectiveness of the current systems from the viewpoints of various stakeholders.
- Observations, Formal observations should be undertaken by the analysis team. These observers should monitor the interactions stakeholders have of the current systems, making relevant notes.
- Requirements After the analysis has been completed a formal set of requirements should be produced for any proposed changes of an existing system or implementation of a new system.

Documents produced during maintenance
- Annotated code listings To ensure effective maintenance of the source code for any developer. A complete list of the annotated source code is required to resolve issues or extend the system.
- Algorithm designs A complete collection of all algorithm designs in pseudocode or flow chart format should be required. These can aide a future developer in following the logic of a program for maintenance purposes.
- Data dictionaries A data dictionary is a document that contains the structures of all databases, data types and the relationship between them. This is useful for maintaining, debugging and extending the data within the system
- Variable list
- Data dictionary
- Class diagram
- List of sub routines
- Entity Relationship Diagram

Factors considered when proposing a new system
- The factors that need to be considered when proposing a new system solution include cost, time scale and budget.
- A proposed system should be cost effective, in terms of human resources, finances, technology and time.
- A proposed system needs to be effective in terms of human resource costs. The proposed system must not over or under utilise developers. When developing a new system, each developer should be allocated roles and development activities.
- These activities should be overseen by a lead developer to ensure that human resources are being fully utilised and cost effective.
- A proposed project should be financially cost effective. Developers should research and source the most financially cost-effective methods/resources/technologies when proposing a new system.
- Technologies sources including hardware and software should be cost effective.
- The system should have a specific time scale for development from inception to evaluation.
- The proposed system should follow a suitable development methodology with appropriate and realistic deadlines.
- These deadlines should follow a suitable plan to ensure an effective time scale for the project.
- The system needs to have a controlled budget. This budget should be managed accordingly to ensure the success and economic viability of the project.

Methods of changeover
- When implementing a new solution there are various methods of changeover that can be employed including direct, pilot, phased and parallel.
- Direct changeover is the simplest but most risky method of changeover. This method should only be employed where there is not an existing system already in place.
- New systems always come with a variety of problems including bug and compatibility issues and directly changing to a new system could have a significant impact on business and productivity if these issues occur.
- Pilot changeover is usually employed when a business has the required amount of resources to effectively test a new system by deploying it into one area for example, a new stock management system in one of a company’s many warehouses.
- This method allows bugs and other issues to be confined to just one area and when fixed the system can be rolled out on a much larger scale.
- Phased changeover is used when a system can be deployed in units or modules. This works well when parts of a new system are being developed independently and upgrading an existing system.
- When each module is implemented into an existing system many compatibility issues can occur between the new systems modules and the existing system.
- Parallel changeover is used when there can be opportunity for a system to fail. Phased changeover implements a new system alongside an existing system and if one fails the other takes over.
- System tasks are run concurrently on both the new system and the existing causing a duplication of tasks. These tasks can be used to ensure consistency between the new and existing systems.
- Parallel changeover is employed for critical systems such as those in hospitals and banks where data access and integrity is critical.

Testing
- Alpha testing is conducted in-house by developers and occurs before the customer agrees to accept the final program.
- Alpha builds are not shared with either the end user or with the customer.
- Alpha builds are not final piece of software and often include limited functionality and many bugs.
- Beta testing is conducted after alpha testing and later on in the software development life cycle.
- Beta builds are shared with a limited number of end users to beta test the system with live data.
- Beta builds contain all the main functionality but will still include some bugs.
- Bugs reported by the beta testers are corrected by the development team.
- Acceptance testing occurs is the final phase of testing during the software development life cycle.
- Acceptance testing is undertaken by the actual end users of the system with real data.
- The purpose of acceptance testing is to ensure the system has met the original requirements and specifications of the customer.

Feasibility
- Technical practicality
- Cost effectiveness
- Time scale
- Budget
- To provide information required to support a decision to proceed.

Fact finding techniques
- Observation of a sample of operators as they use the current system.
- Document inspection, including business documents, user manuals and maintenance records.

Stages in program productions
Analysis, descriptions of;
- Abstraction / reduce problem to essential features
- Decomposition / top down approach
- DFD’s / illustration of data flows
Design of,
- Data structures / data types / variables and constants
- Algorithms / pseudo code / flowcharts of processes
- Sub routines
- HCI / inputs / outputs.
- Test data - typical, extreme and erroneous.
- Prototyping
Implementation; consideration of
- Type and level of language and IDE
- Translation method and writing / de-bugging of code
Documentation
- Description of an ongoing process
- User instructions, maintenance manuals Testing, when and by whom
- Alpha
- Beta

Maintenence stages
- Perfective maintenance – to improve a system in use, Making improvements that are not major enough to justify a new system.
- Adaptive maintenance – to change a system in use. Making changes to suit revised working requirements / OS versions / new hardware

Types of languages
- Procedural languages are suitable for both the Agile and Waterfall approach
- Scripting Languages are suitable for both the Agile and Waterfall approach
- Non-Procedural languages would be suitable for the Waterfall approach but some might not work as well with the Agile approach
- Non-procedural programming languages require programmers to specify rules and facts which is more suitable for Waterfall
- Object Orientated languages are suitable for both the Agile and Waterfall approach
- Visual languages would be more suitable for Agile
- 4th Generation languages are suitable for both the Agile and Waterfall approach

Question 6

System Design

Answer 6

Criteria used to evaluate computer based solutions
Requirements - evaluate the solution against the original requirements. All requirements should be met for a solution to be successful
Cost - evaluate the solution against costs which include financial costs, human costs and resource costs. A solution must not exceed any negotiated costs to be successful
Robustness - evaluate the solutions against its test results. A solution should use error trapping and validation methods to be successfully robust and reduce the chance of system errors and failures
- Usability - evaluate the solution against the ease of user for the end user. A solution should use an intuitive user interface suitable for the end user to be successful
- Performance - evaluate the performance of the solution, it should be fully optimised to reduce memory usage. A solution should complete specific task within a given time frame to be successful
- Functionality – the system must produce correct results for a given set of inputs.

Natural language interface
- A natural language interface is where speech and linguistics is used
- to interact and control a software application.
- One potential use for a natural language interface would be in translation software. Natural language could be processed in real time to allow for a seamless translation service.
- Colloquialisms and words can be interpreted differently regionally.
- Accents could make is difficult for a natural language interface to identify the words being spoken.
- Ambiguity in spoken language where a word may have more than one interpretation.
- Background noise could cause problems.
- Illness such as sore throat
- Two words that sound the same (two, to) homonyms
- Dialect / accents
- Use of proper nouns
- Words from other languages in common use
- Voice patterns

Human computer interface / interactions
- A natural user interface uses relies on intuitive actions related to natural, everyday human behaviour.
- Touch screens, where uses touch or tap graphic icons.
- Gesture recognition systems which track and translate user movements into instructions.
- Speech recognition systems that identify spoken words and phrases and convert them into instructions.
- An immersive interface places one or more of the user’s sense into a computer generated virtual environment.
- Virtual reality headsets or HMDs (head mounted displays) which receive video from a computer, possibly with head tracking (up and down movement).
- Binaural or 3D earphones to filter out natural sound and replace with a chosen selected audio.
- Force feedback and touch controls provide sensation of using hands within a virtual environment.

Natural language in high level language
- Ambiguity is an uncertainty of meaning in which different interpretations are possible.
- High level programming languages must be unambiguous so that there is only one way to interpret each program statement
- and therefore enable accurate translation into machine code.

Voice input interface
- Speech is a very natural way to interact, and it is not necessary to use a keyboard or work with a remote control
- No training required for users
- Voice is hands-free making it suitable for use in a variety of environments e.g. driving
- Suitable for the disabled (qualified)
- Can be used to drive several apps in a sequence e.g. Find John Smith and give me directions to him.
- Faster than typing on a keyboard (must be qualified not just faster).
- Even the best speech recognition systems sometimes make errors e.g. homophones
- If there is noise or some other sound in the room (e.g. the television or a kettle boiling), the number of errors will increase
- Regional accents can affect the outcome
- Requires data connection to interpret speech and return results
- Delivering sensitive information e.g. credit card details could be a security risk.
- Only understands certain foreign languages

Touch Screens
- No need for another pointing device such as a stylus
- Can pinch and expand to scale images/text
- Screen can be used for input as well as output so device can be small
- Intuitive, so easy for beginners to learn to use
- Limits number of peripherals needed

Design review
- Checking the/validation correspondence between the actual design and its specification / user requirements / objectives / safety issues
- Confirming that the most appropriate techniques have been used
- Confirming the HCI is appropriate for the application

Types of interface
GUI
- GUI system is usually easy to learn for a novice user
- GUI system is usually more intuitive to use e.g. icons relevant to the application
- may be similar to other packages with which users are familiar
- can show images/videos etc to promote the clothing / make it appeal to customers
- can have an on-screen / soft keyboard
Touch screen
- generally more robust than e.g. mouse or keyboard
- easy to use with little comp knowledge/customer may be familiar with touch screen
- can be designed to replicate common mobile phones / tablets (swiping etc)
- takes up less space the keyboard and mouse
- will be attractive to customers
- can have an on-screen / soft keyboard [not twice]
Forms dialogue
- customers can choose items from a list
- may have in-built validation
Text-based
- time consuming
- not attractive to most customers / not likely to have images
- not easy to learn or use in a crowded environment
Speech recognition interface
- not easy to use in a crowded environment - probably too much background noise
- may be ineffective until computer “learns” customer’s speech style: impractical
- may have problems with different accents / different voices, homophones etc
Voice synthesis
- not suitable in noisy environment (particularly if several computers nearby)
Handwriting recognition
- text input may not be appropriate for this application
- not very reliable
- may not be easy to use in a crowded shop
Mouse
- not easy for complete novice users
- easily damaged [not twice]
- could be stolen
Hardware Keyboard
- text input not appropriate for this application
- easily damaged [not twice]
- quite large [but not if used as a benefit of e.g. touchscreen elsewhere in answer]

Forms Dialogue
- Cursor may move automatically to next input field
- Intuitive to fill in - echoes familiar paper form / good for surveys etc
- Allows change to be made while screen still visible
- May include validation – only some entries allowed

Touch pad
- A touchpad can more easily be fitted into a small device like a laptop computer or PDA / does not require extended flat space to move the mouse over / allows multiple gestures, hand swipes

Question 7

Software Engineering

Answer 7

Software for Analysis and Planning
- Used in producing of designs
- Planning a system through flow charts or UML software
- Allow developers to produce planning and design documents for cases such as the end user or developers
- used in requirements engineering and management. Used to record and monitor requirements, use and test cases.
- Example of CASE tool is Rational Rose

Software for Software development
- IDEs are software used in development
- provide wide range of tools including debugging such as automatic error checking and break points
- allow developers to produce test cases for their software as they develop (write code and debug it after while running a process).
- used to support multiple developers in the development of a single project.

Software used for system design
- Designing a system structure can be completed using flow chart or UML software
- UX and UI designers use wireframing and mock-up tools for user interfaces and experience
- collaborative code editors could be used to produce pseudocode for review by developers
- examples includes rational rose

Software used for system testing
- Control software to test that a solution conforms to internal and external standards
- Test environments can be used to test the portability of software on different platforms such as Linux and windows
- Version control repository can be used to report, monitor and analyse code errors, defects and bugs.
-Built-in automated testing features within IDEs such as breakpoints, to generate unit and system performance testing.

Difference between translation and execution errors
Translation errors - usually identified by a compiler where the instructions given cannot be translated to machine code due to errors:
Syntax error - e.g. IF without ENDIF or punctuation error or spelling error
Linking error - e.g. calling a function where the correct library has not been linked to the program
Semantic error - e.g. variable declared illegally (start with number, have space or contain special characters)
Execution/Runtime errors - even though a program will compile and execute, it could unexpectedly crash or produce incorrect results.
Logical error - e.g. division by 0 or use of incorrect logical/comparative operator
File handling - e.g. When an attempt is made to write to a file that does not exist

Program version management in software engineering
- used to track and save source code throughout the software development process
- Program version management tools are commonly integrated into IDEs such as visual studio
- examples of program version management tools include GitHub and Mercurial.
- version management tools create different versions of source code to track changes and development
- versions can be stored on a local machine which is known as local version control
- versions can be stored on a local server which is known as centralised version control
- each version can include comments on what has been developed in that particular version and how
- can be used to roll-back to a previous version if a program becomes corrupt or a bug is found during the development process
- allows code to be reviewed and checked before they committed to a master version
- Cloud-based repositors can be used to provide distributed version control (GitHub or Bit Bucker)
- cloud-based version control will ensure developers always have access to the most up-to-date versions of the source code.
- Distributed version control useful when a software development team are working on different aspects of a single project
- version control is essential in maintaining quality control and assurance in software development
- version control is essential for tracking bugs and issues in source code.
- used as a repository for different stages of code development
- useful when multiple developers are working on a single project, it ensures that a developer does not overwrite someone else’s code.

Compilers, interpreters and assemblers
- Translators are pieces of software used to convert one type of programming languages to another.
- Compilers coverts high-level programming language source code into object and machine code, run through a single executable file.
- The compilation process can throw multiple errors which at times can make debugging more difficult.
- Once software is compiled it does not need to go through recompilation unless changes are made to the original source code.
- One executable file produced by compilation can be executed many times.
- Many languages such as C++ and VB.Net produce a single executable targeted to one platform or operating system i.e. an EXE file for a Windows platform.
- If a program needs to be run on a different platform is will need to be recompiled and targeted at the required platform. i.e. Mach-O file for Mac OS.
- However, some programming languages such as Java are executed within its own virtual machine and can be compiled into byte code and executed cross-platform within an installed Java Virtual Machine (JVM).
- Once an application is compiled it is difficult to review the source code making intellectual property easier to protect.
- Unlike compilers, interpreters covert high-level programming language source code line-by-line.
- An interpreter translates a single line of code into machine code then executes it before moving onto the next.
- An interpreted application does not produce an executable file, meaning source code must be interrupted each time the application is run.
- To execute interpreted source code there needs to be a relevant interpreter installed on the running platform.
- The same high-level source could can be interpreted on many different platforms, making the application highly portable.
- Interpreted code could potentially be easier to debug as it will throw an exception at the current line being translated.
- Interrupted applications need the source code to run, making intellectual property harder to protect.
- an example of an interpreted language is python
- An assembler is used to translate low-level assembly language mnemonics into machine code to directly program the CPU.
- Each assembly language instruction has a one-to one relationship with a machine code instruction unlike high-level languages where one instruction it translated into multiple machine code instructions.
- This means that assembly is faster than compiling and interrupting and allows greater control over memory usage.
- Directly writing code in binary machine code would be prone to errors and can be highly time consuming hence we use assembly language and assemblers.

Code editor tool in IDE
- Auto completion or code completion, Suggests or completes the function being typed including variables and arguments
- Bracket matching, Useful when coding in a language that uses blocks of code contained within brackets, for detecting missing brackets.
- Syntax checks, Recognises and highlights errors in syntax during code input.
- Formatting e.g. indentation or colour coding of variables

Purpose of code translation
- Converting the source code written by the programmer into machine code / executable code.

Compiling vs Interpreting
Advantage of using a language that requires compiling compared with a language that
requires interpreting are:
- Once compiled the program will run quickly
- the object code will be efficient because the compiler will translate directly to the native code of the specific machine /optimise the code for the target hardware.
- Protection of intellectual property
Two advantages for a program developer of using a language that requires
interpreting compared with language that requires compiling are:
- Debugging can be easier as interpreter will stop translation at the point where the error occurred and highlight the error for the programmer to deal with.
- Code is more portable as it is not machine dependent and will run on different hardware or in a browser (java script)
- For security when downloading code from the Internet so it can be checked before interpreting on the local machine.

Assembler
- The purpose of an assembler is to translate assembly language into machine (executable) code
- An assembler’s source code is low level code, compliers translate high level source code.
- An assembly instruction which will translate to one machine code instruction, whereas single lines of high level code compile to many machine code instructions.

Stepping, Breaking and Variable watch
Stepping. Execution of code one line at a time. Allows the programmer to examine each line of code in isolation to check that it is behaving as intended.
Break points. A special marker that pauses execution of code at a present position. Whilst paused the programmer inspects the test environment (registers, memory, files etc) to check that the program is functioning correctly.
Variable watch. Used to view values in global and local variables as the code is executed in debug mode. Can be set to continually inspect variables which will be updated as the code is stepped through.

Question 8

Program Construction

Question 9

Economic, Moral, Legal, Ethical and Cultural Issues

Answer 9

Code of conduct
- professional standards required by the Institute as a condition of membership.
- includes standards for professional competence and integrity

Code of professional competence
- Only undertake work or provide a service that is within your competence.
- do not claim any level of competence as an ICT Technician that you do not possess.
- Develop your professional knowledge, skills and competence on a continuing basis, maintaining awareness of technological developments, procedures, and standards that are relevant to school ICT systems
- Ensure that you have the knowledge and understanding of Legislation and that you comply with such Legislation, in carrying out your professional responsibilities.

Code of integrity
- Respect and value alternative viewpoints and, seek, accept and offer honest criticisms of work by teachers and management
- Avoid injuring others, their property, reputation, or employment by false or malicious or negligent action or inaction.
- Reject and will not make any offer of bribery or unethical inducement in relation to exams or courseworkg
- Confidentiality, respect confidentiality of pupils, exams, and staff

General Data Protection Regulation 2018
- A set of rules to protect the privacy of all European Union citizens.
- GDPR is to simplify the data, privacy and consent legislation across the EU.
- All private data must be collected lawfully and with consent.
- All data collected and stored must be protected from misuse and exploitation.
- The types of data considered personal under the existing legislation include name, address, and photos.
- GDPR extends the definition of personal data so that something like an IP address can be personal data.
- It also includes sensitive personal data such as genetic data, and biometric data which could be processed to uniquely identify an individual.
- Under the GDPR it is a legal requirement that data breaches such has hacking are reported to the relevant authorities within 72 hours and the consumer has a right to know when a breach occurs.
- Businesses also need to make it easier for consumers to access their data and be very clear on how their data is being processed and used.
- GDPR also acknowledges the right to be forgotten where by a business should delete data held on a consumer if they have no grounds to retain it.
- Parental consent is required for the processing of data of under 16-year olds.
- Data processors can be directly liable for the security of personal data.

Data Protection Act 1998
- Personal data shall be processed fairly and lawfully.
- Personal data shall be obtained only for one or more specified and lawful purposes, and shall not be further processed in any manner incompatible with that purpose or those purposes.
- Personal data shall be adequate, relevant and not excessive in relation to the purpose or purposes for which they are processed.
- Personal data shall be accurate and, where necessary, kept up to date.
- Personal data processed for any purpose or purposes shall not be kept for longer than is necessary for that purpose or those purposes.
- Personal data shall be processed in accordance with the rights of data subjects under this DPA.
- Appropriate technical and organisational measures shall be taken against unauthorised or unlawful processing of personal data and against accidental loss or destruction of, or damage to, personal data.
- Personal data shall not be transferred to a country or territory outside the EU unless that country or territory ensures an adequate level of protection for the rights and freedoms of data subjects in relation to the processing of personal data.

The Regulation of Investigatory Powers Act 2000 and the Investigatory Powers Act 2016
- Internet and communications companies such as internet service providers and mobile telecommunications providers retain customer browsing history for up to one year. This data can be accessed by a range of public bodies including British security services and the police, upon issue of a warrant.
- Allows the GCHQ, MI6 and MI5 to collect bulk personal datasets including NHS Health Records. When information is bulk collected, it will not only contain information on persons of interest but will also contain information on innocent members of the public.
- Allows the GCHQ, MI6 and MI5 to carry out equipment interference also known as ‘hacking’ personal digital devices upon issue of a warrant. These devices include personal computers and mobile phones. If there is encryption on the devices the service provider will have to comply in bypassing the device security to access any personal data.

Human Rights Act 1998 Article 8
- Right to a private and family life.