Qu'est-ce que l '«orthogonalité»?

Que signifie «orthogonalité» quand on parle de langages de programmation?

Quels sont quelques exemples d'orthogonalité?

L'orthogonalité est la propriété qui signifie "Changer A ne change pas B". Un exemple de système orthogonal serait une radio, où le changement de station ne change pas le volume et vice-versa.

Un système non orthogonal serait comme un hélicoptère où changer la vitesse peut changer la direction.

Dans les langages de programmation, cela signifie que lorsque vous exécutez une instruction, rien d'autre que cette instruction ne se produit (très important pour le débogage).

Il y a aussi une signification spécifique en se référant aux jeux d'instructions .

Tiré de «L'art de la programmation UNIX» d' Eric S. Raymond

L'orthogonalité est l'une des propriétés les plus importantes qui peuvent aider à rendre compacts même les conceptions complexes. Dans une conception purement orthogonale, les opérations n'ont pas d'effets secondaires; chaque action (qu'il s'agisse d'un appel d'API, d'un appel de macro ou d'une opération de langage) ne change qu'une chose sans affecter les autres. Il existe une et une seule façon de modifier chaque propriété du système que vous contrôlez.

Pensez-y a être capable de changer une chose sans avoir un effet invisible sur une autre partie.

Si vous avez un ensemble de constructions. Une langauge est dite orthogonale si elle permet au programmeur de mélanger librement ces constructions. Par exemple, en C, vous ne pouvez pas renvoyer un tableau (tableau statique), C est dit non-cognitif dans ce cas:

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.

En gros, l'orthogonalité est une relation entre deux choses telles qu'elles ont un effet minimal l'une sur l'autre.

Le terme vient des mathématiques, où deux vecteurs sont orthogonaux s'ils se croisent à angle droit.

Pensez à un espace cartésien à 2 dimensions typique (votre grille typique avec les axes X / Y). Tracez deux lignes: x = 1 et y = 1. Les deux lignes sont orthogonales. Vous pouvez changer x = 1 en changeant x, et cela n'aura aucun effet sur l'autre ligne, et vice versa.

Dans les logiciels, le terme peut être utilisé de manière appropriée dans des situations où vous parlez de deux parties d'un système qui se comportent indépendamment l'une de l'autre.

La plupart des réponses sont très longues et même obscures. Le fait est que si un outil est orthogonal, il peut être ajouté, remplacé ou supprimé, au profit de meilleurs outils, sans tout visser.

C'est la différence entre un charpentier ayant un marteau et une scie, qui peut être utilisé pour marteler ou scier, ou avoir un nouveau combo marteau / scie, conçu pour scier le bois, puis le marteler ensemble. Les deux fonctionneront pour scier puis marteler ensemble, mais si vous obtenez une tâche qui nécessite le sciage, mais pas le martelage, seuls les outils orthogonaux fonctionneront. De même, si vous devez visser au lieu de marteler, vous n'aurez pas besoin de jeter votre scie, si elle est orthogonale (non mélangée avec) votre marteau.

L'exemple classique est celui des outils de ligne de commande unix: vous avez un outil pour obtenir le contenu d'un disque (dd), un autre pour filtrer les lignes du fichier (grep), un autre pour écrire ces lignes dans un fichier (cat), etc. peuvent tous être mélangés et assortis à volonté.

Lorsque vous parlez de décisions de projet sur les langages de programmation, l'orthogonalité peut être considérée comme la facilité avec laquelle vous pouvez prédire d'autres choses sur ce langage pour ce que vous avez vu dans le passé.

Par exemple, dans une langue, vous pouvez avoir:

str.split

pour diviser une chaîne et

len (str)

pour avoir la longueur.

Sur un langage plus orthogonal, vous utiliseriez toujours str.x ou x (str).

Lorsque vous cloneriez un objet ou feriez autre chose, vous saurez s'il faut utiliser

cloner (obj)

ou

obj.clone

C'est l'un des principaux points sur le fait que les langages de programmation sont orthogonaux. Cela vous évite de consulter le manuel ou de demander à quelqu'un.

L'article de wikipedia parle davantage de l'orthogonalité sur des conceptions complexes ou des langages de bas niveau. Comme quelqu'un l'a suggéré ci-dessus sur un commentaire, le livre Sebesta parle proprement d'orthogonalité.

Si je n'utiliserais qu'une seule phrase, je dirais qu'un langage de programmation est orthogonal lorsque ses parties inconnues agissent comme prévu en fonction de ce que vous avez vu. Ou ... pas de surprises.

;)

de wikipedia :

L'informatique

L'orthogonalité est une propriété de conception de système facilitant la faisabilité et la compacité des conceptions complexes. L'orthogonalité garantit que la modification de l'effet technique produit par un composant d'un système ne crée ni ne propage d'effets secondaires à d'autres composants du système. Le comportement émergent d'un système composé de composants doit être strictement contrôlé par des définitions formelles de sa logique et non par des effets secondaires résultant d'une mauvaise intégration, c'est-à-dire une conception non orthogonale des modules et des interfaces. L'orthogonalité réduit le temps de test et de développement car il est plus facile de vérifier les conceptions qui ne provoquent pas d'effets secondaires et ne dépendent pas d'eux.

Par exemple, une voiture a des composants et des commandes orthogonales (par exemple, l'accélération du véhicule n'influence rien d'autre que les composants impliqués exclusivement dans la fonction d'accélération). D'un autre côté, une conception non orthogonale peut avoir une influence de sa direction sur son freinage (par exemple, contrôle électronique de stabilité), ou sa vitesse modifie sa suspension. 1 Par conséquent, cet usage est considéré comme dérivé de l'utilisation de l'orthogonale en mathématiques: on peut projeter un vecteur sur un sous-espace en le projetant sur chaque membre d'un ensemble de vecteurs de base séparément et en ajoutant les projections si et seulement si les vecteurs de base sont mutuellement orthogonales.

Un jeu d'instructions est dit orthogonal si une instruction peut utiliser n'importe quel registre dans n'importe quel mode d'adressage. Cette terminologie résulte du fait de considérer une instruction comme un vecteur dont les composantes sont les champs d'instruction. Un champ identifie les registres à exploiter et un autre spécifie le mode d'adressage. Un jeu d'instructions orthogonales code de manière unique toutes les combinaisons de registres et de modes d'adressage.

De Wikipedia :

L'orthogonalité est une propriété de conception de système facilitant la faisabilité et la compacité des conceptions complexes. L'orthogonalité garantit que la modification de l'effet technique produit par un composant d'un système ne crée ni ne propage d'effets secondaires à d'autres composants du système. Le comportement émergent d'un système composé de composants doit être strictement contrôlé par des définitions formelles de sa logique et non par des effets secondaires résultant d'une mauvaise intégration, c'est-à-dire d'une conception non orthogonale des modules et des interfaces. L'orthogonalité réduit le temps de test et de développement car il est plus facile de vérifier les conceptions qui ne provoquent pas d'effets secondaires et ne dépendent pas d'eux.

Par exemple, une voiture a des composants et des commandes orthogonales (par exemple, l'accélération du véhicule n'influence rien d'autre que les composants impliqués exclusivement dans la fonction d'accélération). D'un autre côté, une conception non orthogonale peut avoir une influence de sa direction sur son freinage (par exemple, contrôle électronique de stabilité), ou sa vitesse modifie sa suspension. [1] Par conséquent, cet usage est perçu comme dérivé de l'utilisation de l'orthogonale en mathématiques: on peut projeter un vecteur sur un sous-espace en le projetant sur chaque membre d'un ensemble de vecteurs de base séparément et en ajoutant les projections si et seulement si les vecteurs de base sont mutuellement orthogonales.

Un jeu d'instructions est dit orthogonal si une instruction peut utiliser n'importe quel registre dans n'importe quel mode d'adressage. Cette terminologie résulte du fait de considérer une instruction comme un vecteur dont les composantes sont les champs d'instruction. Un champ identifie les registres à exploiter et un autre spécifie le mode d'adressage. Un jeu d'instructions orthogonales code de manière unique toutes les combinaisons de registres et de modes d'adressage.

Pour le dire le plus simplement possible, deux choses sont orthogonales si la modification de l'une n'a aucun effet sur l'autre.

Comme exemples du manque d'orthogonalité dans un langage de haut niveau, considérez les règles et exceptions suivantes en C.Bien que C ait deux types de types de données structurées, les tableaux et les enregistrements (structs), les enregistrements peuvent être retournés à partir de fonctions, mais pas les tableaux. Un membre d'une structure peut être de n'importe quel type de données sauf void ou une structure du même type. Un élément de tableau peut être de n'importe quel type de données sauf void ou une fonction. Les paramètres sont passés par valeur, à moins qu'il ne s'agisse de tableaux, auquel cas ils sont, en fait, passés par référence (car l'apparence d'un nom de tableau sans indice dans un programme C est interprétée comme l'adresse du premier élément du tableau)

Dans les langages de programmation, une caractéristique du langage de programmation est dite orthogonale si elle est bornée sans restrictions (ou exceptions). Par exemple, en Pascal, les fonctions ne peuvent pas renvoyer de types structurés. Il s'agit d'une restriction sur le renvoi de valeurs à partir d'une fonction. Par conséquent, nous il est considéré comme une caractéristique non orthogonale. ;)

Orthogonalité dans la programmation:

L'orthogonalité est un concept important, qui traite de la manière dont un nombre relativement petit de composants peut être combiné de manière relativement restreinte pour obtenir les résultats souhaités. Il est associé à la simplicité; plus la conception est orthogonale, moins il y a d'exceptions. Cela facilite l'apprentissage, la lecture et l'écriture de programmes dans un langage de programmation. La signification d'une caractéristique orthogonale est indépendante du contexte; les paramètres clés sont la symétrie et la cohérence (par exemple, un pointeur est un concept orthogonal).

de Wikipedia

L'orthogonalité dans un langage de programmation signifie qu'un ensemble relativement petit de constructions primitives peut être combiné d'un nombre relativement restreint de façons pour construire les structures de contrôle et de données du langage. De plus, chaque combinaison possible de primitives est légale et significative. Par exemple, considérez les types de données. Supposons qu'un langage ait quatre types de données primitifs (entier, flottant, double et caractère) et deux opérateurs de type (tableau et pointeur). Si les deux opérateurs de type peuvent être appliqués à eux-mêmes et aux quatre types de données primitifs, un grand nombre de structures de données peuvent être définies. La signification d'une caractéristique orthogonale du langage est indépendante du contexte de son apparition dans un programme. (le mot orthogonal vient du concept mathématique de vecteurs orthogonaux, qui sont indépendants les uns des autres. ) L'orthogonalité découle d'une symétrie des relations entre les primitives. Un manque d'orthogonalité conduit à des exceptions aux règles de la langue. Par exemple, dans un langage de programmation qui prend en charge les pointeurs, il devrait être possible de définir un pointeur pour pointer vers n'importe quel type spécifique défini dans le langage. Cependant, si les pointeurs ne sont pas autorisés à pointer vers des tableaux, de nombreuses structures de données potentiellement utiles définies par l'utilisateur ne peuvent pas être définies. Nous pouvons illustrer l'utilisation de l'orthogonalité comme concept de conception en comparant un aspect des langages d'assemblage des ordinateurs mainframe IBM et de la série VAX de mini-ordinateurs. Nous considérons une seule situation simple: ajouter deux valeurs entières de 32 bits qui résident dans la mémoire ou dans les registres et remplacer l'une des deux valeurs par la somme. Les mainframes IBM ont deux instructions à cet effet,

A Reg1, memory_cell
AR Reg1, Reg2

où Reg1 et Reg2 représentent des registres. La sémantique de ceux-ci est

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

L'instruction d'ajout VAX pour les valeurs entières 32 bits est

ADDL operand_1, operand_2

dont la sémantique est

operand_2 ← contents(operand_1) + contents(operand_2)

Dans ce cas, l'un ou l'autre des opérandes peut être un registre ou une cellule mémoire. La conception de l'instruction VAX est orthogonale en ce qu'une seule instruction peut utiliser des registres ou des cellules de mémoire comme opérandes. Il existe deux façons de spécifier des opérandes, qui peuvent être combinés de toutes les manières possibles. La conception IBM n'est pas orthogonale. Seules deux possibilités de combinaisons d'opérandes sur quatre sont légales et les deux nécessitent des instructions différentes, A et AR. La conception IBM est plus restreinte et donc moins accessible en écriture. Par exemple, vous ne pouvez pas ajouter deux valeurs et stocker la somme dans un emplacement mémoire. De plus, la conception IBM est plus difficile à apprendre en raison des restrictions et des instructions supplémentaires. L'orthogonalité est étroitement liée à la simplicité: plus la conception d'un langage est orthogonale, moins les règles de langage nécessitent d'exceptions. Moins d'exceptions signifient un degré plus élevé de régularité dans la conception, ce qui facilite l'apprentissage, la lecture et la compréhension de la langue. Quiconque a appris une partie importante de la langue anglaise peut témoigner de la difficulté d'apprendre ses nombreuses exceptions aux règles (par exemple, i avant e sauf après c).

L'orthogonalité signifie le degré auquel le langage se compose d'un ensemble de constructions primitives indépendantes qui peuvent être combinées si nécessaire pour exprimer un programme. Les entités sont orthogonales s'il n'y a aucune restriction sur la façon dont elles peuvent être combinées

Example : non-orthogonality

PASCAL: les fonctions ne peuvent pas retourner de types structurés. Les langages fonctionnels sont hautement orthogonaux.

L'idée de base de l'orthogonalité est que les choses qui ne sont pas liées conceptuellement ne devraient pas être liées dans le système. Les parties de l'architecture qui n'ont vraiment rien à voir avec l'autre, telles que la base de données et l'interface utilisateur, ne devraient pas avoir besoin d'être modifiées ensemble. Une modification de l'un ne devrait pas entraîner une modification de l'autre.

Vérifier l'orthogonalité des matrices:

L'orthogonalité peut également concerner les matrices,

Matrix *(transpose of matrix)= identity matrix. 

Cliquez sur le lien ci-dessous pour visionner une vidéo YouTube sur l'orthogonalité.
https://youtu.be/tNekLaxnfW8