Comparing Functional and OO Approaches

Conceptual design problem: Design a system to draw geometric shapes and manipulate them.

Functional

Object Oriented

Proc Rotate (shape)
   case (shape)
        triangle:
        square:
        circle:
   end case
end proc

Proc Draw (shape)
   case (shape)
        triangle:
        square:
        circle:
   end case
end proc

Proc Zoom (shape)
   case (shape)
        triangle:
        square:
        circle:
   end case
end proc

class Triangle
   method rotate()
   method draw()
   method zoom()
end class

class Square
   method rotate()
   method draw()
   method zoom()
end class

class Pentagon
   method rotate()
   method draw()
   method zoom()
end class

Diagram comparing "pure" functional and oo approaches will go here.

When to use

Functional	Object Oriented
Requirements emphasize "what does it do" Highly process oriented Simple data Transient data Complex rules or logic real time systems sequential architectures	Requirements emphasize "what data does it manage" Highly data oriented Complex or rich data domain Resident data Simple rules event driven architectures
Examples	Examples
Classic sequential data processing E.g. weekly payroll Scientific/engineering (lots of computations on simple numerical data) Message routing Artificial Intelligence networking	databases of any kind word processor image manipulation Computer aided drafting Simulation / modeling inventory control role playing games

Examples that could be either

Automated Teller Machine

Compiler

Operating Systems

Application to different levels of design

Functional and object-oriented approaches are complementary rather than opposing techniques and each may be applicable at different levels in the design. Consider the software in a modern civilian airliner.

High Level Design (object oriented)

navigation subsystem
radar subsystem
external communication subsystem
instrument display subsystem
propulsion subsystem

Middle Level Design (functional)

Display_Track (radar subsystem)
Compensate_for_Wind_Speed (navigation subsystem)
Reduce_Power (propulsion subsystem)
Low_Fuel_Warning (instrument display subsystem)
Lock_onto_Frequency (communication subsystem)

Low Level Design (object oriented)

Altimeter
Radio Beacon
Aircraft Position
Engine
Landing Gear

Which is easier?

Those who argue that OO is easier assert:

the world is objects
OO is more natural

It can be argued that functional design is easier than OOD:

Requirements are usually stated as desired functions, so it's a direct translation into functional components of the solution.
Historical precedence - functional came first as a result of Von Neumann architecture.
Thinking about the complex orchestration of collaboration among objects is difficult.
Functional is more natural. It's how people think about softare - "what can it do?"
Article critical of OO: "Does OO sync with how we think?" L.Hatton, IEEE Software, May/June 1998.

Symptoms of poor design choice

Your OO design should probably be a functional design if:

Your class names are verbs that have been "objectified", e.g., Generator, Editor, Verifier, Parser.
The classes encapsulate no data or simple data such as a strings.
The classes contain relatively few methods and the methods are large or complex, containing lots of functionality.
There are very few classes but each class has many methods or complex methods.
Uneven distribution of intelligence. I.e. there is one central class that does most of the work and many smaller classes that don't do much.
Lack of resident data. Class instances are created and then quickly disposed.

Your functional design should probably be an OO design if:

There is some large global (or public) data structure that many functions access.
Functions make many references to external data entities.
Functions perform small, relatively simple actions on the data.

CPE 205 Home