In my last article I introduced some of the basic concepts behind object oriented programming. Today I continue this introduction by talking about code reuse and composition.

So what do we mean by code reuse? Quoting Wikipedia “Code reuse is the idea that a partial or complete computer program written at one time can be, should be, or is being used in another program written at a later time”. A traditional way in LabVIEW to reuse code is to write subVIs that are shared between many applications or multiple parts of the same application. SubVIs can be further packaged into libraries which contain multiple SubVIs handling different parts of some process.

Object-oriented programming takes code reuse a giant leap forward. The enhanced code reusability is built-in to the design of object oriented programming and was one of the main design goals of object-oriented programming. In my last article I did not mention code reuse. However the concepts I introduced in my last article are central for writing reusable object-oriented code.

Today I’ll concentrate on two concepts of reusing code in object-oriented programming. First code reusability is very much a design issue. In object-oriented programming reusable design is enforced by forcing developers to encapsulate the data and the methods for manipulating the data together into joint entities called classes. As a result programming interfaces become cleaner which as a result increases code reusability. In addition the object data is hidden from the users and only exposed via interface methods forcing developers to think how they classes expose their data to maximize reusability. Second existing classes can be used as private data members of new classes with similar functionality. This way the functionality of a new class can be partially or fully delegated to some other classes.

Object-oriented programming also introduces a powerful technique called inheritance that helps reusing code a great deal. It’s a topic of its own, and we’ll leave it as a subject for our next articles.

Designing Reusable Class Interfaces

Although object-oriented programming provides many ways for reusing code, it doesn’t mean that code is automatically reusable. Writing well reusable code requires both experience and a lot of consideration from the developer. An important phase of object-oriented development process is defining the interface for the class under development.

Last time we talked about class interfaces. An interface consists of a set of methods (subVIs) the class user can use to perform actions on an object of that class type. These methods can be for example manipulations of the object private data, getting information about the object state or interacting with other objects or other systems such as files, devices and network. When defining this interface, the developer should think carefully how to make these interface methods as general purpose as possible to allow the class to be used also outside the scope of the current application in development.

In the development process the development team should really concentrate on defining and specifying the central parts of the interface of each class. If the interface of a class is only an implicit result of coding and not a design decision, the code reusability will definitely be scarified.

Composition

If a class interface is well designed, the class may be easily used to implement some of the functionality of another class. This can be achieved by using an object of one class type as a private data member of another class. Using classes as private data members of other classes is called composition.

As an example consider a class Engine that represents an engine of a motor vehicle. The interface of Engine has methods Start Engine and Stop Engine. Now consider you would like to create a class Car. Cars normally have engines so you can now use the class Engine as a private data member of class Car.

You may want the interface of class Car have methods Start Car Engine and Stop Car Engine. Now that Engine is a private data member of class Car you can delegate the actions of starting and stopping the engine from the Car class to the Engine class.

Composition is a very powerful and flexible way of reusing existing code. A new class can be composed of multiple different classes. One class could be used as a private data member multiple times in the same class. In our example class Car could have an array of objects of class Wheel in addition to class Engine as its private data members. Composition even allows changing the underlying implementation at runtime but we will not go deeper in to this dynamic composition yet.

Conclusions

Object oriented programming brings code reuse to completely to a new level. Indeed better code reuse may be the single most important reason to migrate from conventional LabVIEW programming to object-oriented LabVIEW programming. In this articles I’ve introduced several mechanisms of code reuse in object-oriented programming. These seemingly simple concepts are however hard to master. In my future articles I’ll go into more detail how to master these techniques.

In the next article I’ll introduce third mechanism of code reuse called inheritance. Subscribe to the RSS feed not to miss it.