 | Coupling computer science: Encyclopedia - Coupling computer science
Coupling (computer science)
In computer science, coupling or dependency is the degree to which each program module relies on each other module.
Coupling is usually contrasted with cohesion. Low coupling often correlates with high cohesion, and vice versa. The software quality metrics of coupling and cohesion were invented by Larry Constantine, original developer of Structured Design (see also SSADM).
Coupling computer science - Low coupling
Coupling can be "low" (also "loose"), or "high" (also "tight"). Low coupling means that one module does not have to be concerned with the internal implementation of another module, and interacts with another module with a stable interface (see Information hiding). With low coupling, a change in one module will not require a change in the implementation of another module. Low coupling is a sign of a well structured computer system.
However, in order to achieve maximum efficiency, a highly coupled system is probably needed. In modern computing systems, performance can often be traded for lower coupling; the gains in the software development process are greater than the value of the running performance gain.
Low-coupling / high-cohesion is a general goal to achieve when structuring computer programs, so that they are easier to understand and maintain.
The concepts are usually related: low coupling implies high cohesion and vice versa. In the field of object-oriented programming, the connection between classes tends to get lower (low coupling), if we group related methods of a class together (high cohesion).
In object-oriented programming, coupling is a measure of how strongly one class is connected to another.
Coupling is increased between two classes A and B if:
- A has an attribute that refers to (is of type) B.
- A calls on services of a B object.
- A has a method which references B (via return type or parameter).
- A is a subclass of (or implements) B.
Disadvantages of high coupling include:
- A change in one class forces a ripple of changes in other classes.
- Difficult to understand a class in isolation.
- Difficult to reuse or test a class because dependent class must also be included.
One measure to achive low coupling is functional design: it limits the responsibilities of modules. Modules with single responsibilities usually need to communicate less with other modules, and this has the virtuous side-effect of reducing coupling and increasing cohesion in many cases.
Inversion of Control
Coupling computer science - Types of coupling
The types of coupling, in order of lowest to highest coupling, are as follows:
Data coupling
Data coupling is when modules share data through, for example, parameters. Each datum is an elementary piece, and these are the only data which are shared (e.g. passing an integer to a function which computes a square root).
Stamp coupling (Data-structured coupling)
Stamp coupling is when modules share a composite data structure, each module not knowing which part of the data structure will be used by the other (e.g. passing a student record to a function which calculates the student's GPA).
Control coupling
Control coupling is one module controlling the logic of another, by passing it information on what to do (e.g. passing a what-to-do flag).
External coupling
External coupling occurs when two modules share an externally imposed data format, communication protocol, or device interface.
Common coupling
Common coupling is when two modules share the same global data (e.g. a global variable).
Content coupling
Content coupling is when one module modifies or relies on the internal workings of another module (e.g. accessing local data of another module).
In object-oriented programming, subclass coupling describes a special type of coupling between a parent class and its child. The parent has no connection to the child class, so the connection is one way (i.e. the parent is a sensible class on its own). The coupling is hard to classify as low or high; it can depend on the situation.
Coupling computer science - Known uses
Dependency is also common in talking about software package management. One software package, in order to work or to be fully functional, may depend on other software packages and thus must also be installed, and their specific versions must be known if backward compatibility is broken between versions. The Apt package format, as well as some versions of the RPM package format, include dependency information between packages. This is convenient for updating software but can lead to dependency hell.
Build systems like make are also dependency driven in the sense that a more complex object, like a program, only gets linked together once all its dependencies, i.e. the objects it is built of, have been compiled.
High cohension and low coupling is equal to very good design.
See also
Categories: Computer science | Object-oriented programming | Software architecture
Other related archivesApt, Computer science, Information hiding, Inversion of Control, Object-oriented programming, RPM, SSADM, Software architecture, backward compatibility, class, classes, cohesion, compiled, computer programs, computer science, computer system, dependency hell, functional design, linked, make, object-oriented programming, program, software development, software package, software quality metrics
 Adapted from the Wikipedia article "Coupling computer science", under the G.N U Free Docmentation License. Please also see http://en.wikipedia.org/wiki |
