INTERNATIONAL SCHOOL OF

MANAGEMENT AND TECHNOLOGY

FACULTY OF COMPUTING

ASSIGNMENT COVER SHEET

This form is to be completed by students submitting assignments of level 4 and level 5.
Students are required to complete all sections and attach to your assignment.

STUDENT DETAILS

STUDENT NAME

STUDENT ID

UNIT AND ASSIGNMENT DETAILS

UNIT TITLE Unit 1: Programming

UNIT NUMBER H/618/7388

ASSIGNMENT Introduction to Algorithms and Programming with an IDE

TITLE

ISSUE DATE DUE DATE Deadline Date

ASSESSOR Teacher’s Name

NAME

ESTIMATED
WORD LENGTH

SUBMISSION

HAND IN DATE Submitted Date

DECLARATION AND ACKNOWLEDGEMENT
When submitting assignments, each student must sign a declaration confirming
that the work is their own.

Plagiarism and Collusion

Plagiarism: to use or pass off as one’s own, the writings or ideas of another
without acknowledging or crediting the source from which the ideas are taken.

Collusion: submitting an assignment, project or report completed by another

person and passing it off as one’s.

In accordance with the Academic Integrity and Plagiarism Policy:

1. I declare that:
a) this assignment is entirely my own work, except where I have included fully-
documented references to the work of others,
b) the material contained in this assignment has not previously been submitted
for any other subject at the University or any other educational institution,
except as otherwise permitted,
c) no part of this assignment or product has been submitted by me in another
(previous or current) assessment, except where appropriately referenced, and
with prior permission from the Lecturer / Tutor / Unit Coordinator for this unit.

2. I acknowledge that:
a) if required to do so, I will provide an electronic copy of this assignment to the
assessor;
b) the assessor of this assignment may, for the purpose of assessing this
assignment:
I. reproduce this assignment and provide a copy to another member of
academic staff;
II. communicate a copy of this assignment to a plagiarism checking
service such as Plagiarism Check (which may then retain a copy of this
assignment on its database for the purpose of future plagiarism
checking).

I am aware of and understand that any breaches to the Academic Code of Conduct will
be investigated and sanctioned in accordance with the College Policy.

SIGNATURE DATE
Table of Contents
List of Figures..................................................................................................................................1
List of abbreviation..........................................................................................................................3
Programming Paradigms.................................................................................................................4
Types of Programming Paradigms..................................................................................................5
Procedural Programming.................................................................................................................6
Characteristics of Procedural Programming................................................................................7
Uses of Procedural Programming................................................................................................8
Object Oriented Programming (OOP).............................................................................................9
Characteristics of OOP..............................................................................................................10
Uses of OOP..............................................................................................................................12
Event Driven Programming...........................................................................................................13
Characteristics of Event Driven Programming..........................................................................14
Uses of Event Driven Programming..........................................................................................15
Interrelationship between the programming paradigms................................................................15
Evaluation of source code in an application..................................................................................16
Procedural Programming...........................................................................................................16
Evaluation..................................................................................................................................17
Object Oriented Programming...................................................................................................17
Evaluation..................................................................................................................................18
Event Driven Programming.......................................................................................................18
Evaluation..................................................................................................................................21
Activity 2.......................................................................................................................................22
Algorithm.......................................................................................................................................22
Process of building an application.................................................................................................22
Defining and analyzing the requirements..................................................................................22
Steps taken from writing code to execution..................................................................................23
Step 1: Define an algorithm:......................................................................................................23
Step 2: Draw out a flowchart:....................................................................................................24
Step 3: Choose Platform:...........................................................................................................25
 IDE (Integrated Development Environment)............................................................................25
Preferred IDE (Net Beans).........................................................................................................25
Step 4: Suitable Programming Language..................................................................................26
Low Level Programming Language......................................................................................26
High Level Programming Language.....................................................................................26
Step 5: Program Execution Process...........................................................................................26
Process of writing code..................................................................................................................27
Problem faced................................................................................................................................28
Coding standard used in my code..................................................................................................28
Implementation of algorithm in a suitable language.....................................................................30
Algorithm...................................................................................................................................30
Flowchart...................................................................................................................................31
Pseudo Code..............................................................................................................................31
Relationship between algorithm and code.....................................................................................33
Integrated Development Environment (IDE)................................................................................33
Common features of IDE...............................................................................................................34
IDENTIFYING AND SOLVING ANY LOGICAL ERRORS.....................................................34
Debugging program errors.............................................................................................................36
Activity 3.......................................................................................................................................38
Integrated Development Enviroment.............................................................................................38
IDE chosen for my project.............................................................................................................38
Debugging......................................................................................................................................39
Process of Debugging....................................................................................................................40
Prove the Analysis.....................................................................................................................41
Debugging features available in Apache NetBeans...................................................................41
Breakpoints................................................................................................................................41
Variable Inspection....................................................................................................................42
Exception handling....................................................................................................................42
Stepping.....................................................................................................................................43
Debugging Process for the secure and robust application.............................................................44
Activity 4.......................................................................................................................................45
Integrated Development Enviroment.............................................................................................45
Use of a IDE in development process of the program...................................................................45
Algorithm for the Best Fitness Fee Calculator..........................................................................45
Flow chart for the Best Fitness Application..............................................................................46
Screenshot of the best fitness fee calculator using IDE.................................................................46
Login Page.................................................................................................................................46
Best Fitness Fee Calculator...........................................................................................................48
Relationship between algorithm and source code.........................................................................49
Evaluation of the use of an IDE to develop the application..........................................................50
Comparison of using IDE without using.......................................................................................51
Coding Standard............................................................................................................................51
Role of Coding Standard...............................................................................................................51
Evaluation of Coding Stadard........................................................................................................52
Necessary for individuals..........................................................................................................52
Necessary for teams...................................................................................................................52
References......................................................................................................................................53
 PROGRAMMING

List of Figures
Figure 1 Programming Paradigms...................................................................................................4
Figure 2 Types of programming paradigms....................................................................................5
Figure 3 Procedural Programming...................................................................................................6
Figure 4 Characteristics of Procedural Programming.....................................................................7
Figure 5 Uses of procedural Programming......................................................................................8
Figure 6 OOP...................................................................................................................................9
Figure 7Characteristics of OOP.....................................................................................................10
Figure 8 Uses of OOP....................................................................................................................12
Figure 9 Event Driven Programming............................................................................................13
Figure 10 Characteristics of Event Drive Programming...............................................................14
Figure 11Uses of Event Driven Programming..............................................................................15
Figure 12 Interrelationship between the paradigms.......................................................................15
Figure 13 Illustrations of Procedural Programming......................................................................17
Figure 14 Output of Procedural Programming..............................................................................17
Figure 16 Illustration of OOP........................................................................................................18
Figure 15 Output of OOP..............................................................................................................18
Figure 17 Coding for Event Driven Programming........................................................................20
Figure 18 Output of Event Driven Programming..........................................................................21
Figure 19 Software Development Process.....................................................................................22
Figure 20 Flow chart of odd and even numbers............................................................................24
Figure 21 Apache NetBeans..........................................................................................................25
Figure 22 Program Execution Process...........................................................................................26
Figure 23 Coding Standard............................................................................................................29
Figure 24 Class Field.....................................................................................................................29
Figure 25 Flowchart of area...........................................................................................................31
Figure 26 calculate the area of rectangle in C++..........................................................................32
Figure 27 Calculate he area of rectangle in phython.....................................................................32
Figure 28 calculate the area of rectangle in java...........................................................................32
Figure 29 Logical Errors................................................................................................................35
Figure 30 Solving the error............................................................................................................36
Figure 31 error in program............................................................................................................37
Figure 32 Debugged program code...............................................................................................37
Figure 33 IDE chosen for project..................................................................................................38
Figure 34 Debugging.....................................................................................................................39
Figure 35 Process of Debugging....................................................................................................40
Figure 36 Debugging Features in Apache NetBeans.....................................................................41
Figure 37 Breakpoints....................................................................................................................42
Figure 38 Exception Handling.......................................................................................................43

Page 1
 PROGRAMMING

Figure 39 Debugging for secure application.................................................................................44

Figure 40 IDE................................................................................................................................45
Figure 41Flowchart of Best Fitness...............................................................................................46
Figure 42 Login Page of Best Fitness............................................................................................47
Figure 43 Login Successful...........................................................................................................47
Figure 44 Error in Login Page.......................................................................................................48
Figure 45 Best Fitness Application................................................................................................49

Page 2
 PROGRAMMING

List of abbreviation
IDE: Integrated Development Environment

OOP: Object Oriented Programming

GUI: Graphical User Interface

Page 3
 PROGRAMMING

Programming Paradigms

Figure 1 Programming Paradigms

Programming paradigms are various approaches or styles in which a specified program or

programming language can be structured. Each paradigm involves certain elements, features, and
ideas about how to resolve common programming issues. Many programming languages employ
different approaches or strategies in order to use paradigms. It is not necessary for these
paradigms to be exclusive of each other; it is possible for a single program to incorporate
multiple paradigms (Collegenp, 2023).

Page 4
 PROGRAMMING

Types of Programming Paradigms

Figure 2 Types of programming paradigms

The various types of programming paradigms include

 Procedural Programming
 Object-oriented Programming
 Event-driven Programming

Page 5
 PROGRAMMING

Procedural Programming

Figure 3 Procedural Programming

Procedural programming is a programming paradigm that involves partitioning down a problem

into a set of processes or procedures that are implemented progressively. This is a significant and
typical programming paradigm that is still extensively used in numerous spheres of software
development. The foundational principle of procedural programming is to divide a problem into
smaller, more manageable sections and tackle each separately. It is appropriate for applications
necessitating a sequence of stages or low-level programming (Collegenp, 2023).

Page 6
 PROGRAMMING

Characteristics of Procedural Programming

Figure 4 Characteristics of Procedural Programming

 It assembles code into modular and reusable parts by using procedures, subroutines, or
functions.
 It divides a program into smaller procedures, each of which responsible for executing a
certain task.
 Creates program using top-down process
 It demonstrates real-world forms as 'procedures' working on 'data'.
 The information and capacities are confined from each other.
 The program's logic is clear and easy to grasp. (Sinha, 2021).

Page 7
 PROGRAMMING

Uses of Procedural Programming

Figure 5 Uses of procedural Programming

 It operates effectively for problems that can be broken down into sequence.
 It is generally used in scripting techniques. Some scripting techniques used are Bash, Perl
and Python.
 Organizing code into procedures enables the reuse of common code throughout a
program.
 It produces more efficient code in low-level programming as compared to other
programming paradigms because it permits direct control over the machine (Collegenp,
2023).

Page 8
 PROGRAMMING

Object Oriented Programming (OOP)

Figure 6 OOP

Object-oriented programming (OOP) is a programming paradigm that relies on introducing the

concept of objects, which are instances of classes that incorporate data as well as activity. The
fundamental objective of OOP is to arrange code around objects, which work as the system's
foundation. OOP offers additional degrees of abstraction and encapsulation through the use of
objects, making it less complex to design big and scalable systems. OOP is optimal to
complicated, big and often updated or maintained programs (Collegenp, 2023).

Page 9
 PROGRAMMING

Characteristics of OOP

Figure 7Characteristics of OOP

The characteristics of OOP is given below

 Class
 Object
 Polymorphism
 Data Abstraction
 Inheritance
 Encapsulation

Class

The concepts of classes and objects are centered around OOP. Classes are utilized for creating
objects, which are instances of the class. OOP offers higher abstraction and modularity by
employing classes and objects, which can facilitate the construction of large and scalable
software systems (Agrawal, 2023).

Object

Objects are distinct entities with their own attributes and functions. When an object is created,
memory is assigned to keep its information and methods. Objects can interact with one another
without requiring knowledge of each other's data or programming. (Agrawal, 2023).

Polymorphism

Page 10
 PROGRAMMING

Polymorphism is a characteristic of OOP which allows object to take on numerous forms. This
implies that objects may be utilized in a variety of ways depending on the context, allowing for
more flexibility and extensibility. This is very beneficial for developing complicated and scalable
systems (Agrawal, 2023).

Abstraction

Abstraction is a crucial concept in OOP that includes hiding irrelevant information from the user
in order to control complexity. Abstraction helps programmers to introduce new features without
impacting other sections of the code by focusing only the necessary aspects. This decreases
programming complexity, increases efficiency, and promotes modularity, making the code easier
to maintain and debug. Large code bases would become highly complicated without abstraction,
and adding new functionality would be challenging (Agrawal, 2023).

Inheritance

In OOP, inheritance provides objects with the ability to acquire attributes and functions from
other objects. This concept involves making new classes derived from existing ones, with the
newly created one referred to as the derived class and the existing one as the base class. This
method allows for the formation of a hierarchical class system that is able to replicate real-world
objects and their interactions. Inheritance promotes reusability by allowing for the reuse of fields
and methods from the base class in the derived class. (Agrawal, 2023).

Encapsulation

Encapsulation is an integral concept in object-oriented programming (OOP) that entails grouping

data and activity into a single unit called an object and prohibiting direct access to it from outside
influence. Encapsulation protects data and techniques from outside intervention by limiting
direct access to them. It is the technique of encapsulating all vital information within an item and
disclosing only a portion of it to the outer world (Agrawal, 2023).

Page 11
 PROGRAMMING

Uses of OOP

Figure 8 Uses of OOP

The uses of OOP are listed below

 OOP promotes the reuse of existing objects and libraries

 OOP includes hiding the irrelevant information from user to reduce the complexity
 Encapsulation, the feature of OOP protects data and techniques from outside intervention
by limiting direct access to them.

Page 12
 PROGRAMMING

Event Driven Programming

Figure 9 Event Driven Programming

Event-driven programming is a programming paradigm that focuses on the management and

handling of the events. In this paradigm, the control flow of the program is determined by the
occurrence of events, which are monitored by code. Event-driven programming is often used in
graphical user interfaces (GUIs) to allow the program to respond to user interactions, such as
mouse clicks and key presses (Collegenp, 2023).

Page 13
 PROGRAMMING

Characteristics of Event Driven Programming

Figure 10 Characteristics of Event Drive Programming

 It is excellent for creating complex structures since it encourages the divide-and-conquer

philosophy and permits the use of additional strategies, such as synchronous calls.
 It is used in graphical user interfaces (GUIs) and other applications that prioritize user
input.
 It is more straightforward and user-friendly since it is more visible (Collegenp, 2023).

Page 14
 PROGRAMMING

Uses of Event Driven Programming

Figure 11Uses of Event Driven Programming

It is useful in the game development while creating the behavior of objects in games.

It is beneficial in Graphical User Interface (GUI) and other applications that focus on user input.

Interrelationship between the programming paradigms

Figure 12 Interrelationship between the paradigms

Page 15
 PROGRAMMING

Procedural programming is a type of imperative programming that is centered on its concept of

calling processes. A procedure is instinctively a set of instructions that perform some computing
and are executed one at a time. The core concept of procedural programming is dividing a task
into smaller, more manageable bits of code known as functions or procedures. This is done to
make the program easier to utilize and maintain. C++, C, and BASIC are some instances of
procedural programming.

The event-driven programming method concentrates upon events such as user interactions,
system notifications, or sensor outputs. The occurrence of events determines the sequence of
program execution in this paradigm. Some examples of event-driven programming languages
include Visual Basic, C++, and Java.

Object-oriented programming (OOP) is a programming paradigm that focuses on using classes

and objects to organize and structure software programs. The basic idea behind OOP is to create
reusable code components, called classes, which can be used to instantiate individual objects. In
OOP, a program is organized into classes that define the behavior and properties of objects.
Some examples of OOP include C++, Java, and Python.

The overall flow or decision-making logic of an application is outlined by procedural and event-
driven programming, whereas object-oriented programming focuses on the structure of the
decision-making logic. Object-oriented programming can be viewed as a continuation or
evolution of procedural programming, while object-oriented programming is suitable for
implementing event-driven programming (Yasi, 2022).

Evaluation of source code in an application

Programming paradigms are several structures or methods for organizing a certain program or
programming language. A programming paradigm is a way of organizing and structuring code,
and it can have a significant impact on how the code is written and how it is used. So, let’s
explore some examples of source code that implement different programming paradigms.

Procedural Programming

Here is an example of using the procedural programming paradigm in C++ to check if the given
integer is a prime number.

Page 16
 PROGRAMMING

Figure 13 Illustrations of Procedural Programming

Figure 14 Output of Procedural Programming

Evaluation
The program in C++ demonstrates the use of procedural programming to determine whether a
user-inputted number is prime or not. It starts by defining three integer variables and asking the
user to enter a number. The code is executed in a sequential manner from top to bottom, which is
characteristic of procedural programming.

Object Oriented Programming

Here is an example of using the object-oriented programming paradigm in C++ to display the
information of student using the class

SCREENSHOT OF CODES WITH CLASS…

Figure 15 Illustration of OOP

Page 17
 PROGRAMMING

SCREENSHOT OF THE ABOVE CODE OUTPUT…

Figure 16 Output of OOP

Evaluation
In the above code, we define a student class with private member variables for roll number and
age. The constructor is used to initialize the object with the provided values. The get details ()
method is a member function of the class that displays the student's information. We then call get
details () method to display the student's information.

Event Driven Programming

Here is an example of using the object-oriented programming paradigm in C++ to check if the
given integer is a prime number.

Page 18
 PROGRAMMING

Page 19
 PROGRAMMING

Figure 17 Coding for Event Driven Programming

Page 20
 PROGRAMMING

Figure 18 Output of Event Driven Programming

Evaluation
The above diagram demonstrates how to make java calculator using the event driven
programming. This program in Java demonstrates the functionality of a basic calculator that can
perform fundamental arithmetic operations, such as addition, subtraction, multiplication, and
division. The program receives user input and displays the results of the calculations, depending
on the user's selection of the operation. Event-driven programming is a programming paradigm
that focuses on the management and handling of the events.

Page 21
 PROGRAMMING

Activity 2

Algorithm
An algorithm is a set of instructions that must be carried out in a certain order in order to produce
a given result. Algorithms can be implemented in several programming languages because their
development is frequently independent of the chosen language. Key characteristics of an
algorithm include being precise, accurate, efficient, and independent of any one particular
programming language. The importance of algorithm is determined by its performance and
scalability (Upadhyay, 2023)

Process of building an application

From identifying the issue to launching and maintaining the application, building an application
is a complex and multifaceted process that involves many steps. This outline discusses the
crucial steps involved for developing an application and points out some best practices and
resources that can guarantee success (Shiverware, 2019).

Figure 19 Software Development Process

The steps for the building an application involves five different steps:

Defining and analyzing the requirements:

Before coming up with a general idea for any program, it is crucial for the team of software
specialists to gather the business requirements at the earliest phase of building an application.
During this phase, stakeholders and project managers should concentrate on identifying the
specific features of the software under consideration. Stakeholders assist in determining what
type of software is required by recommending features or issues that must be solved. They create
use-case diagrams and process maps that assist the UI design of the new program (Pham, 2019).

Page 22
 PROGRAMMING

Designing
In the design phase of an application development, software developers create a prototype and
user interface to represent how the application should function and look. They refine the design
based on feedback and generate a test model to verify the application's performance. The project
scope is reviewed, an estimate is provided, and the design is evaluated after completion to make
sure it satisfies the customer's expectations (Pham, 2019).

Developing

In the development stage, the developers will be responsible for writing the code based on the
final design documents. The code will be developed according to the design and implementation
models. The application will be tested thoroughly to ensure it meets quality standards and
customer requirements. Any issues or bugs will be identified and addressed during the debugging
process. The testing will be carried out using pre-established test cases and plans (Pham, 2019).

Integrating and testing

The integration process will necessitate the utilization of a test plan, deployment diagrams, and
user acceptance criteria. Testing is a noteworthy part of the software creation life cycle and
includes several types of functional and non-functional tests, like integration testing, unit testing,
system testing, acceptance testing, and non-functional testing. Testing begins after the coding is
done and the created program is fully tested. If any issues are encountered, they are delegated to
developers to be resolved. (Pham, 2019).

Deploying
During the final stage of deployment, the software application will be implemented according to
the deployment plan. Once the customer approves the deployed software, we will establish a
maintenance team to provide ongoing support to the customer (Pham, 2019).

Steps taken from writing code to execution

Using different programming languages, there are numerous ways to carry out a program. Some
of the procedures include:

Step 1: Define an algorithm:

An algorithm is a set of steps or rules to solve a problem or complete a task. It is essentially a
formula that guides the user to the solution. Computer programs can be seen as complex
algorithms that carry out specific tasks through a sequence of pre-defined actions. Here is an
example of the algorithm to find whether the entered number is odd or even.

Step 1: Start

Step 2: Declare Variable n.

Step 3: Ask the user to input a number.

Page 23
 PROGRAMMING

Step 4: Check: If n%2 == 0 Then

Print: N is an Even Number.

Else

Print: N is an Odd Number.

Step 5: Stop.

Step 2: Draw out a flowchart:

A flowchart is a visual representation of an algorithm that uses symbols to show the steps in a
process. It helps to make the algorithm easier to understand by presenting it in a diagram. To
illustrate this, I created a flowchart that demonstrates how to determine if a number is even or
odd.

Figure 20 Flow chart of odd and even numbers

Step 3: Choose Platform:

An interconnected system of software, hardware, and technologies is referred to as a platform.

Through interfaces and usage patterns, the platform offers a certain set of functions. Components
that are compatible with the platform can interact and operate without any problems, regardless
of how the platform's functionality is actually implemented. The most effective way to work with

Page 24
 PROGRAMMING

the platform appears to be via selecting an appropriate Integrated Development Environment

(IDE).

IDE (Integrated Development Environment)

An Integrated Development Environment (IDE) is a software tool that enables programmers to
integrate different aspects of creating computer programs. IDEs strengthen programmers'
efficiency by combining many software developments processes into a single package. A single
graphical user interface (GUI) can be used to access all of these features. These tasks include
debugging programs, producing executable files, and altering source code. IDE is intended to
boost developers' efficiency. They accomplish this by minimizing the duration of setup,
accelerating the pace of development tasks, educating developers on the most recent best
practices and security concerns (CodeAcademy, 2023).

Preferred IDE (Net Beans)

The Apache Net Beans platform is a software development framework that offers an all-
inclusive environment for constructing applications with the utilization of Java SE, PHP, and
HTML5. Furthermore, it facilitates effortless incorporation with exterior tools and services. This
platform is primarily utilized by beginners in the programming and development field. So, I have
utilized the Net Beans Integrated Development Environment (IDE) to develop the software.

Figure 21 Apache NetBeans

Step 4: Suitable Programming Language

Programming languages are composed of up of a set of instructions that the CPU compiles to
carry out certain tasks. The majority of these languages are high-level ones, including C, C++,
Pascal and COBOL. Each programming language is unique and encompasses a set of keywords
and syntax, which are utilized to craft a set of instructions that the computer can understand and
perform (Hemmendinger, 2022).

Page 25
 PROGRAMMING

Low Level Programming Language

A low-level language is a kind of programming language that is expressed in binary form using
0s and 1s, which are equivalent to machine instructions, and lacks hardware abstraction. Machine
level language and Assembly language are the two languages that fall under this category
(Hemmendinger, 2022).

High Level Programming Language

High-level language is a programming language that permits programmers to create programs
that are not dependent on a specific type of computer. These languages are deemed "high-level"
because they are closer in syntax and structure to human languages than machine-level languages
(Hemmendinger, 2022).

Step 5: Program Execution Process

Figure 22 Program Execution Process

Preprocessor

The C/C++ program is first processed in the preprocessor before compilation. The preprocessor
includes header files and expands macros.

Compiler

The second stage of the process is complier where the output file is created during the
preparation step and sent to the compiler. The compiler compiles the program, checks for errors
and generates the object file, which contains assembly code.

Linker

Page 26
 PROGRAMMING

In this third stage, a linker merges multiple object files or libraries and creates an executable file.

Loader:

At this point in the procedure, the loader loads the executable file into main memory so that the
program may run (Jaiswal, 2022).

Process of writing code

The process of writing code requires a few essential steps to guarantee the production of a
dependable and viable software answer. These steps encompass comprehending the necessities,
designing the answer, executing the code, and examining/troubleshooting it (Study.com, 2003).

Understanding the Requirements: The first and most important stage is to obtain an extensive
understanding of the project's specifications. Collaboration with stakeholders, such as customers
or product owners, is required to acquire precise information on the intended functionality, user
expectations, constraints, and any unique business laws or regulations that must be taken into
account (Study.com, 2003).

Designing a solution: Once the needs are understood, the following step is to design the
solution. Structuring the solution necessitates forming a high-level design or framework design
that depicts the general structure, components, and associations of the software. This can
incorporate making diagrams, flowcharts, or other visual representations to arrange the code
composition and recognize the connections between various modules or classes (Study.com,
2003).

Implementing the Code: Once the design is complete, the coding phase may begin. Developers
produce code according to their preferred programming language, transforming the design and
requirements into instructions that may be executed. This stage includes identifying the proper
data structures, algorithms, and programming paradigms required for achieving the needed
functionality. Code is often produced in a text editor or an IDE (Study.com, 2003).

Testing and Debugging: After writing the code, it is required to be thoroughly examined in
order to verify its precision and reliability. Testing entails writing test cases which address
various situations and edge cases with the aim to ensure that the code performs as intended. Unit
testing (testing individual components or functions), integration testing (testing component
interaction), and system testing (testing the complete system) are all part of it. Any errors or
problems that develop during testing are acknowledged and resolved through debugging, which
includes looking into and repairing the code to eliminate errors along with improving
performance (Study.com, 2003).

Iteration and maintenance: After the code has been properly developed and tested, the program
can proceed to a maintenance phase. This encompasses tracking, updating, and improving the
code for the purpose to respond to user feedback, solve issues, strengthen performance, and
Page 27
 PROGRAMMING

introduce new features. This iterative procedure indicates the software’s-maintained

dependability and functionality (Study.com, 2003).

Problem faced
When converting a designed algorithm into program code, there are several possible challenges
that one may face. Some of these challenges include:

• Identifying the appropriate data types and structures provided by the selected
programming language to represent the data used in the algorithm.
• Recognizing the appropriate control structures, such as loops, conditionals, and functions,
required to operate the algorithm in the selected programming language.
• Guaranteeing the efficiency and optimization of the computer code, this may need the use
of specialized data structures and methods.
• Debugging the program code, particularly when the algorithm is intricate, this might
necessitate the use of debugging methods and tools.
• The use of comments and other documentation tools may be necessary to make the
computer code readable and well-documented.

In short, the conversion of a proposed algorithm into computer code necessitates careful
consideration of a number of variables, including data types and structures, control structures,
optimization, debugging, documentation, security, compatibility, and coding standards (Manelli,
2020).

Coding standard used in my code

Coding standards confirm that code is written consistently and in a structured way. This
promotes readability and makes it easier for individuals to figure out and maintain the code.

Variable Scopes, Readability, and Lambda Expression

Every variable defined in Java has its own scope. This means that the variables' visibility and use
must be confined within the scope. A local variable is viewable from the beginning of its
declaration to the completion of the method or portion of code in which it is stated. Declaring a
variable close to its potential use is a useful strategy. This not only upgrades the accessibility of
code but also simplifies debugging ( Debnath, 2019).

Page 28
 PROGRAMMING

Figure 23 Coding Standard

Class Field

Methods in Java either belong to a class or an interface. As a result, there's a probability that the
programmer unintentionally using the same named local variables the same as class member
variables. The Java compiler, on the other hand, is able to distinguish the appropriate one from
the scope. Furthermore, contemporary IDEs are intelligent enough to detect the conflict.
However, it is the job of the programmer to be vigilant and prevent such conflicts since it can
lead to undesirable outcomes. The following code example display how competing variable
names might result in drastically different results ( Debnath, 2019).

Figure 24 Class Field

Page 29
 PROGRAMMING

Standard Libraries

Java is renowned for its extensive range of libraries. Although not all libraries are perfectly
designed, they are usually satisfactory. Java regularly introduces new libraries and continuously
enhances the existing ones. Hence, one should make the most of classes, methods, interfaces,
Enums, and annotations from the library whenever feasible ( Debnath, 2019).

Treating Method Arguments as Local Variables

In Java, a variable declared can be used multiple times. This means that local variables which are
non-final declared in the method arguments can also be used with different values. However, this
practice is not recommended due to the fact that the variable sent as a method argument is
supposed to keep its initial value which is the value that the method will work with ( Debnath,
2019).

Implementation of algorithm in a suitable language

Algorithm
Step-1: Start

Step-2: Input length and breadth

Step-3: area= length*breadth

Step-4: print area

Step-5: Stop

Page 30
 PROGRAMMING

Flowchart

Figure 25 Flowchart of area

Pseudo Code
START
DECLARE length, breadth
READ length, breadth
Area = length * breadth
PRINT "Area of rectangle is ", area
STOP

Now let’s write the program of above algorithm and pseudo code.

Given below is the structure in C++

Page 31
 PROGRAMMING

Figure 26 calculate the area of rectangle in C++

Given below is the structure in python

Figure 27 Calculate he area of rectangle in phython

Given below is the structure in java

Figure 28 calculate the area of rectangle in java

To calculate the area of a rectangle in C++, Java, and Python, you need to define variables for
the length and width of the rectangle. Once you have the length and width values, you multiply

Page 32
 PROGRAMMING

them together to obtain the area. The result of the multiplication is then stored in a variable
called 'area'. Before executing the computation, make sure that the length and width values have
previously been supplied or retrieved from the user. By modifying the length and width values,
you can calculate the area of different rectangles.

Relationship between algorithm and code

The success of the project is heavily dependent on the relationship between the algorithm and
program code. An algorithm is a logical step-by-step technique used to solve a specific issue or
job, whereas a program is software code that finally converts to machine code that the computer
can comprehend and execute to solve a given problem. An algorithm is more like a concept, a
means to solve a problem, but a program is more associated with the execution of one or more
tasks by a computer. An algorithm is a set of guidelines that are organized in a certain order to
address a problem. It is employed in a number of disciplines, including mathematics, computer
science, and logistics. Depending on the programming language being used, algorithms are
written using a specific syntax.

Computer programs are collections of instructions that instruct a computer how to execute a
particular task. Python, Java, C++, JavaScript, PHP, and Ruby are few of the programming
languages that are used to create computer applications. Humans are able to comprehend these
languages with ease because of their design. Programs are able to handle user input, alter that
information, and produce data in a way that is valuable to people. Algorithms act as a roadmap
for programmers during the development of programs. They provide precise and step-by-step
instructions for writing code by concentrating on the solution. This makes it easier to translate
the algorithm into a specific programming language. Algorithms help programmers solve
problems and write optimized code, and they vary depending on the programming language
used. Algorithms are essential in simplifying and streamlining the process of creating programs
(Singh, 2023).

Integrated Development Environment (IDE)

An IDE, or Integrated Development Environment, is a software application that combines the
many tools needed to build and test software into a single program. IDEs integrate functions such
as software editing, building, testing, and packaging. IDEs are meant to include all programming
processes in a single application, which can increase software developer productivity by
standardizing the development process and arranging the required capabilities for software
development in the UI. IDEs can also boost developer productivity by shortening installation
times and expediting programming operations. Developers must pick, deploy, integrate, and
maintain all of these technologies independently if they do not use an IDE (Allaire, 2012).

Page 33
 PROGRAMMING

Common features of IDE

An integrated development environment (IDE) is software which incorporates common
developer tools into one integrated graphical user interface (GUI) for the objective of developing
applications. An IDE generally comprises of the following components:

Source Code Editor: A source code editor is a specialized program created to make writing
code easier. It offers a range of programming-related features, such as syntax highlighting, which
demonstrates different parts of the code in different colors, language-specific auto-completion,
which fills in code snippets or functions as the developer types, and bug checking capabilities,
which can be used to highlight errors or potential problems in the code as it is being written.

Debugger: Debugger: a software program used to test other applications and illustrate
graphically where an issue exists in the source code.

Compiler: A compiler is a translator that generates a low-level language output (such as

assembly or machine code) from a high-level language input. It is kind of a computer application
that converts instructions written in a programming language into machine code (a binary 0- and
1-bit language that a computer processor can comprehend). The machine code is subsequently
processed by the computer to complete the associated tasks.

Code Completion: Some IDEs consist of automated code completion technologies that can
intelligently recognize and insert common code components, minimizing the possibility of
mistakes and defects and saving developers time when acquiring code.

Programming Language Support: IDEs usually have been built to interact with a single
programming language, however some may support multiple languages. When considering
IDEs, it is fundamental to consider the programming languages you want to utilize (Allaire,
2012).

IDENTIFYING AND SOLVING ANY LOGICAL ERRORS

Logical mistakes might appear throughout the development process when the code fails to
produce the expected outcomes or operates in an unforeseen way. Logical errors can be
identified and corrected by adjusting the algorithm or making the required modifications to the
code through investigating the code and the values of variables at various stages. The calculate
Average function in this code computes the average of an array of values. Although there exists a
logic error in the average computation. It fails to manage the scenario when the value of the
count parameter is identical to zero, which could arise if the array is null (JavatPoint, 2021).

Here's an example to identify any logical errors

Page 34
 PROGRAMMING

Figure 29 Logical Errors

The calculate Average function in this code computes the average of an array of values.
Although there exists a logic error in the average computation. It fails to manage the scenario
when the value of the count parameter is identical to zero, which could arise if the array is null.

To address this issue, we must include a condition that checks if count is larger than zero before
conducting the division operation.

Page 35
 PROGRAMMING

Figure 30 Solving the error

We added an if statement to the revised code to ensure if the count is larger than zero before
executing the division operation to determine the average. If count is 0, the division operation
cannot be performed to avoid dividing by zero.

Debugging program errors

The debugging tools provided by the IDE might be utilized in order to efficiently debug program
errors including runtime or syntax issues. These tools suggest error messages, stack traces, and
other diagnostics that assist in finding and identifying the fault's source (JavatPoint, 2021).

Here's the example of debugging program errors

Page 36
 PROGRAMMING

Figure 31 error in program

The logical mistake was present in the original code in the recursive call to the factorial function.
Instead of decrementing n by one, it was accidentally increased by one. As a result, an endless
recursion and inaccurate factorial computation occurred.

The debugged one is

Figure 32 Debugged program code

Page 37
 PROGRAMMING

Activity 3

Integrated Development Enviroment

An IDE, or Integrated Development Environment, is a software application that combines the
many tools needed to build and test software into a single program. IDEs integrate functions such
as software editing, building, testing, and packaging. IDEs are meant to include all programming
processes in a single application, which can increase software developer productivity by
standardizing the development process and arranging the required capabilities for software
development in the UI. IDEs can also boost developer productivity by shortening installation
times and expediting programming operations. Developers must pick, deploy, integrate, and
maintain all of these technologies independently if they do not use an IDE (Allaire, 2012).

IDE chosen for my project

Figure 33 IDE chosen for project

Apache NetBeans is the chosen IDE for my project. Apache NetBeans is a flexible and durable
Integrated Development Environment (IDE) capable of providing a full collection of software
development tools. It is an open-source IDE that supports a broad range of programming
languages, including Java, C/C++, PHP, and HTML. NetBeans presents an easy-to-use and
flexible interface that is suitable for both beginner and skilled developers. Its concentrates on
Java programming which enables advanced code editing, code refactoring, and smart code
completion. It additionally includes project management features, version control integration,

Page 38
 PROGRAMMING

and an integrated debugger for quick debugging and troubleshooting. On the whole, Apache
NetBeans is a fully featured and flexible IDE that provides the tools and capabilities required to
allow the development of the Best Fitness application, facilitating developers to produce efficient
and maintainable code while exploiting all the benefits of an integrated development
environment.

Debugging

Figure 34 Debugging

Debugging is the procedure of recognizing and fixing logical or syntactical errors in a computer
program. A debugger is software which assists in this entire process. A software developer could
employ a debugger to browse through a program's code and inspect variable values, to identify
errors. Software developers are able to debug a program using a wide range of techniques, such
as utilizing a debugger or exploring crash reports (Halipern & Santhanam, 2002).

Page 39
 PROGRAMMING

Process of Debugging

Figure 35 Process of Debugging

During the development stage, software programs are subjected to extensive testing, upgrading,
debugging, and maintenance. In general, defects and faults in software are frequently eliminated.
Debugging is the process of maintaining a software issue. The various steps involved in the
debugging process are mentioned below

Identifying the error: An inaccurate error identification could result in wasted time in
development. It is frequent for users to report production errors that are challenging to figure out,
and sometimes the information we receive is inaccurate. It is significant for identifying the actual
error (JavatPoint, 2021).

Find the error location: After successfully identifying the errors, you have to browse through the
code to figure out the specific location of the error. At this point, you should concentrate on
detecting the problem rather than understanding it (JavatPoint, 2021).

Analyze the error: In the third phase, analyzing the code and applying a bottom-up technique that
begins with the error location. This assists in recognizing the error. Analyzing an error has two
basic goals: identifying other faults around the issue and ensuring that any collateral damage is
not included into the fix (JavatPoint, 2021).

Page 40
 PROGRAMMING

Prove the Analysis: Once you've completed examining the original issue, you must check for any
other errors that might appear on the program. This stage includes developing automated tests for
those areas utilizing a test framework (JavatPoint, 2021).

Cover Lateral Damage: At this step, you must develop or gather all unit tests for the code that
will be changed. If you execute these unit tests now, they should all run (JavatPoint, 2021).

Fix & Validate: The final procedure involves fixing all errors while executing all test scripts to
verify if they all pass (JavatPoint, 2021).

Debugging features available in Apache NetBeans

Figure 36 Debugging Features in Apache NetBeans

The chosen IDE for this project, Apache NetBeans, suggests a wide range of strong debugging
options that can assist developers in figuring out and solving errors in their code. NetBeans
provides the following important debugging features:

Breakpoints
A breakpoint causes the debugger to stop functioning at a specific code location within the user's
application, providing them with control of the debugger. A breakpoint pauses the execution of a
program to make sure you can examine the program's internal functioning. Before you activate
the debugger, you have to setup a minimum of one breakpoint to pause execution of the program.
Set a breakpoint at the main () function's call by clicking on the line containing main ()'s left-
margin. In the left margin, a red circle or a triangle with an inverted shape appears, indicating

Page 41
 PROGRAMMING

that a breakpoint has been placed at that line. Breakpoints are by far the most popular form of
debug event utilized by developers (JavatPoint, 2021).

Figure 37 Breakpoints

Variable Inspection
Developers in Apache NetBeans have the capability to look over variable values during
execution, which means they can investigate variable values while the application is executing.
This capability is crucial for understanding the way the program functions and tracking variable
changes in value while the code is being executed. Overall, NetBeans' ability to monitor and
adjust variable values during runtime gives developers significant insights into the execution of
their code and aids in the identification and resolution of errors or unexpected behavior. It
provides a dynamic and interactive method to debugging, allowing developers to fine-tune their
code and guarantee that their applications provide the expected results (JavatPoint, 2021).

Exception handling
An exception is a type of error that can occur during the run-time of a program, interrupting its
usual flow. Java Exception Handling is a flexible and object-oriented method of handling
exception circumstances. Exceptions in Java can occur as an outcome of a variety of events,
including inaccurate information entered by the user, a hardware issue, network connection
failure, or a database server that is unreachable. Exception handling refers to the code that
describes what to do in certain exception conditions (JavatPoint, 2021).

In our code, we utilize the try-catch block for handling exceptions. To handle exceptions, try is
at the beginning of the block and catch is at the end of the try block. With a try block, we may
have multiple catch blocks. The try-catch block can also be nested. An argument of type
Exception is required by the catch block.

Page 42
 PROGRAMMING

Figure 38 Exception Handling

Stepping
In debugging, stepping refers to the process involving execution of code one instruction or line at
a time. The programmer is able to verify the current state of the program, machine, and relevant
data before and after a certain line of code is implemented. This permits the programmer to
determine the impact of each line or instruction separately and obtain insight into the executing
program's behavior (or misbehavior) (JavatPoint, 2021).

Page 43
 PROGRAMMING

Debugging Process for the secure and robust application

Figure 39 Debugging for secure application

Debugging is the procedure of recognizing and fixing logical or syntactical errors in a computer
program. A debugger is software which assists in this entire process. When developers recognize
bugs, they have to determine the errors in their newly generated code statements and attempt to
correct them. As a result, developers should see bugs as a learning opportunity. Debugging is a
vital ability for developers. The more time developers dedicate to debugging, the better they
achieve. Developers who debug regularly are certain to learn many beneficial skills. The more
adept engineers become at acquiring new skills, the easier it will be to correct flaws in their code.
Debugging promotes the developer minimize unnecessary and imprecise information.

The debugging process occurs immediately as the software code is developed. The procedure
then proceeds in phases as code gets combined with further programming components to result
in a software product. It promptly reports an in-error state. This permits for earlier identifying of
errors and renders the software development process stress-free and trouble-free.

It also delivers the most useful information concerning data structures and facilitates
understanding. Developers are able to create safer and more robust software that are less
susceptible to errors by utilizing debugging techniques and tools (Halipern & Santhanam, 2002).

Page 44
 PROGRAMMING

Activity 4

Integrated Development Enviroment

An IDE, or Integrated Development Environment, is a software application that combines the
many tools needed to build and test software into a single program. IDEs integrate functions such
as software editing, building, testing, and packaging. IDEs are meant to include all programming
processes in a single application, which can increase software developer productivity by
standardizing the development process and arranging the required capabilities for software
development in the UI. IDEs can also boost developer productivity by shortening installation
times and expediting programming operations. Developers must pick, deploy, integrate, and
maintain all of these technologies independently if they do not use an IDE (Allaire, 2012).

Figure 40 IDE

Use of a IDE in development process of the program

Algorithm for the Best Fitness Fee Calculator

Step 1: Start
Step 2: Initialize variables for athlete count, athlete details, and overall cost
Step 3: Prompt the user for the number of athletes
For each athlete:
a. Prompt for athlete details (name, training plan, weight, target weight, sauna
option, private coaching hours).
b. Calculate the training fees based on the selected options.
c. Calculate the weight comparison.
d. Display the athlete's details, itemized costs, total cost, and weight comparison.
e. Update the overall cost.
Step 4: Display the overall cost for all athletes
Step 5: End the program

Page 45
 PROGRAMMING

Flow chart for the Best Fitness Application

Figure 41Flowchart of Best Fitness

Screenshot of the best fitness fee calculator using IDE

Login Page
A login page is an essential component of software programs and websites that authenticates
users. It generally includes areas for entering a username/email and password, as well as a
"Remember Me" option, a "Forgot Password" link, a "Sign In" button, and a "Sign Up" link. It
affirms safe system access and shows error alerts as needed. The main objective of it is to
authenticate users and allow access based on valid credentials.

Page 46
 PROGRAMMING

Figure 42 Login Page of Best Fitness

Figure 43 Login Successful

When the correct information is entered, the login will be successful, granting the user access to
the system or application.

Page 47
 PROGRAMMING

Figure 44 Error in Login Page

If we enter the wrong password then the message saying wrong username and password occurs.

Best Fitness Fee Calculator

The Best Fitness Fee Calculator is a software solution established for a local fitness organization
that concentrates in providing training sessions to individuals of various ages and levels of
expertise. Users may enter personal information such as their customer’s name, training plan,
current weight, target weight category, sauna option, and hours of personalized coaching into the
training plan. Based on the presented information, the program computes monthly training
expenses, displays an itemized cost breakdown, and compares the present weight to the desired
weight. The program is intended to be user-friendly and versatile, allowing more athletes to be
registered.

Page 48
 PROGRAMMING

Figure 45 Best Fitness Application

Relationship between algorithm and source code

The success of the project is heavily dependent on the relationship between the algorithm and
program code. An algorithm is a logical step-by-step technique used to solve a specific issue or
job, whereas a program is software code that finally converts to machine code that the computer
can comprehend and execute to solve a given problem. An algorithm is more like a concept, a
means to solve a problem, but a program is more associated with the execution of one or more
tasks by a computer. An algorithm is a set of guidelines that are organized in a certain order to
address a problem. It is employed in a number of disciplines, including mathematics, computer
science, and logistics. Depending on the programming language being used, algorithms are
written using a specific syntax.

Computer programs are collections of instructions that instruct a computer how to execute a
particular task. Python, Java, C++, JavaScript, PHP, and Ruby are few of the programming

Page 49
 PROGRAMMING

languages that are used to create computer applications. Humans are able to comprehend these
languages with ease because of their design. Programs are able to handle user input, alter that
information, and produce data in a way that is valuable to people. Algorithms act as a roadmap
for programmers during the development of programs. They provide precise and step-by-step
instructions for writing code by concentrating on the solution. This makes it easier to translate
the algorithm into a specific programming language. Algorithms help programmers solve
problems and write optimized code, and they vary depending on the programming language
used. Algorithms are essential in simplifying and streamlining the process of creating programs
(Singh, 2023).

Evaluation of the use of an IDE to develop the application

The selected IDE i.e., Apache NetBeans is critical in the developing of the Best Fitness
application, ensuring several features and advantageous benefits that promoted in the design and
development process. Here is an assessment of the IDE's use:

Simple to use: NetBeans provides a platform for developers who wish to construct applications
efficiently and intelligently by providing comprehensive code analyzers, editors, and translators
that are compatible with the most recent Java technology. It facilitates developers to use
sophisticated Java 8 language components to update programs efficiently and quickly ( Walker,
2021).

Rich development capabilities: NetBeans has comprehensive static analysis capabilities which
permit users to avoid the expenditures associated with problematic code. There is also a
NetBeans Profiler function that offers developers with expert advice regarding enhancing
application performance and memory utilization. It also assists users in developing dependable
and adaptable Java SE, JavaFX, and Java EE applications ( Walker, 2021).

Support multiple languages: Apache NetBeans supports numerous programming languages,

including Java, C/C++, and Python, ensuring the you more versatility in selecting whichever
programming language is that's ideal for certain application components ( Walker, 2021).

Powerful Code Editor: The code editor of the system provides users with effective tools, code
templates, code generators, and coding advice for fast refactoring. Furthermore, users can
customize the system's capabilities with plugins and work with drag and drop tools for smart
development of GUI for PHP, JAVA SE, JAVA EE, Java ME, HTML5, and C/C++ ( Walker,
2021).

Page 50
 PROGRAMMING

Comparison of using IDE without using

The usage of an Integrated Development Environment (IDE) has been very essential in the
creation of the Best Fitness application. This IDE offered an extensive selection of features and
capabilities which greatly assisted with the implementation of the algorithm. While comparing
the algorithm written down with the source code itself, the Integrated Development Environment
(IDE) has provided a huge help in bridging the divide between the two. The IDE gave a
straightforward and user-friendly platform for creating, revising, and controlling the code. Its
features like syntax highlighting, auto-completion, and code formatting made sure that the code
has been very well-aligned with the logic stated in the algorithm. Furthermore, the IDE's
debugging capabilities facilitated efficient detection and fixing of any logical mistakes or bugs in
the source code. IDEs boost productivity for programmers by merging typical software
development operations such as modifying source code, generating executables, and debugging
into a single tool. For languages that require a compile or build step, IDEs can convert code
written in high-level languages to the specific object code for the chosen platform. The
specifications for these features can vary greatly depending on the language ( Walker, 2021).

Coding Standard
Coding standards are recommendations and guidelines for creating consistent, high-quality code.
Consider coding standards to be principles, plans, and best practices for writing cleaner, clearer,
and error-free code. These serve as an organized framework for software developers to create
complex, highly functional code. Coding standards guarantee that each line of code is written
uniformly, readably, and effectively. This helps to make the code more accessible to developers
to figure out and to interact with, enabling software of greater quality. Coding standards
guarantee the all developers agree to identified guidelines. As a consequence, even inexperienced
developers may easily grasp, debug, and then update the code (Moonen & Boogerd, 2008).

Role of Coding Standard

Improving the productivity of software development: Developers often dedicate a large chunk of
their time dealing with code quality issues that could have been prevented. Establishing coding
standards will assist the team in identifying the issues earlier on or even avoid them completely
(Moonen & Boogerd, 2008).

Consistency: Consistency is a requirement for successful collaboration and long-term viability.

Coding standards generate naming conventions, formatting styles, and methods for coding which
remain uniform throughout the codebase. This uniformity allows various engineers to interpret
and deal with the code with greater ease, contributing to improved cooperation and less
misunderstanding (Moonen & Boogerd, 2008).

Maintainability: Code maintainability is optimized by precisely defined coding standards. They

emphasize flexible, well-organized code, thereby making less complicated to maintain, change,

Page 51
 PROGRAMMING

and debug. Developers who implement consistent coding techniques may rapidly discover and
comprehend code parts, resulting in more rapid maintenance and less time spent on error
improvements or feature upgrades (Moonen & Boogerd, 2008).

Reusability: Coding standards recommend to reuse code. Developers provide code which is
more modular, detached, and independent of individual implementations by adhering to
predefined rules. This allows code components to be reused in other portions of the program or
in additional projects, saving development both money and time (Moonen & Boogerd, 2008).

Evaluation of Coding Stadard

Necessary for individuals

Coding standards provide as a foundation for code reviews and peer input. It is simpler to
examine and offer suggestions for code when developers implement coding standards. It enables
helpful criticism, improvement concepts, and the identification of future issues. Individuals can
utilize this to improve their skills in coding. Coding standards confirm that code is written
consistently and in a structured way. This promotes readability and makes it easier for
individuals to figure out and maintain the code. Following coding standards allows flexible and
reusable programming. Developers construct code that is readily understood, reused, and shared
between projects by following to established standards and practices. This saves time and effort
by avoiding the need for remaking the design or develop code from the very beginning up
(Zhang & Mao, 2019).

Necessary for teams

Coding standards assure everyone on the team follows an identical coding style and structure.
Because of this uniformity, the source code becomes simpler to understand and read for
everyone involved. When team members need to work on separate portions of the codebase or
collaborate on similar code, it minimizes confusion and shortens the learning process. Coding
standards serve as a foundation for code reviews within the team. Team members may review
adherence to standards for coding during code reviews, making certain the code is well-
organized, follows guidelines, and satisfies quality guidelines. Code reviews assist in the
recognition of possible errors, enhancing the level of code quality, and enabling the process of
knowledge exchange within the team. Teams can collaborate effectively which can provide the
software of superior quality and accelerate their development processes by emphasizing and
maintaining the coding standards (Zhang & Mao, 2019).

Page 52
 PROGRAMMING

References
Debnath, M., 2019. Top 10 Java Coding Standards. [Online]
Available at: https://www.developer.com/design/top-10-java-coding-guidelines/
[Accessed 05 06 2023].

Walker, A., 2021. What Is an IDE? How It Helps Developers Code Faster. [Online]
Available at: https://www.g2.com/articles/ide
[Accessed 05 06 2023].

Agrawal, S., 2023. Characteristics of Object Oriented Programming. [Online]

Available at: https://www.codingninjas.com/codestudio/library/characteristics-of-object-
oriented-programming
[Accessed 4 May 2023].

Allaire, J., 2012. RStudio: integrated development environment for R. Boston, MA, 770(394), pp.
165-171.

Althar, 2021 . Building intelligent integrated development environment for IoT in the context of
statistical modeling for software source code. Multimedia Technologies in the Internet of Things
Environment, pp. 95-115.

CodeAcademy, 2023. Code Academy. [Online]

Available at: https://www.codecademy.com/article/what-is-an-ide
[Accessed 04 06 2023].

Collegenp, 2023. Programming Paradigms and their Definitions. [Online]

Available at: https://www.collegenp.com/article/programming-paradigms-and-their-definitions/
[Accessed 10 5 2023].

Halipern, B. & Santhanam, P., 2002. Software debugging, testing, and verification. IBM Systems
Journal, 41(2023), pp. 4--12.

Hemmendinger, D., 2022. computer programming language. [Online]

Available at: https://www.britannica.com/technology/computer-programming-language
[Accessed 05 06 2023].

Jaiswal, K., 2022. Sarthaks. [Online]

Available at: https://www.sarthaks.com/2319663/explain-program-execution-process-in-c

Page 53
 PROGRAMMING

JavatPoint, 2021. Debugging. [Online]

Available at: https://www.javatpoint.com/debugging
[Accessed 05 06 2023].

Manelli, L., 2020. Implementation of Algorithms in the C Programming Language. In:

Introducing Algorithms in C: A Step by Step Guide to Algorithms in C . s.l.:Apress, Berkeley,
CA.

Moonen, L. & Boogerd, c., 2008. Assessing the value of coding standards: An empirical study.
In: 2008 IEEE International conference on software maintenance. Beijing, China: IEEE, pp.
277--286.

Pham, T., 2019. Saigon Technology. [Online]

Available at: https://saigontechnology.com/blog/6-stages-for-software-development-procedure-
you-need-to-know
[Accessed 05 06 2023].

Shiverware, 2019. 7 Steps of App Development. [Online]

Available at: https://shiverware.com/app-development/7-steps-app-development.html
[Accessed 04 06 2023].

Singh, A. K., 2023. Techow99. [Online]

Available at: https://www.techow99.com/what-is-the-difference-between-an-algorithm-and-a-
program/
[Accessed 2023].

Sinha, P., 2021. Functional vs. Procedural vs. Object-Oriented Programming. [Online]
Available at: https://scoutapm.com/blog/functional-vs-procedural-vs-
oop#h_25645808410001614878426854
[Accessed 03 05 2023].

Study.com, 2003. How to Write a Program: Coding, Testing & Debugging. [Online]
Available at: https://study.com/academy/lesson/how-to-write-a-program-coding-testing-
debugging.html
[Accessed 04 06 2023].

Upadhyay, S., 2023. simpli learn. [Online]

Available at: https://www.simplilearn.com/tutorials/data-structure-tutorial/what-is-an-
algorithm#:~:text=An%20algorithm%20is%20a%20step,more%20than%20one
%20programming%20language.
[Accessed 06 05 2023].

Yasi, 2022. Stackoverflow. [Online]

Available at: https://stackoverflow.com/questions/74426618/what-are-the-relationships-among-

Page 54
 PROGRAMMING

procedural-object-oriented-and-event-driven-pa
[Accessed 4 5 2023].

Zhang, T. & Mao, S., 2019. An overview of emerging video coding standards. GetMobile:
Mobile Computing and Communications, 22(2023), pp. 13--20.

Page 55