Designing Reusable Classes

Bhargava Ram Koti(700623600)

Summary: The object oriented way of designing the system is different from traditional
development. It was considered different because of its structure which is modular and enforces
the multi use of same code written by developer. The major idea given by the author is that this
pattern of development gives the opportunity of reusability of code. We will discuss as per the
user. He uses the example of small talk to describe it. Let us understand and move forward. We
shall know how it is useful in real environment. The application of this paper, various
applications of this example, their pros cons of their use in general use of system. Reuse is the
keyword that author emphasizes every time when object-oriented concept is introduced.
This way of development is considered to be less time for development and increases
productivity. In addition we see it is easy to develop the product from the old format. It was also
ought to reduce the cost of system development. However it was not considered what we think of
the system. The development of the system based on component is essential. It may provide the
scope for modular version of building the system. The components can vary in any size. It may
range from small, medium and large size. However it does not depend on the size of the size of
system but ultimately it depends on the functionality of system which is used for development.
There are a lot of techniques that are mentioned by author achieving the intended
functionality. While there are various types of inheritance is available in the whole object
oriented design, we see the author describes the one and only design that is mentioned in the
article. It was named to be single inheritance. In any aspect the author finally says that the
objective of this paper should be to enforce the reusability of the software. In component based
we see that it is very easy to knowledge others and explain the others clearly and to the self. The
functions are called sometimes as methods. Even though the name or functionality doesnt
change it enables every user of such system to know the concept very easily. It enables the
derived class use the functions from the base class. This is core concept involved in inheritance.
The next concept is polymorphism.
The current method is mostly used in many forms. We obtain such functionality just
based on one form. This is best explained in the form of using the concept of one in many
contexts. Such unique features make the design of the system traditional different the regular
development. We discuss various examples in detail the object oriented design of system. The
concepts are frameworks, software lifecycle and toolkit to name some of them. The framework
was supposed to be collection of classes where it is useful to solve the complex problems
involved in the system. As the object oriented design became more significant the task became
more complex for the software developer or software engineer to understand the system and its
applications. We see a lot of people using the inheritance in the earlier days for the development.
As the design more intuitive we see it became more complex and difficult to understand
the system. The complex system brings out the talent of developer to understand its structure
clearly. Even the opposite can happen like only a knowledgeable person can easily understand
the complex system. Finally as per the author we see his input as we should be able to develop
the framework, abstract class and general rules for the system development. In addition to these
we see that we should know that experience, skill and knowledge of a person decide on the

developing the system .We see author is confident of development of system in more confident
way by his teaching methods of object oriented design.
We now discuss how internal system of object oriented works. It is general understand of
the system that we have a object, method, encapsulation, abstract class when we have our notion
on object oriented system. As the name suggests we see that object oriented design is completed
based on object. It is general for the software developer to explain the difference the natural
design and the object-oriented design. There is need to understand the contrast between the
polymorphism and inheritance. Before we discuss the concept of inheritance we should know
about the abstract class.
The abstract class helps you declare method in them and finally use in the derived class.
It is your final decision to declare or define the method in the base class. We shall now discuss
about the polymorphism in detail. In general it is considered by sending a message in
polymorphism. However the confusion should be avoided in understanding the message of the
system especially when compared with small talk or distributed operating systems. Based on the
input of method or command line argument we see that the particular method is invoked for
calculating the function value. If we provide the correct input the system will work correctly.
We should ensure that no mistake while message from one method to another method. It
gives unnecessary complexity for the system. It is a tedious task for technical support to
understand the problem and give the solution. When you object oriented language like c++ we
should know that it is not entirely dependent on the development but also the structure of the
system. Errors like buffer overflow can write data to adjacent memory location. We should avoid
such problem by making proper design of the system. Eventhough it is not language dependant it
is mainly depends on the design of the system. We now discuss the concept of protocol and how
it is useful or change the scope of object oriented design.
Protocol is could be defined as set of rules. Since we are dealing with object these rules
are applicable to object. It discusses what is allowed and restricted for a object. We should know
the return type of the object. The object is considered by encapsulating the data and operations
on the data itself. Like discussed the system explains the modularity by an example. The object
oriented design also explains the information hiding in the system If the object has return type
that is similar the author says that they are interchangeable provided they use same protocol. The
objects can be combined to produce the complex objects. We know discuss the concept of plug
compatible if the particular object follows same protocol. The complex objects which can be
building together give an opportunity known as tool kits.
This concept shall be discussed later. The next concept we think is shared protocol where
various objects are sharing protocol to communicate among themselves on classes. This is
similar to arithmetic operators used for complex mathematical operations like matrix addition,
subtraction, multiplication and division. The author gives the example where overloading
concept was used for similar operations. In the traditional system it may be tedious task of
writing code from scratch to develop the system which is additional burden. In addition we
discuss the concept called virtual function which was not discussed by the author. It increases the
readability of the program. It gives the simpler task for developer who wants to understand the
complex code which contains millions of lines of code. This concept is not applicable in other
non-object oriented languages.

Critique: One concept is to understand the protocols before they are implemented in the system.
If you understand them we can see that the system communicates effectively. But however in
other case we have to know that any discrepancy could result in opposite. If you implement them
correctly the task becomes simpler and easy to understand. The concept is clear in definition but
there is more than just understanding .The author has to present the side effects. It was not
presented well. The author gives proper suggestion on development but he fails utterly in
predicting in the cons. The next concept is inheritance.
The inheritance concept says that derived class attains its features from the base class.
The features include its operations, functionality from the base class. Since every derived class
inherits from the base class the requirement of defining the code once again is not required. They
define a new concept called program by difference where there are some similarities between the
base class and derived class. Obviously there will be certain differences between them. We also
get additional feature like organizing the classes in the program.
Moreover, it also helps to build the protocols. This is not to be considered as just
application oriented. It can be used to develop standard general use systems. It also helps to
know how to organize the information. In the end we see that we can extend the information by
developing the classes. If you get an additional requirement in future during the agile
development of a process, then we can make the proper code changes in the existing code and
run the program. When you designing the system you should that the concept of inheritance and
protocol should co-exist. The concept is that either of them is separately dependent on the super
class or base class for system requirement. Each property should not oppose other. We can use
the various types of inheritance those are available like multiple inheritance to avoid such
problems. The next concept that we should think is the virtual function. The function can be
declared virtual in the base class which has each own implementation at the base class and the
derived class.
The object which is instantiated can use any of them based on the requirement. This
saved the time, cost and improves the efficiency of the system. On the other hand we should the
flexible environment where we can provide the easy extension for any language. The author has
not mentioned about such virtual functions. He has to update knowledge before writing such a
report. He has wrongly given information where he said there is no instance for the abstract
class. It is individual programmer right to have an instance and definition addition with the
declaration. The author might have misconception about the abstract class before he wrote this
article. The other option is that feature might not available before he started writing this article.
The author has given final declaration that abstract class that is was to represent the protocol.
The next we have find the difference between the abstract class and the concrete class.
The concrete class is the class where it is compulsory to declare the method and define
the method. In abstract class it is your wish to define and declare the method. The next option
that is to find the different perspective he imposes on the reader. In the general perspective we
have give the general idea abstract class usage is ideal case for object oriented design. We now
move out from the traditional concept think out most promising features that were explained by
the author. The first among is the tool kit or the framework. The concept we have to understand
here is that they use the core abstract class concept for the representation of the design. In this
concept they communicate by message. The messages use the class representation. The next
option that we consider is that all classes are grouped into a library that ensures reusability. Just

the compiler is fragmented into parts like lexer, parser etc we consider the application is
combine of components. The framework provides the inbuilt libraries that are useful in
application development. These classes ensure high reusability and make the task of developer
very simple. The next concept we discuss is the life cycle of the project that is present for
development of an application. The thing is that we have to understand the white box framework
and black box framework.
Each has distinct work of development guidance. While one has to understand we have to
hide the code while we develop the system. This ensures that security of the system while
developing the system. The black box approach is not recommended by the author. However it is
our collective responsibility of the system to ensure the safety of the system. The additional
option is MVC architecture of development. Design is said to be proper in white box approach
and the components are well connected. The abstract design is available in the white box
approach. Key factor that makes an impact in Object oriented approach is the design of the
system. To ensure such proper design of the system there are certain steps of measures touted to
be helpful for the system.
The initial step is use of recursion function. The recursion function as the name suggests
it makes a function call to its own function. There may internal loop which may decrement the
value or increase the based on the requirement. Metrics are to be mentioned properly for its
implementation. We have other option of excluding the case analysis. The task becomes simpler
if an object is declared in the original class instead of inheritance. If done in such a manner there
will be less dependency, increases module based development and reduces redundancy. The next
viable option is to reduce the amount of communication between the components. As the
communication increases the system becomes complex and not a recommended solution for
application development.
The author recognizes another method of passing less command line arguments to the
system. It is thought provoking approach but its genuine validity can only assumed only through
practical analytics. It may sometime curse a system which has lot of dependency on large data. It
is because if the data decreases it is not practical for such kind of application. In addition the
author claims that hierarchical dependency between the classes should be deep and thin. Well it
may be no of relationships may less like one to many or one to one to consider a few. He has
taken the practical example of small talk for this explanation. The result could be validated by
eminent scientists and researchers of society.
The next step in consolidation of reusability of code in the reduce the amount of size of
code in the function you define in the program. Instead of writing the useless code which is large
enough that deteriorates performance. We can use the small amount of efficient code that is high
performing. Using local variables, reducing the dependency on the global variables can improve
the performance of system. Better communication can be achieved through message passing
between components. Abstract class plays a key role in the design of your system. Some of
complex methods can be made into small parts for easy understanding of the system for every
person in the project. Exclude parameter passing could be enabled between necessary classes for
the improvement of the process. Instead of developing an application from start multiple times
we can use this object oriented approach which ensures reusability of the system. The author do
not directly recommend this approach but he indirectly suggests this approach of program
development. In the end I think it is not as efficient in performance in traditional approach.