Licence Keywords:

Reverse Engineer: The process of analysing an existing system to identify its components and their
interrelationships, ultimately to allow the creation of a similar system

Decompile: The process of taking executable machine code and generating the equivalent higher level
language source code, so that it is easily understood by the programmer.

Disassemble: The process of translating a program from its executable form into assembler language
form

Alter: The process of editing the source/machine code to change its functionality of the software
program.

Fetch Execute Cycle:

1. Instruction is fetched from the primary memory and is stored in the instruction register (IR)
2. Program counter is incremented to the memory address of the next instruction to be executed
3. Control unit decodes the instruction to determine the nature of the instruction
4. If possible, any operands are loaded from the primary memory into registers
5. ALU (arithmetic logic unit) executes the instruction and stores the result in the accumulator, unless
otherwise specified.
6. Fetch execute cycle resets for next instruction

Translation Process:
The translation process starts off with lexical analysis. In lexical analysis, one character from the source
code is scanned at a time, and tokens are generated for each user-defined identifier (procedures,
variables) and tokens are also generated for each language element (syntax, constants, operators). These
tokens are then stored in a token table, with reference to its attributes (name, data type, memory
location).

Then, syntactical analysis occurs. In syntactic analysis, a parse tree is created with hierarchical structure
of the tokens. The machine aims to verify that the arrangement of tokens are in the correct order by
parsing with the parse tree. If parsing fails to occur, then this means that there is a syntactical error with
the arrangement of the tokens. Then, the type checker identifies data types any incompatible
operations.

Finally, code generation occurs. The parse tree is traversed in this stage, and the tokens are converted
into object code.
Static Linking & Dynamic Linking
In static linking, the compiler produces object code from its provided source code, including calls to any
external libraries or externalyl compiled subroutines. The linking process then locates the executable
code for each of those routines, and links it with the generated object code, to create one complete self
contained executable file

DLLs (known as dynamic link libraries), are common files used to replace subprograms within a program.
DLL's can be linked to a program to provide functionality of those subprograms at any time during
runtime.

OOP Keywords:
Encapsulation: Encapsulation is one of the four pillars of the object oriented paradigm. Through
encapsulation, the implementation details of programmed elements are hidden, whilst direct access to
those elements are also restricted. Encapsulation also provides a public interface to allow for classes to
interact with its instantiated objects.

Inheritance: Inheritance is one of the four pillars of the object oriented paradigm. Through inheritance,
subclasses (descendants) are able to inherit data attributes and methods from its superclass (parent).
Hence, inheritance encourages the reuse of code as each class does not need to be individually
redefined.

Abstraction: Abstraction is one of the four pillars of the object oriented paradigm. Abstraction involves
the breakdown of a complex problem into smaller, yet more manageable and simpler problems to be
solved. In the OOP context, abstraction is used by breaking down a problem into multiple objects that
interact with each other to solve the problem.

Polymorphism: Polymorphism is one of the four pillars of the object oriented paradigm. Through
polymorphism, a method is able to take many forms, allowing multiple objects to call the same method
for different purposes. To achieve this, either the internal processing of the method is changed, or the
parameters passed through are altered. This is respectively known as method overriding and method
overloading.

Methods: Methods are subroutines that are associated with a class, and are the equivalent of an
imperative function.

Property: Properties hold the characteristics and attributes that are used to define a class. They are the
equivalent of a variable.

Objects: Objects are an instance of a class, defined by its attributes and methods
Classes: A class is a blueprint containing both attributes and methods to define an object.

Instantiation: Creating an object based on a class or creating a particular instance of an object. For
example, creating a specific character within a game based on a Character class.

Inference Engine
The inference engine is the processing unit of logical programming languages. The engine would make
use of forward or backward chaining to reach a conclusion about the characteristics of a particular
scenario based on a set of established facts and rules, derived from the knowledge base.

Random Number Generation:

Random number generation is the generation of a sequence of values that cannot be reasonably
predicted better than random chance. This is usually used in applications where it is used to emulate
luck-based scenarios.
Examples: Dice roll, random number assigning to people etc..

Design Specifications:
Developer:
QA
Documentation
System Modelling
Choice of approach
Variables
Data types
Data structures
Algorithms

User:
Appropriate Messages
Appropriate Icons
Data formats
Social ethical issues
Ergonomics
Interface design

Types of errors:
Logic Errors: Logic errors occur throughout execution, and are caused when the code does not function
as intended. However, they do not cause the program to crash. Common logic errors are:
Running a loop once too many, incorrect output,
Runtime errors: Runtime errors occur throughout execution, and result in the termination/crash of a
program. They are often preceded by a logic error. Common runtime errors are:
Arithmetic overflow, accessing inappropriate memory location, division by 0

Syntax errors: Syntax errors occur throughout translation, and are caused when the code cannot be
successfully translated.

To consult for logic errors, a desk check should be done. Hence, that is why we should leave 1 submodule
to 1 task at a time, so the logic error can be easily isolated.

Copyright Vs Software Licence Agreements

Copyright laws and software licence agreements both govern the use and distribution of software.
Copyright laws are in place to safeguard the legal intellectual property rights of developers. However,
software licence agreements specify how others can use that software under these copyright
protections. Whilst copyright laws provide a broad legal framework, licences like GNU GPL, set specific
terms for usage, redistribution, and modification. However even without a licence, copyright law still
applies. Licensing allows developers to retain control while outlining the extent to what the users are
allowed to do with the software. In essence, copyright laws establish the creator's rights, while software
licences regulate how those rights are extended to users.

Anti-Piracy Techniques (NSSREB):

Non-copyable data sheets were introduced in the 1980s, and were included with the purchase of
software products. Consumers received a physical data sheet, which contained values in which the user
had to input into the software to allow for continuous use.

Hardware has unalterable embedded serial numbers. The software binds to the serial number on
startup, checks if serial number matches on every execution thereafter.

Site Licences allow software to be downloaded from network servers (larger organisations). There is a
user count restriction and make sure that limit is not surpassed to ensure validity of site licence.

A registration code is used to activate software products during the initial stage in the installation
process. Software checks validity through the internet, logs your IP and matches if info is right.

Encryption Key: Encryption effectively scrambles the data or executable code in such a way that it is
virtually impossible to make sense. Decryption key then unscrambles and allow execution. Key is
removed after successful installation.
Back to base authentication: Can be used when installing the software or it can be used each time the
software is run. Sends requests to the server to validate the user. Needs internet connection for request

Heuristics
Heuristics are principles, among several alternative courses of action, to determine the most effective
pathway in achieving some goal. Heuristics are also called “rules of thumb” which employ fuzzy logic to
determine the optimal path to take in order to reach a resolution.

This is particularly useful to determine results that are not known. For instance, virus scanning software
often use heuristics to detect viruses and malware by looking for tell-tale signs.

Benefits of regular contact between dev & client

● Get understanding of requirements
● Clarify needs (through means such as prototypes)
● Communication allows for feedback to be given
● Bugs can be addressed if the user tells them

Expert System
An expert system is able to emulate the decision-making processes used by humans. They are often
designed to solve complex problems by reasoning using a set of facts and rules rather than conventional
procedural code.

Backwards and Forwards Chaining

Backwards chaining starts off with the assumption that the given goal is true. Then, it breaks the goal
into individual subgoals that need to be proven. In this context, the goal is broken into the following
subgoals: -------------------------------------. The inference engine then scans through the knowledge base and
finds the fact ----------. This, then proves the subgoal to be true ------------------

Forward chaining involves entering a goal into the inference engine and then searching through the
knowledge base to find all possible matches that might satisfy this goal. In this context, the inference
engine scans through the knowledge base and finds the following---

Programmer Productivity
Programmer productivity relates to how efficiently a program can be developed and maintained. It is
influenced by factors such as the speed with which code can be generated, the correctness of the code,
the ease with which the code can be tested, revised and maintained.
These factors relate to features such as the simplicity of language syntax, the ability to modularise, and
features that support testing of the code.

Paradigm Definition
A paradigm is a philosophical or theoretical framework, representing a distinct approach under which
laws, theories, and generalizations are developed. In programming, it refers to a model or pattern that
shapes the way programmers think about solving problems. Examples of programming paradigms
include the imperative paradigm, functional paradigm, logic programming, and object-oriented
programming (OOP).

Outline likely reasons for failure of development throughout the cycle

- QA criteria not set correctly
- Resources for time and budget were not allocated correctly
- Lack of technical expertise
- Failure of communication with clients
- Poor specifications for programmers

Considerations for making screen designs

- Audience Identification
- Identification of screen size and data formats needed (if any data validation needed)
- Consistency

Recommending the most appropriate paradigm:

(a) (i) Describe the strengths of the logic paradigm, with reference to a specific
type of problem
The logic paradigm uses facts and rules as its basic building blocks and is able to form expert
systems which emulate complex decision making logic and therefore address problems that
cannot be solved using conventional procedural code. Furthermore, the logic paradigm is highly
adaptable, enabling new facts and rules to be integrated to form a thorough knowledge
representation system, removing the need for a complex series of if statements to emulate
decision making, improving productivity. For example, the logic paradigm could be used to make
a medical diagnosis software to diagnose medical conditions, by taking the symptoms of the
patient and using its inference power from the knowledge base to give a reasonable diagnosis.

(ii) Describe the strengths of the object-oriented paradigm, with reference to

a specific type of problem.

Logic paradigm: The logic paradigm would be the most appropriate as rules could be created on how
to…. Through this, a thorough knowledge representation system could be modelled, as facts about each
…….. Can be entered into some kind of expert system shell.

Social Networking
“Social networking is a form of communication and discussion through networks, which are typically
with friends, family, colleagues or others, and is conducted in either a physical or virtual space.”

Relative and Sequential Files

Relative:
Relative files are files that have a known structure which allows the start of individual records to be
determined. Each record within the file are of the same size so the relative positions of each record
within the file can be calculated, allowing access these respective records without reading all the
preceding data

-more efficient generally

-must have a positive integer key field
-can jump to any record in the file instantly using the key field
-can update, add or remove parts of the file no matter its position without having to rewrite the whole
file
-fields of equal sizes

Sequential:
Sequential files are files that store data in a continuous stream that must be accessed from the beginning
to the end. In order to access data at any point, all the preceding data must have been read.

-input,output, append
-readi n the order it was written

Stubs and Drivers

Stubs: In software testing, stubs are used in a top down approach, and are placeholder modules for
lower-level modules that are yet to be completed. A stub would contain placeholder code, which
performs dummy processing, and allows the higher level module to be tested without the need for the
lower level module to be written.

Drivers: Drivers are used to test lower level modules through a bottom up approach. A driver could call
upon the lower module and pass dummy data as parameters. Then the outputs of those lower level
modules could be displayed to check for correct functionality. Basically works as black-box testing

Higher vs Lower Level Languages

Check SDD CSSA 2021 Paper