Benefits and Risk

• Exploits the expressive power of the object-oriented programming languages:
Object-oriented programming (OOP) languages such as Java, C++, and Python allow developers to
model complex systems using objects, which can represent real-world entities. This expressive power
makes it easier to translate conceptual models into code.
In a library management system, books, members, and librarians can be represented as objects, each
with their attributes and methods. This approach makes the code intuitive and closely aligned with the
real-world entities it represents.
• Encourages the re-use of software components:
OOP promotes the creation of reusable software components. Once a class is defined, it can be used in
multiple programs without modification.
Example: A Person class in a human resources application can be reused in a customer relationship
management system without any changes. Both systems can use the same class to represent an
individual with properties like name, address, and phone number.
• Leads to systems that are more resilient to changes:
OOP makes it easier to modify existing code and add new features without disrupting the system. This
is because changes in one part of the system do not necessarily affect other parts.
Example: In an e-commerce platform, if a new payment method needs to be added, it can be done by
creating a new class that implements the payment interface, without altering existing payment methods.
• Reduces development risk:
Explanation: By breaking down a system into smaller, manageable objects, OOP helps in isolating and
identifying issues quickly. It also allows for incremental development and testing.
Example: Developing a car simulation game involves creating separate objects for different car parts
like the engine, wheels, and body. Each part can be developed and tested independently, reducing the
overall risk of system failures.
• Reduction in development time and the size of the resulting source code:
OOP's modular approach allows for faster development cycles and more concise code. Code reusability
and inheritance help in reducing redundancy.
Example: In a project management tool, the Task class can inherit properties and methods from
a ProjectItem base class. This inheritance minimizes the code needed to implement task-specific
features, as shared attributes and methods are defined only once in the base class.
• Appeals to the working of human cognition:
OOP aligns with how humans naturally perceive and organize information, making it easier to
understand and manage complex systems.
Example: When designing a smart home system, objects like Light, Thermostat,
and SecurityCamera correspond to real-world devices. This natural mapping between objects in
the system and real-world devices makes it easier for developers and users to understand and interact
with the system.
Risks of Object Oriented Development:
There could be start-up cost risk and performance risk.
Start- Up Cost Risks:
• Initial Investment in Tools:
When a company starts using object-oriented programming (OOP) for the first time, it needs
to buy and set up new software development tools. This requires money and time.
Example: Imagine a company that has only used basic text editors for coding. To switch to
OOP, they might need to invest in integrated development environments (IDEs) like IntelliJ
IDEA or Visual Studio, which can be expensive.
• Lack of Existing Software:
If a company is new to a specific object-oriented language, it likely won't have any pre-existing,
reusable software components in that language. This means they have to build everything from
scratch.
Example: A company transitioning to Java from another language will not have any Java
libraries or frameworks they've previously developed, so they'll need to start from zero, which
can slow down initial progress.
• Training and Knowledge Required:
Without proper training and understanding, the first attempt at using OOP can fail. OOP
requires a different way of thinking compared to procedural programming, and it takes time to
learn and adapt to this new mindset.
Example: Developers used to procedural programming might struggle with concepts like
inheritance, polymorphism, and encapsulation. Without adequate training, they might misuse
these concepts, leading to poor design and software that doesn't work well.
Performance Risk:
In object-oriented programming, objects often need to communicate with each other by calling
methods on other objects. This communication adds some extra work (overhead) for the
computer to manage.
Example: Think of it like making phone calls to give instructions. If you have to call someone
every time you need something done, it takes time to dial, connect, and talk. Similarly, when
objects call each other, the computer needs time to manage these calls, which can slow things
down a bit.
• Inheritance Hierarchies:
In OOP, classes can inherit features from other classes. When creating an object from a derived
class (a class that inherits from another class), the computer has to run the setup code
(constructors) for that class and all its parent classes. If there are many levels of inheritance, it
takes more time.
Example: Imagine a family tree where each generation passes down certain traits. If a new
member is added to the family, you need to acknowledge all the traits passed down from many
generations, which takes time. Similarly, when an object is created in a deeply nested
inheritance structure, the computer has to go through all the levels, which can slow down
performance.
• Polymorphism:
Polymorphism allows objects of different classes to be treated as objects of a common

superclass. The actual method that gets executed is determined at runtime. This flexibility
comes with a performance cost because the program must decide which method to call during
execution (runtime).
Example: Consider a scenario where you have a Shape superclass with subclasses
like Circle, Square, and Triangle. If you have a list of Shape objects and call
the draw method on each, the program needs to determine the correct draw method to execute
for each object at runtime. This decision-making process can slow down the execution.
Dynamic Allocation:
Object-oriented programming often involves creating objects dynamically (at runtime) using
memory allocation. Dynamic allocation is generally more time-consuming compared to static
allocation because it involves managing memory allocation and deallocation.
When creating a new Student object in a school management system, memory must be
allocated for the new object's attributes and methods. This process involves additional overhead
to manage memory, especially if many objects are being created and destroyed frequently,
leading to potential fragmentation and increased garbage collection time.

Benefits and Risk

Uploaded by

Copyright:

Available Formats

Benefits and Risk

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Benefits and Risk

Uploaded by

Copyright:

Available Formats

• Exploits the expressive power of the object-oriented programming languages:

• Encourages the re-use of software components:

• Leads to systems that are more resilient to changes:

• Reduces development risk:

• Appeals to the working of human cognition:

Risks of Object Oriented Development:

There could be start-up cost risk and performance risk.

Start- Up Cost Risks:

• Initial Investment in Tools:

• Lack of Existing Software:

• Training and Knowledge Required:

Polymorphism allows objects of different classes to be treated as objects of a common

You might also like

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.