What is "Orthogonality"?

Question

What does "orthogonality" mean when talking about programming languages?

What are some examples of Orthogonality?

Sable

Answer 1

Orthogonality is the property that means "Changing A does not change B". An example of an orthogonal system would be a radio, where changing the station does not change the volume and vice-versa.

A non-orthogonal system would be like a helicopter where changing the speed can change the direction.

In programming languages this means that when you execute an instruction, nothing but that instruction happens (which is very important for debugging).

There is also a specific meaning when referring to instruction sets.

Rotative

This answer reminds me of "superposition" theory from signal and systems. – Harlem

A very clear explanation of the different usages of this word: c2.com/cgi/wiki?DefinitionOfOrthogonal – Templas

So is functional programming completely orthogonal? – Oddment

That's an interesting question @yannbane. In theory, depending on the theoretical functional language, it may be true. In practice no, even functional languages have ways to change state. – Rotative

@C.Ross Haskell is the only purely functional language I'm familiar with. Ignoring unpure (IO) functions - I can't find an example of non-orthogonality in Haskell. But I've only been studying it for an hour in total so who am I to draw conclusions I guess... – Oddment

I like the dictionary.com definition, "Mutually independent; well separated" - but does anyone know if there's a word for the opposite? (Contingent? Codependent?) – Autostability

I bet that helicopter example is from "Pragmatic Programmer" :) – Christie

@strongriley Actually Orthogonality is loose coupling only. – Christie

This lives in the same mental bucket that atomicity and idempotency do for me. – Wira

Answer 2

From Eric S. Raymond's "Art of UNIX programming"

Orthogonality is one of the most important properties that can help make even complex designs compact. In a purely orthogonal design, operations do not have side effects; each action (whether it's an API call, a macro invocation, or a language operation) changes just one thing without affecting others. There is one and only one way to change each property of whatever system you are controlling.

Siderostat

Answer 3

Think of it has being able to change one thing without having an unseen affect on another part.

Prize

Answer 4

Broadly, orthogonality is a relationship between two things such that they have minimal effect on each other.

The term comes from mathematics, where two vectors are orthogonal if they intersect at right angles.

Think about a typical 2 dimensional cartesian space (your typical grid with X/Y axes). Plot two lines: x=1 and y=1. The two lines are orthogonal. You can change x=1 by changing x, and this will have no effect on the other line, and vice versa.

In software, the term can be appropriately used in situations where you're talking about two parts of a system which behave independently of each other.

Undertake

I believe this is the best answer written. – Subjoin

Answer 5

If you have a set of constructs. A langauge is said to be orthogonal if it allows the programmer to mix these constructs freely. For example, in C you can't return an array(static array), C is said to be unorthognal in this case:

int[] fun(); // you can't return a static array.
// Of course you can return a pointer, but the langauge allows passing arrays.
// So, it is unorthognal in case.

Devaluation

Actually I saw this in my book and still don't understand what is that. – Sable

LOL I'm using this book and saw this question on online quiz of the book. What a coincidence. Maybe I should read first chapter, too. – Sable

It's simply saying that return and arrays are more complex when put together: you can't use return around arrays without thinking about the interaction between them. Ideally, you would know what return means, and what an array is, and so you would know what returning an array would do, but actually, it's more complex than that, because C exposes implementation details about arrays (and return). – Unvalued

This sense of "orthogonal" is covered by: en.wikipedia.org/wiki/Orthogonality_(programming) , but it's a new page with little content. – Arcature

This is the "more right" answer about orthogonality in context of programming. "orthogonality" means that a programming construct can be mixed with any other construct, and its semantics will still remain the same. – Coeternal

Answer 6

Most of the answers are very long-winded, and even obscure. The point is: if a tool is orthogonal, it can be added, replaced, or removed, in favor of better tools, without screwing everything else up.

It's the difference between a carpenter having a hammer and a saw, which can be used for hammering or sawing, or having some new-fangled hammer/saw combo, which is designed to saw wood, then hammer it together. Either will work for sawing and then hammering together, but if you get some task that requires sawing, but not hammering, then only the orthogonal tools will work. Likewise, if you need to screw instead of hammering, you won't need to throw away your saw, if it's orthogonal (not mixed up with) your hammer.

The classic example is unix command line tools: you have one tool for getting the contents of a disk (dd), another for filtering lines from the file (grep), another for writing those lines to a file (cat), etc. These can all be mixed and matched at will.

Unvalued

Answer 7

While talking about project decisions on programming languages, orthogonality may be seen as how easy is for you to predict other things about that language for what you've seen in the past.

For instance, in one language you can have:

str.split

for splitting a string and

len(str)

for getting the lenght.

On a language more orthogonal, you would always use str.x or x(str).

When you would clone an object or do anything else, you would know whether to use

clone(obj)

or

obj.clone

That's one of the main points on programming languages being orthogonal. That avoids you to consult the manual or ask someone.

The wikipedia article talks more about orthogonality on complex designs or low level languages. As someone suggested above on a comment, the Sebesta book talks cleanly about orthogonality.

If I would use only one sentence, I would say that a programming language is orthogonal when its unknown parts act as expected based on what you've seen. Or... no surprises.

;)

Ruckus

This answer isn't consistent to others; this just claims consistency between function calls or overall structure in contrast to others that are on the lines of "less-coupling" or "side-effectlessness". – Harlem

This is the usage I usually have heard. I think the reason it is orthogonal is that if you have X.ToString and X.GetType, you can vary the object and the syntax is the same, or you can vary the function and the syntax is the same. The object is independent of the function. – Archine

Answer 8

From Robert W. Sebesta's "Concepts of Programming Languages":

As examples of the lack of orthogonality in a high-level language, consider the following rules and exceptions in C. Although C has two kinds of structured data types, arrays and records (structs), records can be returned from functions but arrays cannot. A member of a structure can be any data type except void or a structure of the same type. An array element can be any data type except void or a function. Parameters are passed by value, unless they are arrays, in which case they are, in effect, passed by reference (because the appearance of an array name without a subscript in a C program is interpreted to be the address of the array’s first element)

Stirpiculture

Answer 9

from wikipedia:

Computer science

Orthogonality is a system design property facilitating feasibility and compactness of complex designs. Orthogonality guarantees that modifying the technical effect produced by a component of a system neither creates nor propagates side effects to other components of the system. The emergent behavior of a system consisting of components should be controlled strictly by formal definitions of its logic and not by side effects resulting from poor integration, i.e. non-orthogonal design of modules and interfaces. Orthogonality reduces testing and development time because it is easier to verify designs that neither cause side effects nor depend on them.

For example, a car has orthogonal components and controls (e.g. accelerating the vehicle does not influence anything else but the components involved exclusively with the acceleration function). On the other hand, a non-orthogonal design might have its steering influence its braking (e.g. electronic stability control), or its speed tweak its suspension.1 Consequently, this usage is seen to be derived from the use of orthogonal in mathematics: One may project a vector onto a subspace by projecting it onto each member of a set of basis vectors separately and adding the projections if and only if the basis vectors are mutually orthogonal.

An instruction set is said to be orthogonal if any instruction can use any register in any addressing mode. This terminology results from considering an instruction as a vector whose components are the instruction fields. One field identifies the registers to be operated upon, and another specifies the addressing mode. An orthogonal instruction set uniquely encodes all combinations of registers and addressing modes.

Tamanaha

Oh thanks I just visited this stub en.wikipedia.org/wiki/Orthogonality_%28programming%29 Sorry. – Sable

"accelerating the vehicle does not influence anything else but the components involved exclusively with the acceleration function" is trivially false, e.g. the suspension reacts to acceleration, the total grip available is limited so acceleration affects cornering ability, it is almost a poster child for non-orthogonality. (good answer, bad example from real life) – Pipkin

Answer 10

From Wikipedia:

Orthogonality is a system design property facilitating feasibility and compactness of complex designs. Orthogonality guarantees that modifying the technical effect produced by a component of a system neither creates nor propagates side effects to other components of the system. The emergent behavior of a system consisting of components should be controlled strictly by formal definitions of its logic and not by side effects resulting from poor integration, i.e. non-orthogonal design of modules and interfaces. Orthogonality reduces testing and development time because it is easier to verify designs that neither cause side effects nor depend on them.

For example, a car has orthogonal components and controls (e.g. accelerating the vehicle does not influence anything else but the components involved exclusively with the acceleration function). On the other hand, a non-orthogonal design might have its steering influence its braking (e.g. electronic stability control), or its speed tweak its suspension.[1] Consequently, this usage is seen to be derived from the use of orthogonal in mathematics: One may project a vector onto a subspace by projecting it onto each member of a set of basis vectors separately and adding the projections if and only if the basis vectors are mutually orthogonal.

An instruction set is said to be orthogonal if any instruction can use any register in any addressing mode. This terminology results from considering an instruction as a vector whose components are the instruction fields. One field identifies the registers to be operated upon, and another specifies the addressing mode. An orthogonal instruction set uniquely encodes all combinations of registers and addressing modes.

To put it in the simplest terms possible, two things are orthogonal if changing one has no effect upon the other.

Meat

Answer 11

Orthogonality means the degree to which language consists of a set of independent primitive constructs that can be combined as necessary to express a program. Features are orthogonal if there are no restrictions on how they may be combined

Example : non-orthogonality

PASCAL: functions can't return structured types. Functional Languages are highly orthogonal.

Portia

Answer 12

Real life examples of orthogonality in programming languages

There are a lot of answers already that explain what orthogonality generally is while specifying some made up examples. E.g. this answer explains it well. I wanted to provide (and gather) some real life examples of orthogonal or non-orthogonal features in programming languages:

Orthogonal: C++20 Modules and Namespaces

On the cppreference-page about the new Modules system in c++20 is written:

Modules are orthogonal to namespaces

In this case they write that modules are orthogonal to namespaces because a statement like import foo will not import the module-namespace related to foo:

import foo;            // foo exports foo::bar()
bar ();                // Error
foo::bar ();           // Ok
using namespace foo;
bar ();                // Ok

(adapted from modules-cppcon2017 slide 9)

Gregg

Answer 13

From Michael C. Feathers' book "Working Effectively With Legacy Code":

If you want to change existing behavior in your code and there is exactly one place you have to go to make that change, you've got orthogonality.

Repentant

Answer 14

Orthogonality is the idea that things that are not related conceptually should not be related in the system so parts of the architecture that have nothing to do with each other, like the database and UI should not be changed together. A change to one part of your system should not cause the change to the other.

If for example, you change a few lines on the screen and cause a change in the database schema, this is called coupling. You usually want to minimize coupling between things that are mostly unrelated because it can grow and the system can become a nightmare to maintain in the long run.

Osset

A link to a solution is welcome, but please ensure your answer is useful without it: add context around the link so your fellow users will have some idea what it is and why it’s there, then quote the most relevant part of the page you're linking to in case the target page is unavailable. Answers that are little more than a link may be deleted. – Bullbat

@Osset do you know what a community wiki means? – Galvanoscope

Answer 15

In programming languages a programming language feature is said to be orthogonal if it is bounded with no restrictions (or exceptions). For example, in Pascal functions can't return structured types. This is a restriction on returning values from a function. Therefore we it is considered as a non-orthogonal feature. ;)

Illconsidered

Answer 16

Orthogonality in Programming:

Orthogonality is an important concept, addressing how a relatively small number of components can be combined in a relatively small number of ways to get the desired results. It is associated with simplicity; the more orthogonal the design, the fewer exceptions. This makes it easier to learn, read and write programs in a programming language. The meaning of an orthogonal feature is independent of context; the key parameters are symmetry and consistency (for example, a pointer is an orthogonal concept).

from Wikipedia

Factotum

Answer 17

Orthogonality in a programming language means that a relatively small set of primitive constructs can be combined in a relatively small number of ways to build the control and data structures of the language. Furthermore, every pos- sible combination of primitives is legal and meaningful. For example, consider data types. Suppose a language has four primitive data types (integer, float, double, and character) and two type operators (array and pointer). If the two type operators can be applied to themselves and the four primitive data types, a large number of data structures can be defined. The meaning of an orthogonal language feature is independent of the context of its appearance in a program. (the word orthogonal comes from the mathematical concept of orthogonal vectors, which are independent of each other.) Orthogonality follows from a symmetry of relationships among primi- tives. A lack of orthogonality leads to exceptions to the rules of the language. For example, in a programming language that supports pointers, it should be possible to define a pointer to point to any specific type defined in the language. However, if pointers are not allowed to point to arrays, many potentially useful user-defined data structures cannot be defined. We can illustrate the use of orthogonality as a design concept by compar- ing one aspect of the assembly languages of the IBM mainframe computers and the VAX series of minicomputers. We consider a single simple situation: adding two 32-bit integer values that reside in either memory or registers and replacing one of the two values with the sum. The IBM mainframes have two instructions for this purpose, which have the forms

A Reg1, memory_cell
AR Reg1, Reg2

where Reg1 and Reg2 represent registers. The semantics of these are

Reg1 ← contents(Reg1) + contents(memory_cell)
Reg1 ← contents(Reg1) + contents(Reg2)

The VAX addition instruction for 32-bit integer values is

ADDL operand_1, operand_2

whose semantics is

operand_2 ← contents(operand_1) + contents(operand_2)

In this case, either operand can be a register or a memory cell. The VAX instruction design is orthogonal in that a single instruction can use either registers or memory cells as the operands. There are two ways to specify operands, which can be combined in all possible ways. The IBM design is not orthogonal. Only two out of four operand combinations possibilities are legal, and the two require different instructions, A and AR . The IBM design is more restricted and therefore less writable. For example, you cannot add two values and store the sum in a memory location. Furthermore, the IBM design is more difficult to learn because of the restrictions and the additional instruction. Orthogonality is closely related to simplicity: The more orthogonal the design of a language, the fewer exceptions the language rules require. Fewer exceptions mean a higher degree of regularity in the design, which makes the language easier to learn, read, and understand. Anyone who has learned a sig- nificant part of the English language can testify to the difficulty of learning its many rule exceptions (for example, i before e except after c).

Stirpiculture

Answer 18

The basic idea of orthogonality is that things that are not related conceptually should not be related in the system. Parts of the architecture that really have nothing to do with the other, such as the database and the UI, should not need to be changed together. A change to one should not cause a change to the other.

Primer