Object oriented programming concept

Introduction
Object-Oriented Programming (OOP) is a programming paradigm based on the
concept of "objects," which are instances of classes. These objects encapsulate data
(attributes) and behaviors (methods) into a single entity. OOP emphasizes principles
like encapsulation, inheritance, polymorphism, and abstraction to create modular,
reusable, and scalable software.
This approach models real-world entities and their interactions, making it intuitive and
efficient for designing complex systems.

Features Object oriented programming concept

 Class
 Objects
 Data Abstraction
 Encapsulation
 Inheritance
 Polymorphism
 Dynamic Binding

1. Class:
A class is a user-defined data type. It consists of data members and
member functions, which can be accessed and used by creating an instance of
that class. It represents the set of properties or methods that are common to all objects
of one type. A class is like a blueprint for an object.
For Example: Consider the Class of Cars. There may be many cars with different
names and brands but all of them will share some common properties like all of them
will have 4 wheels, Speed Limit, Mileage range, etc. So here, Car is the class, and
wheels, speed limits, mileage are their properties.

2. Object:
It is a basic unit of Object-Oriented Programming and represents the real-life
entities. An Object is an instance of a Class. When a class is defined, no memory is
allocated but when it is instantiated (i.e. an object is created) memory is allocated. An
object has an identity, state, and behaviour. Each object contains data and code to
manipulate the data. Objects can interact without having to know details of each
other’s data or code, it is sufficient to know the type of message accepted and type of
response returned by the objects.
For example “Dog” is a real-life Object, which has some characteristics like color,
Breed, Bark, Sleep, and Eats.

Object

3. Data Abstraction:
Data abstraction is one of the most essential and important features of object-
oriented programming. Data abstraction refers to providing only essential
information about the data to the outside world, hiding the background details
or implementation. Consider a real-life example of a man driving a car. The man
only knows that pressing the accelerators will increase the speed of the car or applying
brakes will stop the car, but he does not know about how on pressing the accelerator
the speed is increasing, he does not know about the inner mechanism of the car or the
implementation of the accelerator, brakes, etc in the car. This is what abstraction is.
4. Encapsulation:
Encapsulation is defined as the
wrapping up of data under a single unit. It
is the mechanism that binds together code
and the data it manipulates. In
Encapsulation, the variables or data of a class
are hidden from any other class and can be
accessed only through any member function
of their class in which they are declared. As in
encapsulation, the data in a class is hidden
from other classes, so it is also known as data-
hiding.

Consider a real-life example of encapsulation, in a company, there are different

sections like the accounts section, finance section, sales section, etc. The finance
section handles all the financial transactions and keeps records of all the data related
to finance. Similarly, the sales section handles all the sales-related activities and keeps
records of all the sales. Now there may arise a situation when for some reason an
official from the finance section needs all the data about sales in a particular month.
In this case, he is not allowed to directly access the data of the sales section. He will
first have to contact some other officer in the sales section and then request him to
give the particular data. This is what encapsulation is. Here the data of the sales section
and the employees that can manipulate them are wrapped under a single name “sales
section”.
5. Inheritance:
Inheritance is an important pillar of OOP (Object-Oriented Programming). The
capability of a class to derive properties and characteristics from another class is
called Inheritance. When we write a class, we inherit properties from other classes.
So when we create a class, we do not need to write all the properties and functions
again and again, as these can be inherited from another class that possesses it.
Inheritance allows the user to reuse the code whenever possible and reduce its
redundancy.

6. Polymorphism:
The word polymorphism means having many forms. In simple words, we can
define polymorphism as the ability of a message to be displayed in more than one
form. For example, A person at the same time can have different characteristics. Like
a man at the same time is a father, a husband, an employee. So the same person
possesses different behaviour in different situations. This is called polymorphism.
7. Dynamic Binding:
In dynamic binding, the code to be executed in response to the function call is
decided at runtime. Dynamic binding means that the code associated with a given
procedure call is not known until the time of the call at run time. Dynamic Method
Binding One of the main advantages of inheritance is that some derived class D has
all the members of its base class B. Once D is not hiding any of the public members
of B, then an object of D can represent B in any context where a B could be used. This
feature is known as subtype polymorphism.
 UNIT-1
CHAPTER- 1
INTRODUCTION TO JAVA

JAVA
Java is a high-level, object-oriented, platform-independent programming language
developed by James Gosling at Sun Microsystems (now owned by Oracle
Corporation) in 1995. It is designed to be simple, robust, secure, and portable,
enabling developers to create software applications that can run on any device or
operating system equipped with a Java Virtual Machine (JVM).
Features of JAVA

1. Simple
 Java is designed to be easy to learn and use. Its syntax is clear and simple,
influenced by C and C++ but eliminating many of the complex features of those
 languages, like pointers, operator overloading, and multiple inheritance in
classes.
 No Pointers: Java does not allow direct memory manipulation, which simplifies
memory management and reduces errors such as memory leaks.
 Automatic Garbage Collection: Java has an automatic garbage collection
system that reclaims memory by removing unused objects, making memory
management easier and less error-prone.

2. Object-Oriented
 Everything in Java is treated as an object, which makes it easier to manage
and scale complex software systems.
 Main Principles of OOP:
o Encapsulation: Bundling the data (variables) and methods (functions)
that operate on the data into a single unit, a class.
o Inheritance: A mechanism where one class acquires the properties and
behaviors of another class.
o Polymorphism: The ability for one method or class to take many forms
(e.g., method overloading, method overriding).
o Abstraction: Hiding the complex implementation details and showing
only the essential features of an object.
 OOP makes Java code more modular, reusable, and easier to maintain.

3. Platform-Independent
 One of Java's most significant features is its ability to run on any platform. Java
follows the "Write Once, Run Anywhere" (WORA) philosophy.
 Compilation into Bytecode: Java code is compiled into an intermediate form
called bytecode (.class files), not machine code.
 The bytecode can be executed on any system that has a Java Virtual Machine
(JVM), which interprets the bytecode into platform-specific machine code.
 This allows Java programs to run on any device or operating system (Windows,
Linux, macOS, etc.) without modification.
4. Secure
 Java has this feature since it provides several built-in mechanisms that protects
against vulnerabilities like memory corruption, unauthorized access and
malicious code execution. Java is said to be secure for the following reasons:
o No Direct Memory Access: Unlike C or C++, Java does not allow direct
memory manipulation, which prevents many types of security
vulnerabilities (e.g., buffer overflows).
o Bytecode Verification: Java verifies bytecode before it is executed,
ensuring that malicious or harmful code does not run.
o Class Loaders: These are part of JRE. These control which classes can
be loaded into the Java environment, providing further control over
security.
o Security Manager: The security manager checks the permissions of the
application and can restrict access to system resources, like file I/O and
network connections, preventing unauthorized access.

5. Robust
 Java is designed to be reliable and resilient (the ability of a system to continue to
operate and recover from failures, disruptions, or stress). It has built-in features
that help prevent errors and crashes:
o Exception Handling: Java provides robust error-handling capabilities
through the use of exceptions. Errors are managed using try-catch blocks,
ensuring the program can continue to run even after encountering issues.
o Automatic Garbage Collection: Java automatically handles memory
management and cleans up unused objects, reducing the likelihood of
memory leaks.
o Type Checking: Java is statically typed, meaning the type of every
variable is checked at compile-time. This prevents many common runtime
errors.

6. Multithreaded
 Java has built-in support for multithreading (Thread: Threads are lightweight
subprocesses, representing the smallest unit of execution with separate paths.
Multithreading: is a Java feature that allows concurrent execution of two or
 more parts of a program for maximum utilization of CPU), which means that
multiple threads can run concurrently within a program.
 This is particularly useful in applications that require multiple tasks to be
performed simultaneously, such as:
o Web servers managing multiple client requests
o Games with multiple players
o Real-time applications like chat applications
 Java provides a Thread class and the Runnable interface for creating and
managing threads, making it easier to write highly efficient, responsive
applications.

7. Portable
 Java is highly portable, which is one of its main advantages.
 Java programs are compiled into platform-independent bytecode, which can be
run on any system with a JVM.
 Since Java avoids platform-specific code, a program written on one platform
(e.g., Windows) can run on other platforms (e.g., Linux or macOS) without
modification, as long as a JVM is available.

8. High Performance
 While Java is an interpreted language, it uses a Just-In-Time (JIT) compiler to
convert bytecode into machine code at runtime, improving the performance of
Java applications.
 The JVM optimizes the execution of bytecode to improve the program's
performance as it runs, making Java faster than other interpreted languages like
Python.

9. Distributed
 Java is built with support for distributed computing, meaning applications can
communicate and work across networks.
 Java's Distributed Features:
 o Remote Method Invocation (RMI): Allows objects to communicate
across a network as if they were local.
o Enterprise JavaBeans (EJB): A server-side component architecture for
distributed, transactional, and secure applications.
o Sockets and Networking: Java provides built-in classes for creating and
managing network connections and interacting with other systems over
the internet.

10. Dynamic
 Java is a dynamic language, meaning that it can adapt to changing conditions
and environments during runtime.
 Dynamic Loading of Classes: Java allows classes to be loaded into the program
at runtime (using reflection and class loaders), which makes the system flexible
and extensible.
 Java also supports dynamically adding or removing libraries, which allows
developers to modify or extend applications without recompiling the entire
system.

11. Architecture-Neutral
 Java bytecode is designed to be architecture-neutral, meaning the compiled code
does not depend on the machine's hardware architecture.
 The JVM handles the translation of bytecode into native machine code specific
to the hardware and operating system of the machine it's running on.

12. Interpreted
 Java programs are interpreted by the JVM, which provides platform
independence.
 The JVM translates bytecode into machine code during execution. This
interpretation allows for the portability of Java programs across different
systems.

Difference between C and JAVA

 C Java

C was developed by Dennis M. Ritchie Java was developed by James

between 1969 and 1973. Gosling in 1995.

C is a Procedural Programming Language. Java is Object-Oriented language.

C is more procedure-oriented. Java is more data-oriented.

Java is a high-level language

C is a middle-level language because binding
because translation of code takes
of the gaps takes place between machine
place into machine language using
level language and high-level languages.
compiler or interpreter.

Java is an Interpreted language that

C is a compiled language that is it converts
is in Java, the code is first
the code into machine language so that it
transformed into bytecode and that
could be understood by the machine or
bytecode is then executed by the
system.
JVM (Java Virtual Machine).

C generally breaks down into functions. Java breaks down into Objects.

C programming language can be used for

system programming as well as Application This is not the case in Java.
programming.

C does not contain the property called Java contains the property of
Inheritance because it does not support Inheritance which is very useful in
OOPS, which is very useful for code code reusability.
 C Java

reusability. Thus C is not suited when one has

to relate the things according to the real
world.

Memory allocation can be done by malloc in Memory allocation can be done by

C a new keyword in Java.

Java is a high-level language

C is a low-level language. It has difficult
because translation of code takes
interpretation for the user but it has a closer
place into machine language using
significance to the machine-level code.
compiler or interpreter.

In C89 declaration of variables is at the

beginning of the block but in the latest We can declare variables
version of C that is C99 we can also declare anywhere.
variables anywhere.

A compiler will free up the

memory internally by calling the
free is used for freeing the memory in C. garbage collector.

Java supports the concept of

C supports Threading.
threading.

C supports pointers. Java does not supports pointers.

It is not portable. It is portable.

 C Java

Call by value and call by reference is

It only supports a call by value.
supported in C.

C is platform dependent. Java is a platform independent.

It supports user-based memory management. It internally manages the memory.

C is not robust that is strict type checking

does not takes place while compile and run Java is robust.
time.

Exception handling cannot be directly

Exception Handling is supported in
achieved in C and thus it lacks the
Java.
maintenance of normal flow of the program.

It follows a top-down approach. Java follows a bottom-up approach.

Overloading functionality is not supported by Java supports method overloading

C. which helps in code readability.

Java does not support

C supports Preprocessors.
Preprocessors.

C does not supports OOPS concept. Java supports OOPS concept.

Union and structure datatypes are supported Java does not supports union and
by C. structures.
 C Java

Whereas Java does not support the

C supports the storage classes.
storage classes.

It has 32 keywords. It has 50 keywords.

Go-to statements are supported in C Java does not supports go-to

language. statements.

Virtual keywords are not supported

Virtual keywords are supported by C.
by Java.

Java supports method

Overloading functionality is not supported by
overloading which helps in code
C.
readability.

Default members of Java are

Default members of C are public.
private.

Data hiding is done by using

Data hiding is done by using static in C.
private in Java.
 JAVA Editions
Java has several editions, each tailored for specific types of applications:
1. Java SE (Standard Edition):
o Provides core Java libraries and tools for general-purpose development.
o Used for building desktop applications, command-line tools, and small-
scale programs.
2. Java EE (Enterprise Edition):
o Focuses on large-scale, distributed enterprise applications (applications
that are spread across multiple nodes or servers. They allow multiple
users to access the application simultaneously.).
 o Includes tools for building web applications, business logic, and
database connectivity (e.g., Servlets, JSP, EJB).

3. Java ME (Micro Edition):

o Designed for mobile and embedded devices with limited resources.
o Used in applications for mobile phones, IoT devices, and other
embedded systems.
4. JavaFX:
o A platform for creating rich, interactive user interfaces.
o Used for developing desktop applications with advanced graphics,
animations, and media.
5. Java Card:
o Optimized for smart cards and embedded systems.
o Focuses on secure applications, cryptography, and small memory
devices.
Each edition serves a different purpose, from small-scale apps to enterprise-level
solutions, embedded systems, and rich interfaces.

Java Development Kit (JDK)

The Java Development Kit (JDK) is a software package that provides everything you
need to develop and run Java applications. It is a comprehensive development
environment for Java programming that includes various tools, libraries, and utilities.
Key Components of the JDK:
1. Java Compiler (javac):
o The javac compiler translates Java source code (in .java files) into
bytecode (in .class files), which can then be executed by the Java Virtual
Machine (JVM).
o Example: javac [Link] compiles the Java source file into
bytecode.
2. Java Runtime Environment (JRE):
 o The JDK includes the JRE, which is a part of the Java platform that
allows you to run Java applications.
o The JRE contains the JVM (Java Virtual Machine), class libraries, and
other components necessary to run Java programs.

3. Java Virtual Machine (JVM):

o The JVM executes the bytecode generated by the compiler. It converts the
bytecode into machine-specific code during runtime.
o It also provides memory management, garbage collection, and ensures
platform independence.
4. Java API (Application Programming Interface) (An API stands for
Application Programming Interface, and it is an interface that allows
communication between different applications using the packages it comprises):
o The JDK includes a rich set of Java standard libraries (the Java API),
which provide ready-to-use functionalities for common programming
tasks such as:
 Data structures (e.g., Arrays, Lists, Maps).
 Input/Output (I/O) operations (e.g., file handling, networking).
 GUI development (e.g., Swing, JavaFX).
 Networking, security, and database connectivity (e.g., JDBC).
5. Development Tools:
o Debugger: A tool that helps developers find and fix bugs in their Java
programs.
o Documentation Generator (Javadoc): A tool for generating HTML
documentation from Java code, including comments and annotations.
o Java Archive (JAR) tool: A utility for packaging multiple files (e.g.,
class files, images) into a single archive file, useful for distribution.
6. Other Utilities:
o java: The command-line tool used to run compiled Java applications
(bytecode).
o javap: A tool for disassembling bytecode to inspect class files and see the
details of the compiled code.
 o jconsole: A monitoring tool for observing the performance of Java
applications running on the JVM.
Why is the JDK Important?
 The JDK is essential for Java developers because it provides all the necessary
tools to write, compile, debug, and run Java applications.
 Without the JDK, developers would not have access to the Java compiler (javac),
runtime environment (JRE), or libraries needed to create and execute Java
programs.
The Java Development Kit (JDK) is the complete package required for Java
development, combining the necessary tools (compiler, runtime, libraries, utilities) to
write, compile, test, and run Java applications.
Java Runtime Environment (JRE)
The Java Runtime Environment (JRE) is a crucial component of the Java platform,
designed to provide the runtime environment necessary for executing Java applications.
It includes the tools and libraries required to run Java programs but does not include
development tools like the compiler.

Components of JRE:
1. Java Virtual Machine (JVM):
o The JVM is the core component of the JRE responsible for executing Java
bytecode.
o It translates the platform-independent Java bytecode into machine-
specific code and handles tasks like:
 Memory management.
 Garbage collection.
 Exception handling.
o Ensures that Java follows the Write Once, Run Anywhere (WORA)
philosophy.
2. Core Java Libraries:
 o The JRE includes a rich set of pre-built class libraries (Java API) that
provide common functionalities, such as:
 Collections (e.g., ArrayList, HashMap).
 Input/Output (I/O) operations (e.g., file handling, networking).
 Database connectivity (e.g., JDBC).
 Utilities for string manipulation, date/time handling, etc.
o These libraries are essential for running Java applications, as they provide
pre-written code for common tasks.
3. Java Class Loader:
o The class loader is responsible for loading Java classes into the JVM at
runtime.
o It ensures that the required classes and resources are loaded dynamically
during program execution.

4. Java Native Interface (JNI):

o A part of the JRE that allows Java applications to interact with code
written in other languages (e.g., C or C++).
o Enables integration with platform-specific features or legacy systems.
5. Other Runtime Tools:
o The JRE includes utilities for debugging, monitoring, and optimizing Java
applications.

How the JRE Works:

1. Bytecode Execution:
o Java source code is compiled into platform-independent bytecode by the
Java compiler (javac).
o The JRE takes this bytecode and uses the JVM to interpret or compile it
into machine-specific code at runtime.
2. Platform Independence:
o The JRE ensures that Java applications can run on any operating system
(Windows, Linux, macOS, etc.) with a compatible JRE installed.
Why is JRE Important?
 The JRE is essential for end-users who want to run Java applications.
 Without the JRE, it is impossible to execute Java programs, as it provides the
necessary runtime environment.
 It ensures platform independence and seamless execution of Java applications.

The Java Runtime Environment (JRE) is a runtime environment that includes the
JVM, core libraries, and tools required to execute Java applications. It ensures the
efficient running of Java programs across different platforms.

Java Virtual Machine (JVM)

The Java Virtual Machine (JVM) is a key component of the Java platform that enables
the execution of Java programs. It serves as the runtime engine that takes platform-
independent Java bytecode and translates it into machine-specific instructions for
execution. The JVM is a crucial part of Java’s "Write Once, Run Anywhere" (WORA)
principle.
Functions of the JVM:
1. Bytecode Execution:
o The JVM executes Java bytecode, which is the intermediate, platform-
independent representation of compiled Java source code.
o It translates the bytecode into machine code specific to the underlying
operating system and hardware.
2. Platform Independence:
o Java programs are compiled into bytecode, which is not tied to any
specific machine. The JVM interprets this bytecode, ensuring that Java
programs can run on any platform with a compatible JVM.
3. Memory Management:
o The JVM handles memory allocation and deallocation, ensuring efficient
use of resources.
o It includes features like Garbage Collection, which automatically
removes unused objects from memory to prevent memory leaks.
 4. Security:
o The JVM ensures that Java programs run in a secure environment.
o It includes a Class Loader to load classes dynamically and a Security
Manager to enforce access control rules, such as restricting file or
network access.
5. Error Handling:
o The JVM manages exceptions and errors during runtime, ensuring stable
program execution and recovery mechanisms.

Components of the JVM:

1. Class Loader:
o Responsible for loading .class files (Java bytecode) into memory.
o Performs tasks like loading, verifying, and preparing classes before
execution.

2. Bytecode Interpreter or JIT Compiler:

o Interpreter: Reads and executes bytecode line by line.
o Just-In-Time (JIT) Compiler: Converts bytecode into native machine
code for faster execution. It compiles code dynamically during runtime.
3. Runtime Data Areas (Memory Structure):
o Method Area: Stores class structures, including metadata, method data,
and constant pool.
o Heap: Allocates memory for objects and their instance variables.
o Stack: Stores method-specific data like local variables and method call
details.
o Program Counter (PC) Register: Tracks the address of the currently
executing instruction.
o Native Method Stack: Handles native (non-Java) method calls.
4. Garbage Collector:
o Automatically reclaims memory occupied by objects no longer in use.
 o Improves memory efficiency and reduces the risk of memory leaks.
5. Execution Engine:
o Contains the Interpreter and JIT Compiler to execute bytecode.
o Handles native calls and interacts with the operating system and
hardware.
6. Java Native Interface (JNI):
o Enables Java programs to call native methods written in other languages
like C or C++.
o Facilitates integration with platform-specific features or legacy systems.

Lifecycle of JVM:
1. Loading: The Class Loader loads the Java bytecode into memory.
2. Linking: Classes are verified, prepared, and resolved to ensure correctness and
compatibility.
3. Initialization: The JVM initializes classes and their static variables.
4. Execution: The Execution Engine interprets or compiles bytecode and runs the
program.

Advantages of JVM:
 Platform Independence: Ensures that Java programs can run on any system
with a JVM.
 Memory Management: Handles memory allocation and garbage collection
automatically.
 Security: Provides a secure environment with features like class verification and
sandboxing.
 Optimized Performance: With the JIT Compiler, the JVM optimizes
performance during runtime.

The Java Virtual Machine (JVM) is the heart of Java's runtime environment,
providing a platform-independent, secure, and efficient execution of Java programs. It
 interprets and compiles Java bytecode, manages memory, and ensures the "Write Once,
Run Anywhere".

Difference Between JDK and JRE

KEY JDK JRE

DEFINITION JDK(Java JRE(Java Runtime

Development Kit) is Environment) is the
used to develop Java implementation of
applications. JDK JVM(Java Virtual
also contains Machine) and it is
numerous specially designed
development tools to execute Java
like compilers, programs.
debuggers, etc.
FUNCTIONALITY It is mainly used for It is mainly used
the execution of code for creating an
and its main environment for
functionality is code execution.
development.
DEPENDENCY OF It is platform- On the other hand,
PLATFORM dependent. JRE is not
responsible for
development
purposes so it
doesn’t contain
such tools as the
compiler, debugger,
etc. Instead, it
contains class
libraries and
supporting files
required for the
purpose of
execution of the
program.
IMPLEMENTATION OF JDK JDK = JRE + other JRE = JVM + other
AND JRE development tools. class libraries.
Advantage And Disadvantage of Java

Advantages of Java:
1. Platform Independence:
o Java's "Write Once, Run Anywhere" (WORA) capability allows
programs to run on any platform with a compatible JVM, making it
highly portable.
2. Object-Oriented:
o Java follows the Object-Oriented Programming (OOP) model, making
code modular, reusable, and easier to understand.
3. Rich Standard Libraries:
o Java provides extensive built-in libraries (e.g., Collections, I/O,
Networking, etc.) that simplify development.
4. Security:
 o Java has built-in security features such as bytecode verification, a secure
class loader, and a Security Manager, ensuring robust application
security.
5. Automatic Memory Management:
o Java has a Garbage Collector that automatically handles memory
allocation and deallocation, reducing the risk of memory leaks.

6. Multi-threading Support:
o Java supports multi-threading, allowing developers to build applications
with concurrent processes for better performance.
7. Robust and Reliable:
o Java's strong memory management, exception handling, and type-
checking mechanisms make it a robust language for building stable
applications.
8. Community Support:
o Java has a massive community of developers, making it easy to find
help, resources, and tools.

9. Scalability:
o Java is suitable for developing small-scale applications to large,
distributed enterprise systems.
10. Wide Usage:
o Java is used across various domains, including web development,
mobile applications (via Android), enterprise systems, and cloud
computing.

Disadvantages of Java:
1. Performance Issues:
o Java programs are generally slower than programs written in languages
like C or C++ because of the JVM and abstraction layers.
 2. Memory Consumption:
o Java applications use more memory due to features like garbage
collection and runtime checks, which may be inefficient for resource-
constrained systems.
3. Verbose Syntax:
o Java code tends to be more verbose, which can lead to longer and more
complex programs compared to other modern languages.
4. Lack of Low-Level Programming:
o Java abstracts hardware-level operations, which makes it less suitable
for tasks requiring direct system-level access (e.g., device drivers).
5. Startup Time:
o Java applications often have a longer startup time because the JVM
needs to initialize before execution.
6. Dependency on JVM:
o Java applications cannot run without a properly installed and configured
JVM, creating a dependency on the environment.
7. GUI Development:
o Although Java supports GUI development (Swing, JavaFX), it is less
favored compared to modern tools and frameworks like React or Flutter
for building user interfaces.

8. Complex Learning Curve for Beginners:

o While Java is easier than some languages, its object-oriented principles
and verbose syntax can be challenging for beginners.

Summary Table:

Advantages Disadvantages

Platform independence (WORA) Slower performance

Object-oriented programming High memory usage

Rich standard libraries Verbose syntax

Advantages Disadvantages

Strong security features Longer startup time

Automatic memory management Dependency on JVM

Multi-threading support Limited low-level programming

Scalability and versatility GUI development is less modern

Large community and resources Steeper learning curve for beginners

*********************************************************************