HNC Computing: Programming Paradigms and IDEs Report

This report delves into the realm of programming paradigms and Integrated Development Environments (IDEs), crucial components of software development. It begins by defining and explaining procedural, object-oriented, and event-driven programming paradigms, outlining their characteristics and interrelationships. The report then analyzes IDEs, highlighting key features such as source code editors, debuggers, and build automation tools. Furthermore, it provides a critical evaluation of source code examples for each paradigm, assessing code structure and characteristics to illustrate practical applications. The procedural paradigm's focus on sequential execution and the role of data, the object-oriented paradigm's emphasis on data security and code reusability, and the event-driven paradigm's responsiveness to user actions are all examined. The report concludes with a summary of the programming paradigms and their source code analyses.

Running head: REPORT ON PROGRAMMING PARADIGMS AND IDEs
REPORT
ON
PROGRAMMING PARADIGMS AND IDEs
Name of the Student
Name of the University
Author Note:

1PROGRAMMING PARADIGMS AND IDEs
Introduction:
In the field of the computer programs the programming paradigm represents the practice
that is utilized to solve problem for any specific task. Considering this aspect it is identified that
there are several techniques which is applied to solve any problem. While analyzing this concern
it is identified that there are numerous programming language which needs to follow some
specific strategy with the purpose to solve any problem, those strategies are termed as
programming paradigms (Payne 2019).
Thus, in order to elaborate these paradigm this paper will consist a detail discussion on
the several programming paradigms as well as a critical analysis on the source code of those
programing procedures.
Explanation of procedural, object-oriented and event driven programming:
Procedural Programming Paradigms-
These types of the programming paradigms are such types of programming paradigms
that is entirely based on structured or procedure based solution. Followed by this concern it is
identified that the procedural programing paradigms are entirely based on the operations of
series. Thus, it can be stated that in procedural programming Paradigm the machine will follow
structured instruction (Magalhães et al., 2016).
Object-oriented Programming Paradigms-
Along with the above mentioned programming paradigms it is identified that object
oriented programming paradigm is based on set of objects and classes. This programming
paradigm is one of the programming language which follows the object oriented model. While

2PROGRAMMING PARADIGMS AND IDEs
analyzing the effectiveness of this types of programming paradigm it can be stated that this is
one of the complex programming language (Isaiah et al., 2019).
Event Driven Programming Paradigms-
Along with the above mentioned paradigms, the event driven programming paradigms is
such paradigms that is entirely driven by the user actions such as the events. While analyzing the
execution process of event driven programming it is observed that these types of the program can
be written in any language (Nikouei et al., 2018).
Relation between procedural, object-oriented and event driven programming
paradigms:
Followed by the above discussion it can be stated that these programming paradigms are
one of the significant methods that is used to solve any specific task. Thus, in order to discuss the
relationship between these paradigms a comparison table is mentioned below:-
Procedural Programming
Paradigms
Object-Oriented
Programming Paradigms
Event driven Programming
Paradigms
In this type of programming
paradigms the style of coding
and execution process is liner.
In the object oriented
programming paradigms the
entire coding and execution
process is developed to
perform on specific task
(McBroom et al., 2018).
In this types of programming
paradigm the operations are
performed by the interactions
of physical activities like
keyboard click, mouse click
as well as moving the mouse.
The steps of this procedure is
highly focused on the
sequential format.
This paradigm is highly
focused on protecting the data
and operations of any specific
This paradigm is highly
focused on the user interface.

3PROGRAMMING PARADIGMS AND IDEs
task.
The character interfaces in
this paradigm is mentioned
with the use of commands.
These types of paradigms
provides the commands in
module format.
In order to create program
this paradigm provides the
user interfaces.
Fortan, COBOL and Basic
are such types of
programming language that
follows the procedural
programming paradigms.
JAVA, C++ and Smalltalk are
the types of programming
language that uses object-
oriented programming
paradigms (Salazar and
Vogel-Heuser 2019).
Visual Basic and C# are the
types of programming
language that uses the event
driven programming
paradigms.
Analysis of IDE with respect to each components:
IDE represents the integrated development environment which is a software and provides
the features to the developer to utilize the single graphical user interface. Followed by this
identification it is observed that an IDE consists of three key components which includes the
source code editor, debugger and local build automation. The source code editor is nothing but
an editor which helps the developer to write the syntax. The local build automation helps to
repeat the same tasks as well as the debugger helps to verify the programs.
Followed by these identification it is identified that in the field of programming it is very
essential to use the Ide with the purpose initiate the coding process. As IDE is one of the most
effective and faster the programming software there is no such necessity to invest more time for
developing the code. Making allowance to this concern it is identified that due to the automation

4PROGRAMMING PARADIGMS AND IDEs
feature as well as the accuracy of IDE, it will be very useful to the developer to access the
features of IDE.
Critical analysis of the source code:
Procedural Programming Paradigm-
Source code:-
#include <iostream>
using namespace std;
int main()
{
int i, fact = 1, num;
cout << "Enter any Number: ";
cin >> number;
for (i = 1; i <= num; i++) {
fact = fact * i;
}
cout << "Factorial of " << num << " is: " << fact << endl;
return 0;
}
While analyzing the source code of the Procedural Programming Paradigm it is identified
that this programming language works with execution process rather than focusing on the data.
Procedural programming that initiated with sequential process and the data present in the
execution process shifted from the function to function. After analyzing the entire process it is
observed that one of the major limitation of this paradigm is that the data present in this
procedure is not the first priority however, data is one of the essential element of the procedural
programming paradigm (Cruz-Filipe and Montesi 2017).
Object Oriented Programing Paradigm-
Source code:-
import java.io.*;
class GFG {
public static void main(String[] args)
{

5PROGRAMMING PARADIGMS AND IDEs
System.out.println("GfG!");
Signup s1 = new Signup();
s1.create(22, "riya", "[e-mail]", 'F', 89002);
}
}
class Signup {
int userid;
String name;
String emailid;
char sex;
long mob;
public void create(int userid, String name,
String emailid, char sex, long mob)
{
System.out.println("Welcome to
GeeksforGeeks\nLets create your account\n");
this.userid = 132;
this.name = "Radha";
this.emailid = "[e-mail]";
this.sex = 'F';
this.mob = 900558981;
System.out.println("your account has been created");
}
}
Followed by the analysis of the source code of object oriented programming it is
identified that data security and code reusability is one of the key element of this paradigm.
Along with this it is also observed that abstraction and flexibility is one of the essential element
as well.
Event Driven Programming Paradigm-
package eventdriven;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class EventDriven {
//Frames, panels and header text
private JFrame f;
private JLabel header;
private JLabel msg;
private JPanel statusPanel;

6PROGRAMMING PARADIGMS AND IDEs
public EventDriven(){
prepareGUI();
}
public static void main(String[] args){
EventDriven swingControlDemo = new EventDriven();
swingControlDemo.showEventDemo();
}
private void prepareGUI(){
f = new JFrame("The Twilight Zone");
f.setSize(400,400);
f.setLocation(625, 50);
f.setLayout(new FlowLayout());
header = new JLabel("",JLabel.CENTER );
msg = new JLabel("",JLabel.CENTER);
msg.setSize(350,100);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
statusPanel = new JPanel();
statusPanel.setLayout(new FlowLayout());
f.add(header);
f.add(statusPanel);
f.add(msg);
f.setVisible(true);
}
private void showEventDemo(){
header.setText("... Not only of sight, but of mind...");
JLabel lblUserName = new JLabel("Enter User Name");
final JTextField txtUserName = new JTextField();
txtUserName.setColumns(14);
JButton submitButton = new JButton("Submit");
submitButton.setActionCommand("Submit");
//add the action listener here and display user name
submitButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {

7PROGRAMMING PARADIGMS AND IDEs
String userName = txtUserName.getText();
msg.setText("User Name = " + userName);
}
});
statusPanel.add(lblUserName);
statusPanel.add(txtUserName);
statusPanel.add(submitButton);
f.setVisible(true);
}
}
Followed by the analysis of the above JAVA code which is based on the event driven
programming paradigm it is identified that the entire procedure is based on the event that has
occurred during the execution. Considering this aspect it is observed that in this source code one
of the most essential operation is the ActionListener as well as the ItemListener (Moreno et al.,
2020).
Conclusion:
After completion of this study it can be concluded that this paper is consist of a detail
elaboration of the programming languages based on their detail different paradigms. While
analyzing this concern in this paper the elaboration of the comparison of procedural paradigm,
object oriented paradigm as well as the event driven paradigm is present. Along with this in order
to get a detail idea about the nominated programming paradigm a critical analysis of the source
code of these nominated programming paradigm is present by which the characteristics of these
source code has been determined and explained.

8PROGRAMMING PARADIGMS AND IDEs
Reference:
Payne, J.R., 2019. Introduction to Computer Programming and Python. In Python for
Teenagers (pp. 1-16). Apress, Berkeley, CA.
Isaiah, A.I., Odi, A.C., Rita, A.U., Verginia, A.C. and Anaya, O.H., 2019. Technological
Advancement in Object Oriented Programming Paradigm for Software
Development. International Journal of Applied Engineering Research, 14(8), pp.1835-1841.
Magalhães, G.G., Sartor, A.L., Lorenzon, A.F., Navaux, P.O.A. and Beck, A.C.S., 2016,
November. How programming languages and paradigms affect performance and energy in
multithreaded applications. In 2016 VI Brazilian Symposium on Computing Systems Engineering
(SBESC) (pp. 71-78). IEEE.
Nikouei, S.Y., Xu, R., Nagothu, D., Chen, Y., Aved, A. and Blasch, E., 2018, September. Real-
time index authentication for event-oriented surveillance video query using blockchain. In 2018
IEEE International Smart Cities Conference (ISC2) (pp. 1-8). IEEE.
Moreno, F., Uribe, S., Álvarez, F. and Menéndez, J.M., 2020. Extending Aspect-Oriented
Programming for Dynamic User's Activity Detection in Mobile App Analytics. IEEE Consumer
Electronics Magazine, 9(2), pp.57-63.
Cruz-Filipe, L. and Montesi, F., 2017, June. Procedural choreographic programming.
In International Conference on Formal Techniques for Distributed Objects, Components, and
Systems (pp. 92-107). Springer, Cham.

9PROGRAMMING PARADIGMS AND IDEs
McBroom, J., Yacef, K., Koprinska, I. and Curran, J.R., 2018, June. A data-driven method for
helping teachers improve feedback in computer programming automated tutors. In International
Conference on Artificial Intelligence in Education (pp. 324-337). Springer, Cham.
Salazar, L.A.C. and Vogel-Heuser, B., 2019, October. Applying Core Features of the Object-
Oriented Programming Paradigm by Function Blocks Based on the IEC 61131 and IEC 61499
Industrial Automation Norms. In International Workshop on Service Orientation in Holonic and
Multi-Agent Manufacturing (pp. 273-289). Springer, Cham.