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 ALIJA ACHARYA

STUDENT ID

UNIT AND ASSIGNMENT DETAILS

UNIT TITLE Programming

UNIT NUMBER H/618/7388

ASSIGNMENT Introduction to Algorithms and programming with an IDE

TITLE

ISSUE DATE 26/03/2023 DUE DATE 14/06/2023

ASSESSOR Sandeep Pokharel

NAME

ESTIMATED
WORD LENGTH

SUBMISSION

HAND IN DATE 2023/06/

DECLERATION 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
 Programming

Table of Contents
List of Figures...............................................................................................................................................3
INTRODUCTION...........................................................................................................................................4
PROGRAMMING PARADIGM..................................................................................................................4
TYPES OF PARADIGMS................................................................................................................4
PROCEDURAL PROGRAMMING..............................................................................................................5
CHARACTERISTICS OF PROCEDURAL PROGRAMMING...........................................................................6
OBJECT-ORIENTED PROGRAMMING.......................................................................................................7
EVENT-DRIVEN PROGRAMMING..........................................................................................................12
CHARACTERISTICS OF EVENT DRIVEN PROGRAMMING..............................................13
INTERRELATIONSHIP AMONG PROCEDURAL PROGRAMMING, OBJECT-ORIENTED PROGRAMMING
AND EVENT DRIVEN PROGRAMMING PARADIGMS.................................................................................14
DECLARATIVE PARADIGM:....................................................................................................................15
RELATIONSHIP BETWEEN PROGRAMMING PARADIGMS:.......................................................................15
EVALUATION OF SOURCE CODE OF AN APPLICATION.............................................................................16
ALGORITHMS:...........................................................................................................................................17
CHARACTERISTICS OF ALGORITHMS.....................................................................................................17
PROS OF ALGORITHMS.............................................................................................................18
CONS OF ALGORITHM:..............................................................................................................18
FLOWCHART..............................................................................................................................................19
PROCESS OF BUILDING AN APPLICATION.................................................................................................19
INTEGRATED DEVELOPMENT ENVIRONMENT (IDE):................................................................................22
PREFERRED IDE (Visual Studio Code)....................................................................................................22
CONVERTING THE ALGORITHM INTO A WORKING PROGRAM................................................................23
SOURCE CODE FOR IT:...............................................................................................................................24
ANALYSIS OF RELATIONSHIP BETWEEN ALGORITHM AND PROGRAM CODE..........................................27
CHALLENGES IN CONVERTING THE ALGORITHM INTO PROGRAM CODE................................................28
APPLYING ALGORITHMS USING THE IDE..................................................................................................30
ALGORITHM:.........................................................................................................................................30
FLOWCHART..........................................................................................................................................31
PSEUDO-CODE:......................................................................................................................................31
 Programming

IDENTIFYING AND SOLVING ANY FAULTS IN THE ORIGINAL ALGORITHM:..............................................33

IDENTIFYING ERROR:............................................................................................................................33
RESOLVING ERROR:...............................................................................................................................33
DEBUGGING ANY ERROR IN THE PROGRAM:...........................................................................................34
SECTION-III................................................................................................................................................36
INTRODUCTION.........................................................................................................................................36
IDE CHOOSEN FOR THE PROJECT..............................................................................................................36
DEBUGGING..............................................................................................................................................38
DEBUGGING FEATURES AVAILABLE IN VS COSE.......................................................................................40
PROCESS OF DEBUGGING.........................................................................................................................41
DEBUGGING FOR THE SECURE AND ROBUST APPLICATION....................................................................44
SECTION-IV................................................................................................................................................45
INTRODUCTION.........................................................................................................................................45
ASSESSMENT OF IMPLEMENTATION OF THE ALGORITHM DESIGNED FOR BEST FITNESS......................45
EVALUATION OF THE USE OF THE IDE CHOOSEN TO DEVELOP THE SOFTWARE.....................................47
IMPACT OF NOT HAVING ACCESS TO THE IDE..........................................................................................48
ROLES AND PURPOSE OF CODING STANDARDS IN SOFTWARE DEVELOPMENT.....................................49
CONCLUSION.............................................................................................................................................51
REFERENCES..............................................................................................................................................52
 Programming

List of Figures
Figure 1 PROGRAMMING PARADIGM..........................................................................................................5
Figure 2 TYPES OF PROGRAMMING PARADIGM..........................................................................................6
Figure 3 PROCEDURAL PROGRAMMING......................................................................................................7
Figure 4 Example of PROCEDURAL PROGRAMMING...................................................................................7
Figure 5 OBJECT ORIENTED PROGRAMMING..............................................................................................9
Figure 6 Example of OBJECT ORIENTED PROGRAMMING............................................................................9
Figure 7Example of OBJECT ORIENTED PROGRAMMING...........................................................................10
Figure 8 Example of EVENT-DRIVEN PROGRAMMING...............................................................................13
Figure 9 Example of EVENT-DRIVEN PROGRAMMING...............................................................................13
Figure 10 EVENT DRIVEN PROGRAMMING................................................................................................14
Figure 11 INTERRELATIONSHIP OF DIFFERENT PROGRAMMING PARADIGMS..........................................16
Figure 12 Flow Chart..................................................................................................................................20
Figure 13 SDLC...........................................................................................................................................21
Figure 14 VS code......................................................................................................................................24
Figure 15 SOURCE CODE FOR IT.................................................................................................................25
Figure 16 SOURCE CODE FOR IT.................................................................................................................26
Figure 17 SOURCE CODE FOR IT.................................................................................................................27
Figure 18 Fitness Calculation.....................................................................................................................28
Figure 19 Flowchart...................................................................................................................................32
Figure 20 PSEUDO-CODE...........................................................................................................................33
Figure 21 Example of PSEUDO-CODE.........................................................................................................33
Figure 22 Example of PSEUDO-CODE.........................................................................................................33
Figure 23 IDENTIFYING ERROR..................................................................................................................34
Figure 24 RESOLVING ERROR.....................................................................................................................35
Figure 25 DEBUGGING ANY ERROR IN THE PROGRAM..............................................................................36
Figure 26 IDE CHOOSEN FOR THE PROJECT...............................................................................................37
Figure 27 DEBUGGING...............................................................................................................................39
Figure 28 DEBUGGING FEATURES AVAILABLE IN VS COSE.........................................................................41
Figure 29 PROCESS OF DEBUGGING..........................................................................................................42
Figure 30 DEBUGGING FOR THE SECURE AND ROBUST APPLICATION.......................................................45

ACHARYA ALIJA (BSC.IT / 1st sem) 1

 Programming

INTRODUCTION
PROGRAMMING PARADIGM
The writing style and method of arranging the computer code make up the entire paradigm of
programming. Each paradigm promotes a certain scheme for arranging the software code.
Different programming languages are used to create the computer programs. Every programming
language has a distinctive programming approach that carries out a certain programming
paradigm.

Figure 1 PROGRAMMING PARADIGM

TYPES OF PARADIGMS
The programming paradigms can be categorized into two different types. Such as:

 Imperative paradigm
 Declarative paradigm
1.1 Imperative paradigm: The imperative paradigm is said to be command driven. The
program code in imperative paradigm programming language directs the program
execution as sequence of statements executed one by one. The imperative style program

ACHARYA ALIJA (BSC.IT / 1st sem) 2

 Programming

consists of set of program statements. Each statement directs the computer to perform
specific task.

Figure 2 TYPES OF PROGRAMMING PARADIGM

PROCEDURAL PROGRAMMING
Data and processes are kept distinct in Procedural Programming, with the instructions
influencing the data. These procedures are a series of statements that convert inputs to
outputs . Procedural designers rely on a kernel notion that effectively specifies a top to
the design (White, 2005).

ACHARYA ALIJA (BSC.IT / 1st sem) 3

 Programming

Figure 3 PROCEDURAL PROGRAMMING

Figure 4 Example of PROCEDURAL PROGRAMMING

CHARACTERISTICS OF PROCEDURAL PROGRAMMING

The characteristics of procedural programming are:

ACHARYA ALIJA (BSC.IT / 1st sem) 4

 Programming

1) A huge program is divided into manageable operations or functions: This reduces

code duplication, which enhances code readability and maintainability.
2) Different functions are able to exchange data via global variables: Because functions
are totally segregated, if we want to share data, we must declare it in the upper scope.
3) Function may alter global data: Because global data is transferred from function to
function, global data in function chains may be altered during the transformation.
4) Top-down methodologies: As previously said, procedural programming employs a
top-down technique, with workflow moving from top to bottom.
Uses:

 Procedural programming languages divide the programming effort into a number

of processes (also known as subroutines or functions). Each procedure performs a
particular function and is called via the main program.
 It is also appropriate for systems that are very simple and do not involve many
different interacting sub-systems.

OBJECT-ORIENTED PROGRAMMING
An object-oriented program is composed of interacting objects. Each object has a certain
function. Each object offers a benefit or performs an action that other members of the
community can use. OOP languages, such as Java, organize data and methods under a single
identifier known as an object. Objects often have operations which alter their state and can,
in turn, invoke actions on other objects. (Budd, 2008).

ACHARYA ALIJA (BSC.IT / 1st sem) 5

 Programming

Figure 5 OBJECT ORIENTED PROGRAMMING

Figure 6 Example of OBJECT ORIENTED PROGRAMMING

ACHARYA ALIJA (BSC.IT / 1st sem) 6

 Programming

Figure 7Example of OBJECT ORIENTED PROGRAMMING

Characteristics of object-oriented programming

The characteristics of object-oriented programming are:

 Message passing: An object-oriented program is made up of a collection of objects

that communicate with one another. A message for an object is a request for the
execution of a procedure, and so will execute a function (procedure) in the responding
object that provides the desired outcome. Message passing includes providing the
name of the object, the name of the function (message), and the information to be
transmitted.
 Dynamic binding: Binding is the process of connecting a procedure call code that will
be executed in accordance with the call. Dynamic binding means that the code
attached to a specific procedure call is unknown until the call is made at run-time. It
is connected with a polymorphic reference based on the dynamic type of that
reference.
 Class: A class is a group of objects that have similar attributes for data and some
program parts. A class in C++ is a new data type that contains member variables and
member functions that operate on the variables. A class can convert an object’s whole
set of data and code into a user-defined data type. Objects are class variables. Once a
class has been defined, we can construct an unlimited number of objects from that
class.

ACHARYA ALIJA (BSC.IT / 1st sem) 7

 Programming

When a class is created, objects are produced as follows:

<class name><object name>
If employee is declared as a class, then the statement employee manager will generate
an object manager for the class employee.
 Object: objects are the basic run-time elements in an object-oriented system. They
can represent a person, a location, a bank account, a table of data, or any other item
that the computer must handle. The essential principle underlying the object-oriented
method id to merge data and function into a single unit, which is referred to as an
object. The term object refers to a mix of data and program that represents real-world
thing.
When a program is run, the objects communicate with one another by sending
messages. Each object contains data as well as code for manipulating the data as well
as code for manipulating the data (Anon., n.d.).

Object: student
DATA
Name
Date Of Birth
Marks
FUNCTION
Total
Average
Display

 Abstraction: The act of portraying important traits without giving background details
or explanation is referred to as abstraction. Classes are defined as a set of attributes
such as size, weight, and cost, as well as methods to operate on these attributes. They
include all of the necessary properties of the item to be constructed. The
characteristics are referred to as data members since they contain data, and the
function that operate on these data are referred to as member functions. Because

ACHARYA ALIJA (BSC.IT / 1st sem) 8

 Programming

classes employ the concept of data abstraction, they are referred to as abstract data
types (ADT).
 Inheritance: the technique by which one class inherits the characteristics of another is
known as inheritance. It enables the creation of a hierarchy of classes, form the most
generic to the most particular. When one class inherits from another, the inherits class
is referred to as the base class. The class that inherits is known as the derived class. In
most cases, the inheritance process starts with the creation of a base class. The base
class specifies all of the characteristics that are shared by all derived classes. The idea
of inheritance in OOPs gives the concept of reusability.
 Encapsulation: One of the distinguishing features of encapsulation is that it restricts
accessibility to a class’s attribute data and the specifics of it’s implementation. To
enforce these constraints, OOP languages like as Java, C++, and C# utilize access
modifiers that indicate the type of access authorized at the class and member levels.
The particular modifiers utilized by an OOP language and the rules that govern them
– vary from language to language, although most of them accept at least the following
three modifiers:
 Public: The class or member can be accessible from another class in the software
program or from inside the same class.
 Private: The class or member can only be accessed from within the class. It is not
accessible to any other classes. In general, programming languages limit how the
private access modifier can be used at the class level.
 Protected: The class or member can only be accessible within the class or its
descendant classes. Other classes cannot access it. Protected access modifiers are
typically restricted to the class level by programming languages.
 Polymorphism: The terms “polymorphism” and “morphism” are derived from the Greek
word “poly” and “morphism”. “poly” means “many”, and “morphism” means “form”’
therefore there are numerous forms. Polymorphism refers to the ability to exists in a
variety of forms. For example, an operation may behave differently in different contexts.
The behaviour is determined on the type of data utilized in the operation.
Various ways to achieving polymorphism in C++ program are:
 Function overlapping

ACHARYA ALIJA (BSC.IT / 1st sem) 9

 Programming

 Operator overlapping

EVENT-DRIVEN PROGRAMMING

Figure 8 Example of EVENT-DRIVEN PROGRAMMING

ACHARYA ALIJA (BSC.IT / 1st sem) 10

 Programming

Figure 9 Example of EVENT-DRIVEN PROGRAMMING

ACHARYA ALIJA (BSC.IT / 1st sem) 11

 Programming

The event-driven programming paradigm is a design for software philosophy in which the
processing of events is the core focus of development. Events in the context of interactive
software applications frequently reflect messages from other agents or procedures, sensor
readings, or user actions (Lalejini, 2018).

Figure 10 EVENT DRIVEN PROGRAMMING

CHARACTERISTICS OF EVENT DRIVEN PROGRAMMING

The key characteristics of event driven programming are:

1) Event handlers: The event handler is a piece of code that is supposed to be executed in
response to an event. Assume that you would like a message to appear when a button is
pressed: the event is the button being clicked, and the event handler is the code that
causes the message to appear.
2) Trigger function: Trigger functions serve as the glue that connects events with event
handlers.
3) Event loops: The event loop is a queue data structure that stores a list of events as well as
any relevant data (for example, the x and y positions of a mouse click).
Messages are deleted from this queue in the order in which they are received, so the first
task put to the list is the first task removed and processed.

ACHARYA ALIJA (BSC.IT / 1st sem) 12

 Programming

Uses:

It is used in different three cases:

 When creating games in which a collection of objects performs control flow.
 It is not recommended to create service processes while developing server
applications for many reasons.
 When creating user interfaces, both graphical and textual.

INTERRELATIONSHIP AMONG PROCEDURAL PROGRAMMING, OBJECT-

ORIENTED PROGRAMMING AND EVENT DRIVEN PROGRAMMING PARADIGMS
A program and its divisions are defined as a set of stages in procedural programming.
Declarative programs, on the other hand, attempt to explain the outcome without respect for the
processes necessary to computerize it, instead using provide a definition or designation of the
outcome that is wanted.

Object-oriented programming is a method of arranging code based on encapsulation, inheritance,

replacement, programming to interfaces, and other principles. Object-oriented programming are
typically procedural in nature.

Event-driven programming entails writing event handling methods and relying on the underlying
system’s fundamental event loop. You can avoid the difficulty of building a custom event loop
by taking advantage of several libraries that already operate with the system-provided event loop.
Event-driven programs are frequently written in an object-oriented paradigm; however this is not
always the case.

These three groups are thus not technically hierarchically related, although they are typically
nested within each other in common usage (vandermeer, n.d.).

ACHARYA ALIJA (BSC.IT / 1st sem) 13

 Programming

Figure 11 INTERRELATIONSHIP OF DIFFERENT PROGRAMMING PARADIGMS

DECLARATIVE PARADIGM:
Declarative paradigm is defined as the program which specify the outcomes you want a program
to achieve without defining its control flow. It is ultimately up to the programming language’s
implementation and the compiler to determine how to achieve the desired results. The focuses on
the outcomes rather than the execution process. In other words, using declarative code pushes
you to consider what you want from your application first. Defining this allows you to write
more expressive and explicit code. Some examples are SQL, Miranda, Prolog, Lisp, Many
markup languages (e.g., HTML).

RELATIONSHIP BETWEEN PROGRAMMING PARADIGMS:

The three programming paradigms- procedural, Object-Oriented, and event-driven-each provide
a distinct way to arranging and structuring code; they are all interconnected. Although
differences in their methods and approaches of deployment, all of them attempt to improve the
structure, visibility, and durability of code.

Procedural programming is the concept of an operation or procedure that can be formed up of a

series of stages that are performed in a certain order. This programming style focuses on

ACHARYA ALIJA (BSC.IT / 1st sem) 14

 Programming

breaking down a challenge into phases and performing those steps sequentially. Functions are
utilized to generate code that is reusable that may be reused throughout the application.

Object-oriented programming (OOP) seeks to design models which may collaborate with others
in order to perform certain tasks. Instances of those classes are the classes that describe the
features and behaviors of the objects. OOP enables for inheritance, polymorphism, and data and
behavior encapsulation.

Event-driven programming is a programming paradigm that draws attention to on the existence

of events, including interactions between users with a graphical user interface or sensor input. It
is built on the concept of callbacks, which are referred to as event handlers, which are procedures
that are executed in fulfillment of events. Event-driven programming allows for the creation of
more engaging and responsive user interfaces.

Every programming paradigm has its own approach to code structure and problem resolution.
Event-driven programming is concerned with overseeing events in order to create flexible user
interfaces, procedural programming is concerned with tackling problems by breaking them down
into phases and object-oriented programming is concerned with generating objects with specified
properties and traits.

EVALUATION OF SOURCE CODE OF AN APPLICATION

Checking a product item and task the board are fundamental exercises for accomplishing
inconvenience free programming improvement. Checking changes that have a huge effect, then
again, is normally a troublesome undertaking to do in light of the fact that few out of every odd
designer knows all about the whole source code exhaustively. Based on component rank, we
propose a metric for changes to source code in this study. Software's components and
applications evolve with it. The part rank additionally moves in light of changes in part use-
relationship. As an indicator of the impact of a source code update that is still in development,
we use the degree that reflects the change in component rank. We utilized the measurement to
open-source projects and exhibited that it is viable for deciding refactoring action or fundamental
updates. We additionally talk about how the measurement could assist with process the
executives (Inoue, 2006).

ACHARYA ALIJA (BSC.IT / 1st sem) 15

 Programming

ACHARYA ALIJA (BSC.IT / 1st sem) 16

 Programming

SECTION-II

ALGORITHMS:
An Algorithm is the step-by-step description of the procedure written in human understandable
language for solving given problem. It is an effective procedure for solving a problem in a finite
number of steps. There are four basic algorithms to execute an operation which are discussed
below:

1) sorting algorithms: Sorting is the process of rearranging a list of items such that they are
in the proper order, as handling items in a specific order is more effective than handling
randomly ordered items. For instance, bubble sort, insertion sort, selection sort, etc (Al-
Kharabsheh, 2013).
2) Searching algorithm: A method for locating a certain element's location inside a group of
elements. Example linear search, binary search, etc (Zabinsky, 2009).
3) Recursive Algorithms: a process where an issue is broken down into smaller sub-
problems and then those smaller sub-problems are solved recursively. for instance
Fibonacci sequence, Tower of Hanoi, etc (Burgin, 2006).
4) Dynamic Programming Algorithm: A problem-solving method that divides a problem
into smaller complications and saves the solutions for every sub-issue to avoid
precomputation. For example, longest common subsequence, knapsack problem, etc
(Zhang, 2002).
CHARACTERISTICS OF ALGORITHMS
The following are the characteristics of algorithms:

 Input and Output: An algorithm receives input and creates output based on the stated
inputs.
The procedure is completed after a limited number of steps.
 Deterministic: The algorithm produces the same output for the same input regardless of
the execution environment.
 Correctness: The algorithm must solve the issue successfully and accurately for all
potential inputs.
 Efficiency: The approach takes the least amount of time and memory to do its purpose.

ACHARYA ALIJA (BSC.IT / 1st sem) 17

 Programming

 Modularity: Because of its modularity, the approach may be broken into more
manageable, smaller components or subroutines.
 Well-defined: The steps in the process should be distinct, precise, and unambiguous.
 Scalability: The approach can handle larger sized inputs without noticeably affecting
performance.
 Independence: Each step in the algorithm acts independently of the subsequent ones that
come after it.
PROS OF ALGORITHMS
Algorithms have the following benefits:

 Efficiency
 Reusability
 Scalability
 Clarity
 Standardization
 Reproduction
 Optimization
 Problem solving
 Innovation
CONS OF ALGORITHM:
Some of the cons of algorithm are:

 It might be challenging to include complicated tasks into algorithms

 Complex logic algorithm assessment can be difficult.
 Branching and looping in algorithms might be difficult to express.
Example:

Step 1: Start

Step 2: Declare valuable num.

Step 3: Request a number from the user.

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

ACHARYA ALIJA (BSC.IT / 1st sem) 18

 Programming

Print: num is an Even Number

Else

Print: num is an Odd Number

Step 5: End.

FLOWCHART
A flowchart is a diagram that depicts the operation of an algorithm. In the flow chart, symbols
are used to depict a comprehensible representation of the algorithm. I created a flowchart to
assist folks visualize the concept, which makes it much easier to understand how it works.

Figure 12 Flow Chart

ACHARYA ALIJA (BSC.IT / 1st sem) 19

 Programming

PROCESS OF BUILDING AN APPLICATION

People are growing increasingly reliant on technology, which is rapidly evolving to satisfy all of
their needs. Furthermore, as the requirement for computer programs grows, the importance of
generating software grows by the day. In reality, practically every piece of technology we use is
powered by some form of computer. Client data is collected in order to produce software of the
highest quality. After collecting the requirements, they are analyzed, and a decision is made on
where the program will run.

Figure 13 SDLC

The sequential phases of software development are as follows:

I. Requirement gathering:
At this stage, the project's requirements are gathered and reviewed in order to grasp the
application's scope, objectives, and capabilities.
II. System design:
Throughout this period, the system architecture, database structure, graphical user
interface, and other technical components of the software are clarified.
III. Development:
Through this stage of the process, the actual coding and programming of the software
takes place. Developers create code based on the design specifications.
IV. Testing:

ACHARYA ALIJA (BSC.IT / 1st sem) 20

 Programming

The software is thoroughly tested to identify and repair any faults, flaws, or difficulties.
There are numerous testing methodologies utilized, such as unit testing, integration
testing, and system testing.
V. Deployment:
The application is rigorously tested to identify and repair any faults, flaws, or difficulties.
Unit testing, integration testing, and system testing are examples of testing techniques.
VI. Maintenance:
Eventually installation, the application is maintained and updated as needed.
Improvements, bug fixes, and regular updates are done to keep the application running
and up to date.
Algorithm for BEST FITNESS program
Step1: start the program and display a welcome message.
Step2: initialize variables to store customer information, such as customer name, training
plan, current weight, target weight category, sauna option, and hours of private coaching.
Step3: prompt the user to enter the customer’s name.
Step4: prompt the user to select a training plan from the available options and store the
selection.
Step5: prompt the user to enter the current weight in kilograms and validate the input to
ensure it is a positive number.
Step6: prompt the user to select the target weight category and store the selection.
Step7: ask the user if they want to add the sauna option, and store the choice.
Step8: if the user selects to add the sauna option, calculate the extra cost and add it to the
total cost.
Step9: prompt the user to enter the number of hours of private coaching and validate the
input to ensure it is a positive integer.
Step10: calculate the training fees based on the selected training plan and the number of
weeks in a month (assumed to be four).
Step11: calculate the total cost by adding the training fees and any additional costs (sauna
option)
Step12: compare the current weight with the target weight catef=gory and determine if
the customer needs to lose, maintain, or gain weight.

ACHARYA ALIJA (BSC.IT / 1st sem) 21

 Programming

Step13: Display the customer’s name, itemized list of costs for the month, total cost, and
the comparison between current and target weight.
Step14: Ask the user wants to enter information for another customer. If yes, go back to
step3; otherwise, end the program.

INTEGRATED DEVELOPMENT ENVIRONMENT (IDE):

The term "Integrated Development Environment" (IDE) refers to a piece of software developed
by Arduino.cc that is primarily used for editing, compiling, and uploading code to the Arduino
device. Almost all Arduino modules are compatible with this open source and widely available
software. Accessible to install and start building the code on the go (Fezari, et al., 2018).

Integrated development environments (IDEs) are programs that aid in the creation of other
programs. One of the key advantages of an IDE, which is designed to integrate all programming
jobs in one application, is that it provides a central interface with all the tools a developer
requires, including:

 Code editor: These editors, which are designed for writing and editing source code,
differ from text editors in that they seek to either simplify or improve the process of
writing and editing code for developers.
 Compiler: Compilers convert source code written in a human-readable/writable
language into computer-executable code.
 Debugger: Debuggers are utilized during testing to assist developers in debugging
application applications.
 Build automation tools: These can assist to save time by automating frequent
development processes.
 Class browser: It is used to investigate and refer to the attributes of an object-oriented
class hierarchy.
 Object browser: Inspects items created in a running application program.
 Class hierarchy diagram: Visualizes the structure of object-oriented programming code
for developers (Anon., n.d.).

ACHARYA ALIJA (BSC.IT / 1st sem) 22

 Programming

PREFERRED IDE (Visual Studio Code)

Visual Studio Code was used as the IDE for building the application. It is a fast and versatile
source code editor. It has become highly regarded among developers because to its
functionality, operation, and broad selection of qualities.

Figure 14 VS code

CONVERTING THE ALGORITHM INTO A WORKING PROGRAM:

The Best Fitness Program, a web-based application, allows clients to figure out the cost of a
fitness training program based on a range of input inputs. The application employs a simple
algorithm to request customer data, do the calculations, contrast weight values, and publish
the findings.

ACHARYA ALIJA (BSC.IT / 1st sem) 23

 Programming

SOURCE CODE FOR IT:

Figure 15 SOURCE CODE FOR IT

ACHARYA ALIJA (BSC.IT / 1st sem) 24

 Programming

Figure 16 SOURCE CODE FOR IT

ACHARYA ALIJA (BSC.IT / 1st sem) 25

 Programming

Figure 17 SOURCE CODE FOR IT

ACHARYA ALIJA (BSC.IT / 1st sem) 26

 Programming

Figure 18 Fitness Calculation

The website is built with HTML for arrangement and set up, CSS for style, and Java Script for
dynamic functionality. The program provides an intuitive user experience and provides the
required computations to provide accurate cost information based on the supplied inputs by
separating the way it is shown (HTML/CSS) from the logic.

ANALYSIS OF RELATIONSHIP BETWEEN ALGORITHM AND PROGRAM CODE

The software is built using HTML for architecture and design, CSS for style, and Java Script for
dynamic functionality. The program has a user-friendly interface and does the necessary
computations to provide correct cost information depending on the inputs provided by separating
the way it is shown (HTML/CSS) from the logic.

The analisation of relationship between the algorithm and program code are as follow:

Correspondence of Steps: The specified phases of the algorithm must be appropriately mirrored
in the program code. Every step of the algorithm must be reduced to one line of code that
performs the intended action.

ACHARYA ALIJA (BSC.IT / 1st sem) 27

 Programming

Data Handling and Manipulation: The algorithm specifies the desired outputs, processing
technique, and the information inputs. The software code must correctly handle the given data,
process it using the defined algorithm steps, and produce the expected outputs.

Control Flow and Control Structure: The algorithm may employ structure-based control features
such as conditionals (if-else statements), loops, and branching directives. These control
structures should be implemented into the program code to guarantee proper functioning and
decision making based on the demands of the algorithms.

Error and Exception Handling: The algorithm may include methods for dealing with potential
errors or common circumstances. To deal with situations in which the planned performance fails
to happen, the computer code should incorporate error mitigation tools including exception
handling, input validation, and error messaging.

Code Structure and Organization: The style and arrangement of the program code ought to
replicate the structure of the algorithm. Similar processes may be contained in functions, classes,
or modules to promote code flexibility and reusability.

When compared to the algorithm, the program code may incorporate additions or enhancements
to increase speed or efficiency. This can include approaches such as cached data, algorithmic
improvements, or the use of specific language features that boost processing speed or memory
use.

CHALLENGES IN CONVERTING THE ALGORITHM INTO PROGRAM CODE

JavaScript is the language in which my software is written. Several difficulties might arise when
turning an algorithm into JavaScript code. Common difficulties include:

Language and syntax characteristics: JavaScript syntax and language components can vary from
those of the algorithm's pseudocode or other programming languages. You must grasp JavaScript
syntax and appropriately adjust the algorithm.

Variables and Data Types: Because of JavaScript's dynamic typing, arguments can hold values of
many data types. Make sure you handle data types effectively and to account for any type
modifications or validations that may be required.

ACHARYA ALIJA (BSC.IT / 1st sem) 28

 Programming

Control Flow and Looping: JavaScript supports if-else operators, for loops, while loops, and
other control flow and looping structures. Translate the algorithm's control flow and looping
parts to JavaScript equivalents.

Core Functions and Framework: JavaScript has a number of functions and libraries that can help
with certain tasks. Learn about the various functions and libraries and utilize them as needed to
improve the efficacy and clarity of your code.

Error and Exception Control: Consider how you will manage errors and exceptions in your code.
JavaScript provides try-catch blocks and other ways for catching and managing exceptions.
Determine the precise handling mechanisms for faults and defects in your algorithm
implementation.

Testing and Debugging: Thoroughly test your code to ensure that it delivers the right outputs for
a range of input circumstances. Use your IDE's debugging tools, like as breakpoints and console
logging, to identify and rectify any bugs or logical errors.

Code Structure and Modularization: Divide your code into procedures or modules to improve
code maintainability and reuse. In functions with defined inputs and outputs, encapsulate the
algorithm's smaller, more manageable components.

Code Refactoring and Optimization: Once the procedure has been constructed and is functioning
properly, consider revising the code to improve its structure, readability, and efficiency. Find
locations in the code where it may be simplified or modified to be more effective without
affecting its accuracy.

EXPLANATION OF CODING STRUCTURE USED IN SOURCE CODE

The subsequent coding standards were applied:

Alignment and formatting: Each level of indentation in the code is separated by two spaces,
which improves readability and makes it simpler to identify blocks of code. Functions are
correctly divided, and code parts are separated by line breaks.

ACHARYA ALIJA (BSC.IT / 1st sem) 29

 Programming

Conventions for Naming: Variables and functions are given logical and informative names.
When writing the names, the first letter of each word (save the first) is capitalized. This method
increases code readability and makes understanding the function of distinct parts easier.

Commenting: Some code portions provide explanations as comments. There is, for example, a
comment indicating where the price constants should be set. Comments are often used to provide
context and clarification and are denoted by double forward slashes (//).

HTML structure and tags: The HTML structure follows proper protocols, and the opening and
closing tags are utilized correctly. The tags are indented for readability and clarity.

CSS Style: In the CSS code, selectors, properties, and values are unique from one another since
they all utilize the same formatting style. CSS rule structure is displayed with the necessary
amount of indentation.

Variable and function declaration in JavaScript: Prior to the addition of let and const in ES6,
variables were generally specified using the var keyword, which is now used to specify both
variables and functions. This code appears to have been created in an obsolete programming
paradigm or style.

The code is typically straightforward and adheres to standard coding conventions, making it
easier for developers to understand and maintain the source code. Although coding standards
may vary depending on the project, team, or organization, it is critical to adhere to the specific
coding standards set for a given source.

APPLYING ALGORITHMS USING THE IDE

The algorithm, flowchart, and pseudocode for determining if an integer is odd or even is listed
below.

ALGORITHM:
1. Begin the program.

2. Request that the user enter a number 3. Read and save the data in a variable

4. Calculate the remainder of dividing the integer by 2 using the modules operator (%).

ACHARYA ALIJA (BSC.IT / 1st sem) 30

 Programming

5. Determine whether the residual is equal to zero. If yes, the number is even; otherwise, it is
odd.

6. Show the user the outcome

7. Put an end to the program.

FLOWCHART

Figure 19 Flowchart

PSEUDO-CODE:
an OUTPUT BEGIN NUMBER ("Input number:")

INPUT an IF (a%2==0) OUTPUT even ELSE OUTPUT odd

Let us now build the program for the given algorithm and Pseudo code.

Program in C++ is given below:

ACHARYA ALIJA (BSC.IT / 1st sem) 31

 Programming

Figure 20 PSEUDO-CODE

Program in python is given below:

Figure 21 Example of PSEUDO-CODE

Program in java is given below:

Figure 22 Example of PSEUDO-CODE

ACHARYA ALIJA (BSC.IT / 1st sem) 32

 Programming

IDENTIFYING AND SOLVING ANY FAULTS IN THE ORIGINAL ALGORITHM:

Recognizing and fixing mistakes in an algorithm necessitates a methodical approach. The
following are the steps for identifying and addressing logical errors:

IDENTIFYING ERROR:

Figure 23 IDENTIFYING ERROR

Line 26, Column 25, mistake "Expression expected" indicates a syntax error in the code. It
signifies that a certain sentence has been omitted or anticipated at that location.

RESOLVING ERROR:
To repair this issue, you need to make sure that you entered the right phrase or value in the code
on line 26, column 25. It might be an unfinished statement, an absence of an operator, or an
unknown allocation. By reading over the rest of the code, you can ensure that all variables are
appropriately formatted and that the necessary elements are accessible.

ACHARYA ALIJA (BSC.IT / 1st sem) 33

 Programming

Figure 24 RESOLVING ERROR

DEBUGGING ANY ERROR IN THE PROGRAM:

Here are a few fundamental steps to take when troubleshooting a program fault;

Detecting the problem: Analyze the error notice or examine the software's behavior to attempt to
figure out what went missing.

Recreate the mistake: Examine the statement for any missing or incorrect syntax, such as
parentheses, semicolons, or quote marks.

Check variable values: Using a debugger or console logs, inspect variable values to ensure they
have the desired data.

Follow the course of the program: Examine the program's flow of execution, paying special
attention to loops, conditionals, and function calls, to uncover any logical flaws.

These are a number of common measures to take when troubleshooting a program fault;

ACHARYA ALIJA (BSC.IT / 1st sem) 34

 Programming

Identifying the error: Read the error notice or examine the application's behavior to figure out
what went wrong.

Recreate the mistake: Examine the statement for any missing or incorrect syntax, such as
parentheses, semicolons, or quote marks.

Check variable values: Using a debugger or console logs, inspect variable values to ensure they
have the desired data.

Follow the course of the program: Follow the program's flow of execution, paying special
attention to loops, conditionals, and function calls, to uncover any logical flaws.

Figure 25 DEBUGGING ANY ERROR IN THE PROGRAM

ACHARYA ALIJA (BSC.IT / 1st sem) 35

 Programming

SECTION-III

INTRODUCTION
In this Presentation, we'll take a peek at the debugging technique and the unique VS Code
debugging tools that were employed to construct the Best Fitness software. We'll also discuss
how debugging helps to design more dependable and secure programs.

IDE CHOOSEN FOR THE PROJECT

Let's begin by taking a closer look at Visual Studio Code, the IDE used for this project.

Figure 26 IDE CHOOSEN FOR THE PROJECT

SLIDE 1 IDE CHOOSEN FOR THE PROJECT

ACHARYA ALIJA (BSC.IT / 1st sem) 36

 Programming

Visual Studio Code (VS Code) serves as the IDE for this project. Microsoft developed Visual
Studio Code, a small yet powerful source code editor. It is often used by programmers for a
number of languages, including JavaScript, the language used in this project. Because of its user-
friendly and highly flexible interface, developers may simply tailor their coding environment to
their tastes using VS Code. It offers a wide range of features and extensions that improve
productiveness and simplifies the development procedure. Perhaps the key features of Visual
Studio Code are:

IntelliSense: Users can compose programs faster and with fewer mistakes with the aid of VS
Code's intelligent code completion tool, which offers code snippets, function names, and variable
names as you type.

Developers may use the built-in terminal to execute scripts, conduct orders, and operate the
command-line tool with no leaving the editor.

Because of the integration of VS code, it is straightforward to handle version control, make

changes, and engage with others using GitHub repositories.

Extensibility: The IDE's extensive community of extensions, which may be added to boost
productivity, supports a broad stretch of programming languages, frameworks, and technologies.

Debugging Equipment: It provides sophisticated debugging tools that work with personal and
online programs, such as breakpoints, step-by-step execution, variable testing, and real-time
troubleshooting.

Cross-Platform Support: Visual Studio Code has Windows, macOS, and Linux versions,
providing a single programming environment for all three platforms.

In conclusion, Visual Studio Code is a versatile and feature-rich IDE that offers an intuitive
interface, a wide range of tools, and extensions. It is widely utilized among developers since it
provides an efficient and practical development platform for JavaScript and other coding
languages.

ACHARYA ALIJA (BSC.IT / 1st sem) 37

 Programming

DEBUGGING

Figure 27 DEBUGGING

The phrase "debugging process" alludes to the technique of analysis utilized to identify and
remedy defects or problems in software. Debugging is required during the course of software
creation to ensure code reliability and correctness. The following phases are frequently included
in the debugging process:

Reproduce the Problem: The first step is to reproduce a problem or malfunction that the software
is encountering. This might include running the application with particular data or engaging in
certain behaviors that create the problem.

Diagnose the Bug: Identifying the fault or the root cause of an issue occurs after the problem has
been replicated. This may be performed by employing debugging tools and methodologies,
observing the program's behavior, and understanding the erroneous messages.

Set Breakpoints: Breakpoints are specific areas in the code when the program stops executing in
order to you may analyze the program's present state. By inserting breakpoints at critical spots in
the code, you may focus on certain parts of code and restrict the extent of the problem.

ACHARYA ALIJA (BSC.IT / 1st sem) 38

 Programming

While debugging, you may inspect the contents of variables as well as information structures to
ensure they have the values that are desired. Therefore, it easy to detect any incorrect projects,
logical errors, or unusual behavior.

Analyze Error Messages: The error message and exception details might provide useful
information regarding the fundamental cause of the issue. By inspecting message errors, stack
traces, and exception data, you may establish exactly where in the code the issue occurred while
also comprehending the main reason.

Make the following changes: After discovering the flaw, the next step is to make the necessary
adjustments to address the issue. This could involve modifying the program's logic, changing
variables or parameters, or modifying the code.

Check and verify: After implementing the changes that are required, it is critical to execute the
modified code to ensure that the problem has been successfully fixed and the program is running
as expected. This may entail running numerous tests, modeling various scenarios, and comparing
the results to the expected outcomes.

Conduct as needed: In complicated programs or circumstances with several defects, the

debugging technique might require to be repeated numerous times. It might entail going back to
earlier procedures, reexamining the code, or seeking for more data or insights.

Debugging is the process of locating, analyzing, and correcting flaws in software programs. It is
a methodical and repeating process. To ensure that the program works effectively, close scrutiny,
logical reasoning, and the right utilization of debugging methods and instruments are required.

ACHARYA ALIJA (BSC.IT / 1st sem) 39

 Programming

DEBUGGING FEATURES AVAILABLE IN VS COSE

Figure 28 DEBUGGING FEATURES AVAILABLE IN VS COSE

To assist developers in finding and correcting mistakes, Visual Studio Code, a well-known and
efficient IDE, provides a variety of debugging features. The following are some of the most
important debugging tools provided by Visual Studio Code:

Breakpoints: Breakpoints are pauses in the program's execution that may be inserted into the
code using Visual Studio Code. Breakpoints allow you to closely investigate the software's state
and variables at that exact place in the code.

Step-by-step operation: Software developers can run the software line by line, one command at a
time. In Visual Studio Code, you may step into functions or techniques, extend over lines, and
step out of functions. This allows for precise management and monitoring of the program's
progress.

Watch Expressions: Watch expressions are variables or statements whose values are watched
while debugging, which developers can generate in Visual Studio Code. You can employ this
tool to keep a close eye on a specific parameter or statement while discovering more about its
properties.

ACHARYA ALIJA (BSC.IT / 1st sem) 40

 Programming

Debug Console: The integrated development environment (IDE) includes a debug console,
which allows programmers to continually execute code and evaluate statements when the
program pauses at a breakpoint. This allows for real-time verification and testing of the code's
performance.

Debugging Configuration: Using the IDE's configuration options, you may create launch settings
for various debugging scenarios. Programmers may specify the operating environment,
command-line arguments, and other options to properly debug the software.

Debugging Extension: Visual Studio Code comes with a comprehensive environment of

debugging modules. These extensions offers more features, compatibility with certain software
languages or frameworks, and interactions with external applications or services.

In general, the debugging capabilities in Visual Studio Code are intended to provide
programmers with effective resources for quickly evaluating and correcting errors throughout
their application. Breakpoints, step-through execution, parameter evaluations, and various other
elements collaborate in order to accelerate up debugging and make the IDE less complicated to
navigate when debugging.

PROCESS OF DEBUGGING

Figure 29 PROCESS OF DEBUGGING

ACHARYA ALIJA (BSC.IT / 1st sem) 41

 Programming

The debugging process plays an indispensable role in the creation of more resilient and
trustworthy apps since it aids in the detection and correction of any flaws and faults. Debugging
improves program safety and endurance in the following ways:

Finding Vulnerabilities: Developers have the opportunity to closely analyze the programming
language and how it is applied during the debugging process. This approach can detect
unsecured input transportation, buffer overflows, SQL injection attack locations, and unsecured
data storage. Early diagnosis of these vulnerabilities permits developers to implement suitable
risk-reduction strategies.

Error handling and exception administration: Debugging aids in discovering bugs and omissions
that may occur while a program is utilized. By examining these errors and exceptions,
programmers may improve error handling techniques and ensure that appropriate case handling
is in place. This enhances the user experience, protects against security flaws caused by
incomplete exceptions, and aids in preventing unplanned application failures.

Data Validation and Sanitization: During debugging, creators can examine the information being
provided to ensure it is legitimate and dependable. By checking and filtering user input,
developers may prevent common security issues such as XSS (cross-site scripting) attacks, SQL
injection attacks, and command injection attacks. Accurate input validation and sterilization
reduce the likelihood of malicious program execution or inadvertent data change.

Code Review and Refactoring: Debugging usually necessitates a thorough examination of the
software in order to appreciate its behavior. This is referred to as code evaluation and
restructuring. Software Engineers may now see and alter the source code, rendering it more
efficient, feasible, and protected. By fixing smells of code, removing redundant code, and
employing secure coding approaches, the program becomes more robust and less prone to faults.

Testing and Quality Control: Debugging is an important part of the screening part of the quality
monitoring cycle. Creators can uncover edge cases, concealed flaws, and ensure appropriate
functioning by iterating through the code, inspecting variables, and analyzing how the program
works. Debugging carefully aids in the development of more detailed scenario testing, which
improves the program's overall dependability and efficacy.

ACHARYA ALIJA (BSC.IT / 1st sem) 42

 Programming

Patching and protection updates: The debugging process is still indispensable in detecting and
addressing challenges that may arise in the operational surroundings despite a program has been
launched. Debugging typically aids in the discovery of security weaknesses or problems that
have been recognized by users or detected by monitoring systems. Creators can increase the
program's confidentiality and reliability over the years by addressing swiftly to problems and
delivering fixes or upgrades that improve security.

ACHARYA ALIJA (BSC.IT / 1st sem) 43

 Programming

DEBUGGING FOR THE SECURE AND ROBUST APPLICATION

Figure 30 DEBUGGING FOR THE SECURE AND ROBUST APPLICATION

ACHARYA ALIJA (BSC.IT / 1st sem) 44

 Programming

SECTION-IV

INTRODUCTION
This study intends to present a theoretical view of the sequence of progression from algorithm
creation to deployment, in addition to emphasizing the need of establishing an Integrated
Development Environment (IDE) as well as adhering to code guidelines in an organization like
HDS. This paper evaluates the performance of the algorithm, the interface between the algorithm
and the source code, the IDE used, and the relevance of coding standards for teams working on
software as well as individual coders.

ASSESSMENT OF IMPLEMENTATION OF THE ALGORITHM DESIGNED FOR

BEST FITNESS
The Best Fitness scheme's algorithm was created using the subsequent steps:

1. Initialization: In order to save client info and price information, necessary variables and
constants had to be declared. The basic averages for the variable were picked.

2. User Input: The program requested that the user submit customer information such as name,
training schedule, current weight, target weight category, sauna choice, as well as amount of
private coaching sessions. Input from the user was gathered and saved in the necessary variables.

3. computations: The inputted parameters created the foundation for the software's computations.
It was feasible to determine the entire expenditure for the course of study by combining the
expense of the plan of choice by the number of periods in a month. If the sauna option was
selected, the cost of the sauna was accounted for in the entire cost. Private coaching costs were
calculated by splitting the necessary number of sessions by the hourly fee. The cost of private
instruction was incorporated in the total cost.

4. Weight comparison: The application has assessed the user's current weight to the desired
weight classification. The outcome was saved in an integer which included an estimate of
whether the current weight was further down, within, or above the target weight limit.

ACHARYA ALIJA (BSC.IT / 1st sem) 45

 Programming

5. Output: The program displayed the name of the customer as well as a summary of all costs for
the month. It indicated the monthly training expense as well as the difference between the current
weight and the optimum weight category. The output was shown to the user.

6. Repeat for more customers: The program provided the opportunity to sign-up new users and
repeat step 2. This enabled the processing of several customers in quick order.

7. Program Termination: the client might terminate the software's activity by selecting the quit
alternative provided by the software.

The method was implemented by generating code in a programming language (e.g., JavaScript)
using an Integrated Development Environment (IDE) such as Visual Studio Code. The software
was then run with the code that produced the desired result in accordance with the reasoning
behind of the algorithm.

Throughout the design and development period, the algorithm was commonly checked and
verified to ensure its accuracy and efficiency. Any required adjustments or bug fixes were made
in order to align the actual implementation with the intended method. The aims were precise cost
computations, acceptable weight comparisons, and proper output presentation for all consumers.

EVALUATION OF ALGORITHM AND SOURCE CODE RELATIONSHIP

The following guidelines can be used to assess how closely the Best Fitness program's algorithm
conforms to its real source code:

1. Accuracy: the reasoning and operations of the algorithm should be accurately mirrored in the
source code. Each algorithmic step, including variable generation, input from customers,
computations, and output, should be precisely implemented in the source code.

2. Corresponding connection: the structure and execution of the algorithm ought to closely
resemble the source code. The sequence of statements in the code should correspond to the
progression of stages in the algorithm to guarantee that the software maintains the desired logic.

ACHARYA ALIJA (BSC.IT / 1st sem) 46

 Programming

3. Transparency and Readability: The source code needs to be written in a comprehensible form
that renders it easy for users to comprehend and follow the logic of the algorithm. To improve
ease of use and maintenance, the code requires logical names for elements and replies, as well as
suitable formatting.

4. Programming language compliance: The source code must adhere to the syntax and
regulations of the chosen programming language (for example, JavaScript). To ensure that the
code is ethical and achievable, it must adhere to best practices and standards related to the
language.

5. Objections and Edge Matters Handling: The algorithm explains various situations involving
edges and objections that the source code must consider. To preserve the program's longevity
and protection, it ought to utilize error-handling mechanisms and embrace unexpected data or
conditions with caution.

6. Efficiency and optimization: The source code should strive for optimized performance
whenever feasible. To attain the best potential performance, it should employ the appropriate
data structures, algorithms, and coding methodologies, especially for physically difficult
processes.

7. Checking and Confirmation: Checking and confirmation are used to determine the algorithm's
compliance with the source code. The software is executed with a range of inputs, as well as the
output matches up to the predicted results for the algorithm's parameters. This approach aids in
the detection of discrepancies or possible concerns.

It may determine when the thinking and behavior indicated by the algorithm in employ was
actually properly performed in the source code by comparing the written algorithm to the
genuine source code. Any variances or faults can be addressed and repaired to verify that the
code conforms with the algorithm's criteria.

ACHARYA ALIJA (BSC.IT / 1st sem) 47

 Programming

EVALUATION OF THE USE OF THE IDE CHOOSEN TO DEVELOP THE

SOFTWARE
The usage of the selected IDE (Visual Studio Code) provides several benefits and considerably
improves the production of the Best Fitness application. There is an assessment of the
advantages.

1. Code modifying characteristics: VS Code includes a number of code editing tools, such as
syntax highlighting, code completion, and intelligent tips. These resources assist coders in
writing code more successfully thus improving productivity and minimizing error rates.

2. Interdisciplinary Development Environment: VS Code is a comprehensive programming

ecosystem with an intuitive interface and a number of resources for coding, debugging, and
checking. It makes the process simple with features like GitHub integration and IDE-based
terminal accessible.

3. Wide Application and Modifications: VS Code allows programmers to extend its capabilities
by using a variety of modifications. By offering additional features, acceptance of other
languages, and connections with external tools, extensions like these simplify the development
process and enable change based on what is needed for the project.

4. Debugging capabilities: VS Code has powerful debugging tools that allow developers to
rapidly discover and repair errors in their code. The addition of breakpoints, variable analysis,
and incrementally coding simplifies and speeds up the debugging process.

5. Connectivity and Integration: VS Code encourages cooperation by allowing multiple designers

to collaborate in real time on identical endeavors using technologies such as Live Share.
Furthermore, it seamlessly integrates with a wide range of platforms, frameworks, and
development tools, therefore boosting the overall growth of the ecosystem.

Using Visual Studio Code as the integrated development environment (IDE) to create the Best
Fitness program offers several benefits, including better efficiency, linked development
resources, debugging options, and team assistance.

ACHARYA ALIJA (BSC.IT / 1st sem) 48

 Programming

IMPACT OF NOT HAVING ACCESS TO THE IDE

The following were the probable consequences of being denied entry to the IDE:

1. Restricted Productivity: Without an IDE like Visual Studio Code, developers would be
obliged to utilize simple text editors that lack crucial features like code completion and
intelligent recommendations. This might result in a slower development process, a larger risk of
errors, and reduced overall efficacy.

2. Mechanical Setup and Configuration: Without the IDE's ease of use, setting up a development
environment, creating build systems, and managing dependencies would be more complicated
and time demanding. These activities would have needed to be completed separately by
programmers, which might lead to errors and incorrect results.

3. Lack of Debugging Tools: Debugging code would prove significantly more difficult lacking
an IDE. In comparison to the built-in debugging tools of IDEs, coders must rely on manual
methods such as print statements or external debuggers, which may be laborious and inefficient.

4. Restricted Management of Projects: IDEs such as VS Code usually provide integrated project
management capabilities such as document navigation, application infrastructure participation,
and version control connection. Without such instruments, programmers may struggle to manage
project files and criteria.

5. Reduced collaborative: Lacking an IDE that supports features like real-time code distribution
and cooperative editing, collaborative computing could become more challenging. Software
Developers would have to employ manual transfer of files protocols or other third-party
collaboration tools, which could not be similarly effective or frictionless.

Without an IDE, the programming process could become lengthy and wasteful, with limitations
on teamwork, management of projects, code editing, and debugging.

ROLES AND PURPOSE OF CODING STANDARDS IN SOFTWARE DEVELOPMENT

The language principles used in the creation of software have a considerable impact on the
reliability, durability, and consistency of the code. The following sections discuss the goal and

ACHARYA ALIJA (BSC.IT / 1st sem) 49

 Programming

intent of coding standards, as well as the explanations as to why groups of application designers
and solo coders need them:

1. Code excellence: requirements for coding aid in enforcing norms and suggested practices
for producing productive, apparent and simple code. As a result, the source code is
simpler to comprehend, debug, and manage. They promote the employing of appropriate
names, punctuation, remarks, and style. When programming norms are constantly
subsequently followed, the overall quality of the code improves, while there is a lesser
possibility of introducing bugs or logical flaws.
2. Teamwork and Participation: Coding standards are a collection of accepted conventions
that foster effective cooperation and teamwork within a team working on software. When
team members use the same coding standards, it is easier to examine and comprehend the
other's code, which promotes better working together, smoother insertion, and fewer
disagreements. Coding rules assist team members in understanding others and supporting
a larger codebase.
3. Scalability and maintainability: Computer programs are often updated and maintained.
Code guidelines aid in the scalability and maintainability of applications by promoting
practices such as modularization abstraction, and separation of responsibilities.
Standardized code layout and structure make it easier to adapt, develop, and expand the
product over time, cutting maintenance costs and the likelihood of bringing about new
issues.
4. Readability and Understandability of Code: Software programmers, both original
creators and eventual maintainers, can grasp as well as understand code. Coding
standards improve code readability by establishing clear and uniform conventions for
names of variables, functional names, and code organization. Readable code allows for
more rapid development as well as a decrease in the period required to grasp the
functions and structure. It is also easier to follow, debug, and diagnose a specific code
section.
5. Code Assessments and Constant Integration: Coding norms facilitate code reviews, that
are an important phase in the program creation procedure. Experts can compare the code
to set standards, spot any problems or recommend modifications, and provide feedback.

ACHARYA ALIJA (BSC.IT / 1st sem) 50

 Programming

A person developers and development teams may guarantee that their code easily passes
assessment procedures by adhering to coding standards, and may speed up integration,
boost codebase quality, and eliminate disputes.
6. Future Maintainability and Team Transitions: Code guidelines aid in the long-term
sustainability of programming initiatives, irrespective of the team's makeup evolves.
While new programmers join a team, standardized coding standards assist in making it
easier for them to integrate and grasp the codebase quickly. When migrating from a
single endeavour to another one under the same organization, developers may more
readily conform to the predefined coding standards, resulting in more cooperation and
information exchange.
Coding standards are essential for developing software companies and individual coders
because they promote code excellence, comprehension, reliability, cooperation, and
flexibility. The consistent language and set of rules they provide help the whole project
lifecycle, from initial programming through code reviews, maintenance, and future upgrades.
By adhering to coding standards, developers may generate high-quality code that is easier to
understand, claim, and grow, resulting in greater efficiency and effectiveness in software
creation projects.

CONCLUSION
To summarize, creating the Best Fitness program required devising an algorithm,
implementing it in code, utilizing an IDE, and adhering to coding standards. The source code
for the method used to detect if a number is odd or just even was effectively converted and
the computations were carried out as expected. The chosen IDE, Visual Studio Code, proven
useful in the creating phase because to capabilities such as code editing, debugging, and
command execution. Without such a powerful IDE, the process would have been more
complex and lengthier. Adopting coding rules generated high-quality, legible code and
enhanced communication among team members. These strategies are critical for software
development teams and individual programmers because they encourage successful growth,
accessible code, and greater efficiency. In summary, utilizing the IDE and adhering to code
standards was critical to the successful deployment of the Best Fitness program and are
required for productive creation of software at HDS.

ACHARYA ALIJA (BSC.IT / 1st sem) 51

 Programming

ACHARYA ALIJA (BSC.IT / 1st sem) 52

 Programming

REFERENCES
Al-Kharabsheh, K. S. a. A. I. M. a. A. A. M. I. a. Z. N. I., 2013. Review on sorting algorithms a comparative
study. International Journal of Computer Science and Security (IJCSS), Volume 7, pp. 120--126.

Anon., n.d. object-oriented-programming. [Online]

Available at: https://www.collegenote.net/curriculum/object-oriented-programming/67/360/

Anon., n.d. What Is An Integrated Development Environment (IDE)?. [Online]

Available at: https://www.veracode.com/security/integrated-development-environment

Budd, T., 2008. Introduction to object-oriented programming. s.l.:Pearson Education India.

Burgin, M., 2006. Super-recursive algorithms. s.l.:Springer Science \& Business Media.

Fezari, Mohamed, Al, D. & Ali, 2018. Integrated development environment “IDE” for Arduino. WSN
applications, pp. 1--12.

Inoue, K., 2006. Evaluation of Source Code Updates in Software Development Based on Component
Rank. [Online]
Available at:
https://www.researchgate.net/publication/220773194_Evaluation_of_Source_Code_Updates_in_Softw
are_Development_Based_on_Component_Rank
[Accessed 23 May 2023].

Lalejini, A. a. O. C., 2018. Proceedings of the Genetic and Evolutionary Computation Conference. In:
Proceedings of the Genetic and Evolutionary Computation Conference. s.l.:s.n., pp. 1135--1142.

vandermeer, D., n.d. quora.com. [Online]

Available at: https://www.quora.com/What-are-the-relationships-between-programming-procedural-
object-oriented-and-event-driven-paradigms

White, G. a. S. M., 2005. Cognitive Differences Between Procedural Programming and Object Oriented
Programming.. Information Technology \& Management, Volume 6.

Zabinsky, Z. B. a. o., 2009. Random search algorithms. Department of Industrial and Systems
Engineering, University of Washington, USA.

Zhang, K. a. D. M. a. C. T. a. W. M. S. a. S. F., 2002. A dynamic programming algorithm for haplotype

block partitioning. Proceedings of the National Academy of Sciences, Volume 99, pp. 7335--7339.

ACHARYA ALIJA (BSC.IT / 1st sem) 53