Fundamentals of Algorithms, Programming and Software Development

This assignment delves into the core concepts of algorithms and software development. It begins by defining algorithms and illustrating them with a flowchart example. The document then outlines the Software Development Life Cycle (SDLC), detailing the phases involved in building a software application. It further explains the roles of the pre-processor, compiler, linker, and interpreter, using Java as an example to describe the program execution process. The assignment then explores procedural, object-oriented, and event-driven programming paradigms, highlighting their characteristics and relationships. An analysis of Integrated Development Environments (IDEs) is conducted, comparing features of NetBeans and Eclipse, and identifying common functionalities. The document also covers debugging processes within an IDE and emphasizes the importance of coding standards. Overall, it provides a comprehensive understanding of fundamental programming and software development principles.

Contents
Acknnowledgement .......................................................................... Error! Bookmark not defined.
Introduction .................................................................................................................................... 1
1.1 Define what an algorithm is. Give a simple example of an algorithm using a technique that
you’ve learnt/know to express algorithms .................................................................................... 2
Simple example for an algorithm using flow chart ........................................................................ 3
1.2 Briefly describe the process of building a software application (i.e. the phases of the SDLC –
Software Development Life Cycle) ................................................................................................. 5
1.3 Explain the roles of the Pre-processor, Compiler, Linker & Interpreter and describe the
process of programme execution (steps taken from writing code to execution) of a
programming language of your choice (i.e. Java) .......................................................................... 7
2.1 Explain procedural, object oriented and event driven programming paradigms. Your
explanations should also include the characteristics of each ...................................................... 10
2.2 Describe the relationship between procedural, object oriented and event driven paradigms.
28 .................................................................................................................................................. 12
2.3 Explain what an Integrated development environment (IDE) is. Give three examples of your
choice ............................................................................................................................................ 13
2.3 Do a comparison of the features of the IDEs you’ve mentioned in 2.3. Analyze the common
features that a developer has access to in all these IDEs ............................................................ 14
NetBeans vs Eclipse ...................................................................................................................... 15
4.1 Explain how debugging is carried out using the IDE that you used for developing your
application (the debugging process). Describe the debugging facilities available in the IDE you
used. 42
4.2 Outline the coding standards you have used when developing the above application.......42
Introduction
A programme is a set of instructions that tell the computer to do various things; sometimes
the instruction it has to perform depends on what happened when it performed a previous
instruction. This section gives an overview of the two main ways in which you can give these
instructions, or “commands” as they are usually called. One way uses an interpreter, the other

a compiler. As human languages are too difficult for a computer to understand in an
unambiguous way, commands are usually written in one or other languages specially designed
for the purpose.
In this assignment at the beginning we are going to explain about algorithms and the process
of a programming application. Then we have to explain the characteristics of procedural,
objectoriented and event-driven programming, conduct an analysis of a suitable IDE and
implement basic algorithms in code using IDE. At the end of this assignment we have to
determine the debugging process and explain the importance of a coding standard.
Task 01
1.1 Define what an algorithm is. Give a simple example of an
algorithm using a technique that you’ve learnt/know to
express
algorithms (i.e. a pseudocode/ flow chart).
Programming is the process of taking an algorithm and encoding it into a notation, a programming
language, so that it can be executed by a computer. Even though many programming languages
and many different types of computers exist, the important first step is the need to have the
solution. Without an algorithm there can be no program. Computer science is not the study of
programming. Programming, however, is a vital part of what a computer scientist does.
Programming is often the way that we create a representation for our solutions. Therefore, this
language representation and the process of creating it becomes a fundamental part of the
discipline.
Algorithms describe the solution to a problem in terms of the data needed to represent the
problem instance and the set of steps necessary to produce the intended result. Programming
languages must provide a notational way to represent both the process and the data. To this end,
languages offer control constructs and data types.

Simple example for an algorithm using flow chart
Algorithms and flowcharts are two different ways of presenting the process of solving a
problem. Algorithms consist of a set of steps for solving a particular problem, while in
flowcharts, those steps are usually displayed in shapes and process boxes with arrows. So,
flowcharts can be used for presenting algorithms.
Determine whether a student passed the exam or not,
Algorithm-
Step 01: input the grades of 4 courses G1, G2, G3 and G4.
Step 02: calculate the average grade with formula “grade=(G1+G2+G3+G4)/4”
Step 03: if the average grade is less than 60, print “FAIL”, else print “PASS”.

1.2 Briefly describe the process of building a software application
(i.e. the phases of the SDLC – Software Development Life Cycle)
The process of software development services goes to through a series stages in step wise
fashion that almost every developing company follows. Known as the software development
life cycle, these six steps include planning, analysis, design, development and implementation,
testing and deployment and maintenance. Let’s go ahead and see each of these steps to know
how the perfect software is developed.
1. Planning: without the good plan, calculating the strength and
weaknesses of the project, development of software is
meaningless. Planning kicks off a project flawlessly and affects its
progress positively.
2. Analysis: this step about analyzing the performance of the
software at various stages and making notes on additional
requirements. Analysis is very important to proceed further to the
next step.
3. Design: once the analysis is complete, the step of designing takes
over, which is basically building the architecture of the project.
This step will remove possible flaws by setting a standard and
attempting to stick to it.
4. Development and implementation: the actual task of developing
the software starts here with data recording going on in the
background. Once the software is developed, the step of
implementation comes in where the product goes through a pilot
study to see if it’s functioning properly.
5. Testing: the testing stage assesses the software for errors and
documentation bugs if there are any.

6. Maintenance: once the software passes through all the stages
without any issues, it is to undergo a maintenance process when
it will be maintained and upgraded from time to time to adapt to
changes. Almost every software development company follows all
the six steps, leading to the reputation that the country enjoys in
the software market today.

1.3 Explain the roles of the Pre-processor, Compiler, Linker &
Interpreter and describe the process of programe execution
(steps taken from writing code to execution) of a
programming language of your choice (i.e. Java)
Pre-processor
The pre-processor is a macro processor that is used automatically by the C compiler to
transform your program before actual compilation (Preprocessor directives are executed
before compilation.). It is called a macro processor because it allows you to define macros,
which are brief abbreviations for longer constructs. A macro is a segment of code which is
replaced by the value of macro. Macro is defined by directive.
Compiler
A compiler is a computer program that transforms code written in a high-level programming
language into the machine code. It is a program which translates the human-readable code to
a language a computer processor understands (binary 1 and 0 bits). The computer processes
the machine code to perform the corresponding taasks.
A compiler should comply with the syntax rule of that programming language in which it is
written. However, the compiler is only a program and cannot fix errors found in that program.
So, if you make a mistake, you need to make changes in the syntax of your program.
Otherwise, it will not compile.
Linker and Interpreter
An interpreter is a computer program, which coverts each high-level program statement into
the machine code. This includes source code, pre-compiled code, and scripts. Both compiler
and interpreters do the same job which is converting higher level programming language to
machine code. However, a compiler will convert the code into machine code (create an exe)
before program run. Interpreters convert code into machine code when the program is run.

Linker
In high level languages, some inbuilt header files or libraries are keep. These libraries are
predefined and these contain basic functions that are essential for execution the program.
These functions are connected to the libraries by a program known as Linker. If linker doesn't
realize a library of a operate then it informs to compiler and so compiler generates an error.
The compiler mechanically invokes the linker because the last step in compilation a program.
Not built in libraries that also links the user defined functions to the user defined libraries.
Sometimes an extended program is divided into smaller subprograms known as modules. And
these modules should be combined to execute the program. The method of combining the
modules is finished by the linker.
Process of programme execution (Java)
First, the source ‘.java’ file is passed through the compiler, which then encodes the source
code into a machine independent encoding, known as Bytecode. The content of each class
contained in the source file is stored in a separate ‘.class’ file. While converting the source
code into the bytecode, the compiler follows the following steps:
Parse: Reads a set of *.java source files and maps the resulting token sequence into AST
(Abstract Syntax Tree)-Nodes.
Enter: Enters symbols for the definitions into the symbol table.
Process annotations: If Requested, processes annotations found in the specified compilation
units.
Attribute: Attributes the Syntax trees. This step includes name resolution, type checking and
constant folding.
Flow: Performs dataflow analysis on the trees from the previous step. This includes checks for
assignments and reachability.
Desugar: Rewrites the AST and translates away some syntactic sugar.
Generate: Generates ‘.Class’ files

The class files generated by the compiler are independent of the machine or the OS, which
allows them to be run on any system. To run, the main class file (the class that contains the
method main) is passed to the JVM, and then goes through three main stages before the final
machine code is executed. These stages are:
Class Loader
The main class is loaded into the memory by passing its ‘.class’ file to the JVM, through
invoking the latter. All the other classes referenced in the program are loaded through the
class loader. A class loader, itself an object, creates a flat name space of class bodies that are
referenced by a string name. The method definition is:
// loadClass function prototype
Class r = loadClass(String className, boolean resolveIt);
// className: name of the class to be loaded
// resolveIt: flag to decide whether any referenced class should be loaded or not.
There are two types of class loaders: primordial, and non-primordial. Primordial class loader is
embedded into all the JVMs, and is the default class loader. A non-primordial class loader is a
user-defined class loader, which can be coded in order to customize class-loading process.
Nonprimordial class loader, if defined, is preferred over the default one, to load classes.

Task 02
2.1 Explain procedural, object oriented and event driven
programming paradigms. Your explanations should also include
the characteristics of each.
Procedural programming
In procedural programming, a program consists of data and modules/procedures that operate
on the data. The two are treated as separate entities. In the object-oriented programming
(OOP) paradigm, however, a program is built from objects. An object is an instance of a class,
which is an encapsulation of data (called fields) and the procedures (called methods) that
manipulate them. In most, but not all, cases, the fields can only be accessed or modified
through the methods.
An object therefore is like a miniature program or a self-contained component, which makes
the OOP approach more modularized and thus easier to maintain and extend.
Another type of programming paradigm that procedural programming can be contrasted with
is event-driven programming. In this approach, procedures are called/executed only in
response to events, which may include mouse clicks, keyboard press, attaching or removing a
device, arrival of data from an external source, etc. As these events are unpredictable, the
procedures that handle them cannot be executed linearly as is the case with procedural
programming.
Characteristics of Procedural oriented programming: It
focuses on process rather than data.
• It takes a problem as a sequence of things to be done such as reading, calculating and
printing. Hence, a number of functions are written to solve a problem.
• A program is divided into a number of functions and each function has clearly defined
purpose.
• Most of the functions share global data.
• Data moves openly around the system from function to function.

Object oriented programming
Object-oriented programming (OOP) refers to a type of computer programming (software
design) in which programmers define the data type of a data structure, and also the types of
operations (functions) that can be applied to the data structure.
In this way, the data structure becomes an object that includes both data and functions. In
addition, programmers can create relationships between one object and another. For
example, objects can inherit characteristics from other objects.
Some key features of the Object-Oriented programming are:
- Emphasis on data rather than procedure
- Programs are divided into entities known as objects
- Data Structures are designed such that they characterize objects
- Functions that operate on data of an object are tied together in data structures
- Data is hidden and cannot be accessed by external functions
- Objects communicate with each other through functions- New data and functions can be
easily added whenever necessary - Follows bottom up design in program design.
Event driven programming
Event-driven programming known as a computer programming paradigm that used the
occurrence of events to determine the control flow of the program. This type of application is
designed to detect events as they occur, and use an appropriate event-handling procedure to
deal with it, which normally use a callback function or method.
Theoretically, event-driven style of programming is supported in all programming languages,
but they may different in the way of implement it, for example, it’s easier to implement in
languages that provide high-level abstractions, such as closures. Besides, for other
programming environments such as Adobe Flash, they are specifically tailored for triggering
program code by events. Generally, there is a main loop in an event-driven application that used
to listen for events and triggers a callback function when there are events is detected.

Characteristics of event driven programming
• Builds upon Object Oriented Programming.
• It often leads to better software design.
• Enhances the building of event driven applications like those that watch changes in
application states.
• Improved responsiveness and flexibility.
2.2 Describe the relationship between procedural, object oriented
and event driven paradigms.
Procedural paradigm is your looking at the process needed to solve a problem. I do a, then I
do b, and then I do c. There’s a definite process and the flow of the data is highly predictable.
Object oriented is looking at the actors and creating objects to represent those actors. For
example, an emulator for a movie line queue. You’ve got people, the line, and a ticket booth.
So, you build objects around those actors.
Event driven, is used when you have spontaneous moments that need to be taken care of. You
can add event handlers to both procedural and object oriented paradigms. So, as a stand
alone, it’s not a complete paradigm. For instance, your procedural report writer could have an
event to handle out of paper. Or the object-oriented program could have an event to handle
when lightning hits a person standing line for the movie. Events are more a feature to add to
other stuff. Is there a relationship between procedural and object oriented? Not really, based
on the problem to be solved you pick a paradigm which allows you to solve it most efficiently.
Object oriented programming is a way of organizing code around the principles of
encapsulation, inheritance, substitution, programming to interfaces, and so on. Object
oriented programs are usually mostly procedural.
Event based programming is about writing event handling procedures and having the core
event loop provided by the underlying system. In this way you can save the trouble of writing
your own event loop and benefit from various libraries that already work with the system
provided event loop. Event based programs are very often writing using object-oriented style,