Programme d'ordinateur -Computer program

En programmation impérative , un programme informatique est une séquence d'instructions dans un langage de programmation qu'un ordinateur peut exécuter ou interpréter. En programmation déclarative , un programme informatique est un ensemble d'instructions. Un programme informatique est un composant d'un logiciel - qui comprend également la documentation et d'autres composants intangibles.

Un programme informatique sous sa forme lisible par l'homme est appelé code source . Le code source a besoin d'un autre programme informatique pour s'exécuter car les ordinateurs ne peuvent exécuter que leurs instructions machine natives . Par conséquent, le code source peut être traduit en instructions machine à l'aide du compilateur du langage . ( Les programmes en langage machine sont traduits à l'aide d'un assembleur .) Le fichier résultant est appelé un exécutable . Alternativement, le code source peut s'exécuter dans l' interpréteur du langage . Le langage de programmation Java se compile dans une forme intermédiaire qui est ensuite exécutée par un interpréteur Java .

Si l'exécutable est demandé pour exécution, le système d'exploitation le charge en mémoire et démarre un processus . L' unité centrale de traitement passera bientôt à ce processus afin de pouvoir récupérer, décoder, puis exécuter chaque instruction machine.

Si le code source est demandé pour exécution, le système d'exploitation charge l'interpréteur correspondant en mémoire et démarre un processus. L'interpréteur charge ensuite le code source en mémoire pour traduire et exécuter chaque instruction . L'exécution du code source est plus lente que l'exécution d'un exécutable. De plus, l'interpréteur doit être installé sur l'ordinateur.

Bonjour programme mondial

Le "Bonjour, monde!" programme est utilisé pour illustrer la syntaxe de base d'un langage . La syntaxe du langage interprété Basic (1964) a été intentionnellement limitée pour rendre le langage facile à apprendre. Par exemple, les variables ne sont pas déclarées avant d'être utilisées. De plus, les variables sont automatiquement initialisées à zéro. Voici un programme de base pour calculer la moyenne d' une liste de nombres :

10 INPUT "How many numbers to average?", A
20 FOR I = 1 TO A
30 INPUT "Enter number:", B
40 LET C = C + B
50 NEXT I
60 LET D = C/A
70 PRINT "The average is", D
80 END

Une fois les mécanismes de la programmation informatique de base maîtrisés, des langages plus sophistiqués et plus puissants sont disponibles pour construire de grands systèmes informatiques.

Histoire

Les améliorations dans le développement de logiciels sont le résultat d'améliorations du matériel informatique . À chaque étape de l'histoire du matériel, la tâche de la programmation informatique a radicalement changé.

Moteur analytique

La description de Lovelace de la note G.

En 1837, Charles Babbage s'inspire du métier de Jacquard pour tenter de construire la Machine Analytique . Les noms des composants de l'appareil de calcul ont été empruntés à l'industrie textile. Dans l'industrie textile, le fil était amené du magasin pour être broyé. L'appareil avait un "magasin" qui était une mémoire pour contenir 1 000 nombres de 50 chiffres décimaux chacun. Les numéros du "magasin" ont été transférés au "moulin" pour traitement. Il a été programmé à l'aide de deux jeux de cartes perforées. Un ensemble a dirigé l'opération et l'autre a saisi les variables. Cependant, après plus de 17 000 livres d'argent du gouvernement britannique, les milliers de roues dentées et d'engrenages n'ont jamais pleinement fonctionné ensemble.

Ada Lovelace a travaillé pour Charles Babbage pour créer une description du moteur analytique (1843). La description contenait la note G qui détaillait complètement une méthode de calcul des nombres de Bernoulli à l'aide du moteur analytique. Cette note est reconnue par certains historiens comme le premier programme informatique au monde.

Machine de Turing universelle

Machine de Turing universelle.svg

En 1936, Alan Turing a présenté la machine universelle de Turing - un dispositif théorique capable de modéliser chaque calcul. C'est une machine à états finis qui possède une bande de lecture/écriture infiniment longue. La machine peut déplacer la bande d'avant en arrière, en modifiant son contenu au fur et à mesure qu'elle exécute un algorithme . La machine démarre dans l'état initial, passe par une séquence d'étapes et s'arrête lorsqu'elle rencontre l'état d'arrêt. Tous les ordinateurs actuels sont Turing complets .

ENIAC

Glenn A. Beck change un tube à l'ENIAC.

L' Electronic Numerical Integrator And Computer (ENIAC) a été construit entre juillet 1943 et l'automne 1945. Il s'agissait d'un ordinateur polyvalent complet de Turing qui utilisait 17 468 tubes à vide pour créer les circuits . À la base, c'était une série de Pascalines câblées ensemble. Ses 40 unités pesaient 30 tonnes, occupaient 1 800 pieds carrés (167 m 2 ) et consommaient 650 $ par heure ( en monnaie des années 1940 ) en électricité lorsqu'elles étaient inactives. Il avait 20 accumulateurs en base 10 . La programmation de l'ENIAC a pris jusqu'à deux mois. Trois tables de fonction étaient sur roues et devaient être roulées sur des panneaux de fonction fixes. Les tables de fonction étaient connectées aux panneaux de fonction en branchant de lourds câbles noirs dans des tableaux de connexion . Chaque table de fonction avait 728 boutons rotatifs. La programmation de l'ENIAC impliquait également de régler certains des 3 000 commutateurs. Le débogage d'un programme prenait une semaine. Il a fonctionné de 1947 à 1955 à Aberdeen Proving Ground , calculant les paramètres de la bombe à hydrogène, prédisant les conditions météorologiques et produisant des tables de tir pour viser les canons d'artillerie.

Ordinateurs à programme enregistré

Au lieu de brancher des cordons et de tourner des interrupteurs, un ordinateur à programme enregistré charge ses instructions en mémoire tout comme il charge ses données en mémoire. En conséquence, l'ordinateur pouvait être programmé rapidement et effectuer des calculs à des vitesses très rapides. Presper Eckert et John Mauchly ont construit l'ENIAC. Les deux ingénieurs ont introduit le concept de programme enregistré dans une note de trois pages datée de février 1944. Plus tard, en septembre 1944, le Dr John von Neumann a commencé à travailler sur le projet ENIAC. Le 30 juin 1945, von Neumann a publié la première ébauche d'un rapport sur l'EDVAC qui assimile les structures de l'ordinateur aux structures du cerveau humain. La conception est devenue connue sous le nom d' architecture von Neumann . L'architecture a été simultanément déployée dans les constructions des ordinateurs EDVAC et EDSAC en 1949.

L' IBM System/360 (1964) était une ligne de six ordinateurs, chacun ayant la même architecture de jeu d'instructions . Le modèle 30 était le plus petit et le moins cher. Les clients pouvaient mettre à niveau et conserver le même logiciel d'application . Le modèle 75 était le plus haut de gamme. Chaque modèle System / 360 comportait une multiprogrammation - ayant plusieurs processus en mémoire à la fois. Lorsqu'un processus attendait input/output , un autre pouvait calculer.

IBM prévoyait que chaque modèle soit programmé à l'aide de PL/1 . Un comité a été formé qui comprenait des programmeurs COBOL , Fortran et ALGOL . L'objectif était de développer un langage complet, facile à utiliser, extensible et qui remplacerait Cobol et Fortran. Le résultat était un langage volumineux et complexe qui prenait beaucoup de temps à compiler .

Commutateurs pour la saisie manuelle sur un Data General Nova 3, fabriqué au milieu des années 1970

Les ordinateurs fabriqués jusqu'aux années 1970 avaient des commutateurs sur le panneau avant pour la programmation manuelle. Le programme informatique a été écrit sur papier pour référence. Une instruction était représentée par une configuration de paramètres marche/arrêt. Après avoir défini la configuration, un bouton d'exécution a été enfoncé. Ce processus a ensuite été répété. Les programmes informatiques étaient également saisis automatiquement via des bandes de papier ou des cartes perforées . Une fois le support chargé, l'adresse de départ a été définie via des commutateurs et le bouton d'exécution a été enfoncé.

très grande échelle d'intégration

Une matrice de circuit intégré VLSI .

Une étape majeure dans le développement de logiciels a été l'invention du circuit d'intégration à très grande échelle (VLSI) (1964). Après la Seconde Guerre mondiale , la technologie à base de tubes a été remplacée par des transistors à contact ponctuel (1947) et des transistors à jonction bipolaire (fin des années 1950) montés sur une carte de circuit imprimé . Au cours des années 1960 , l' industrie aérospatiale a remplacé le circuit imprimé par une puce de circuit intégré .

Robert Noyce , co-fondateur de Fairchild Semiconductor (1957) et d' Intel (1968), a réalisé une amélioration technologique pour affiner la production de transistors à effet de champ (1963). L'objectif est de modifier la résistivité et la conductivité électriques d'une jonction semi -conductrice . Tout d'abord, les minéraux silicatés naturels sont convertis en tiges de polysilicium à l'aide du procédé Siemens . Le procédé Czochralski convertit ensuite les tiges en un cristal de boule de silicium monocristallin . Le cristal est ensuite tranché finement pour former un substrat de plaquette . Le processus planaire de photolithographie intègre ensuite des transistors unipolaires, des condensateurs , des diodes et des résistances sur la plaquette pour construire une matrice de transistors métal-oxyde-semi-conducteur (MOS). Le transistor MOS est le composant principal des puces de circuits intégrés .

À l'origine, les puces de circuits intégrés avaient leur fonction définie lors de la fabrication. Au cours des années 1960, le contrôle du flux électrique a migré vers la programmation d'une matrice de mémoire morte (ROM). La matrice ressemblait à un réseau bidimensionnel de fusibles. Le processus d'intégration des instructions sur la matrice consistait à brûler les connexions inutiles. Il y avait tellement de connexions que les programmeurs du micrologiciel ont écrit un programme informatique sur une autre puce pour superviser la gravure. La technologie est devenue connue sous le nom de ROM programmable . En 1971, Intel a installé le programme informatique sur la puce et l'a nommé le microprocesseur Intel 4004 .

Le processeur IBM System/360 (1964) n'était pas un microprocesseur.

Les termes microprocesseur et unité centrale de traitement (CPU) sont désormais utilisés de manière interchangeable. Cependant, les processeurs sont antérieurs aux microprocesseurs. Par exemple, l ' IBM System / 360 (1964) avait un processeur composé de cartes de circuits imprimés contenant des composants discrets sur des substrats en céramique .

Sac État 8008

Représentation d'artiste du micro-ordinateur Intel 8008 de l'Université d'État de Sacramento (1972).

L'Intel 4004 (1971) était un microprocesseur 4 bits conçu pour exécuter la calculatrice Busicom . Cinq mois après sa sortie, Intel a lancé l' Intel 8008 , un microprocesseur 8 bits. Bill Pentz a dirigé une équipe à Sacramento State pour construire le premier micro-ordinateur utilisant Intel 8008 - le Sac State 8008 (1972). Son but était de stocker les dossiers médicaux des patients. L'ordinateur prenait en charge un système d'exploitation de disque pour exécuter un disque dur Memorex de 3 mégaoctets . Il avait un écran couleur et un clavier regroupés dans une seule console. Le système d'exploitation du disque a été programmé à l'aide du langage d'assemblage de base (BAL) d'IBM . L'application de dossiers médicaux a été programmée à l'aide d'un interpréteur BASIC . Cependant, l'ordinateur était une impasse évolutive car il était extrêmement coûteux. De plus, il a été construit dans un laboratoire universitaire public dans un but précis. Néanmoins, le projet a contribué au développement du jeu d' instructions Intel 8080 (1974) .

série x86

L' ordinateur personnel IBM d' origine (1981) utilisait un microprocesseur Intel 8088.

En 1978, l'environnement de développement logiciel moderne a commencé lorsqu'Intel a mis à niveau l' Intel 8080 vers l' Intel 8086 . Intel a simplifié l'Intel 8086 pour fabriquer l' Intel 8088 moins cher . IBM a adopté l'Intel 8088 lorsqu'il est entré sur le marché des ordinateurs personnels (1981). À mesure que la demande des consommateurs pour les ordinateurs personnels augmentait, le développement des microprocesseurs d'Intel augmentait également. La succession de développement est connue sous le nom de série x86 . Le langage d'assemblage x86 est une famille d' instructions machine rétrocompatibles . Les instructions machine créées dans les microprocesseurs antérieurs ont été conservées tout au long des mises à niveau du microprocesseur. Cela a permis aux consommateurs d'acheter de nouveaux ordinateurs sans avoir à acheter de nouveaux logiciels d'application . Les principales catégories d'instructions sont les suivantes :

Environnement de programmation

Les circuits VLSI ont permis à l' environnement de programmation de passer d'un terminal informatique (jusqu'aux années 1990) à un ordinateur à interface utilisateur graphique (GUI). Les terminaux informatiques limitaient les programmeurs à un seul shell s'exécutant dans un environnement de ligne de commande . Au cours des années 1970, l'édition de code source en plein écran est devenue possible grâce à une interface utilisateur textuelle . Quelle que soit la technologie disponible, le but est de programmer dans un langage de programmation .

Langages de programmation

Un langage de programmation est un ensemble de mots- clés , de symboles , d' identificateurs et de règles par lesquels les programmeurs peuvent communiquer des instructions à l'ordinateur. Ils suivent un ensemble de règles appelées une syntaxe .

Les langages de programmation tirent leur base des langages formels . Le but de définir une solution en termes de langage formel est de générer un algorithme pour résoudre le problème sous-jacent. Un algorithme est une séquence d'instructions simples qui résout un problème.

Générations de langage de programmation

L'évolution du langage de programmation a commencé lorsque l' EDSAC (1949) a utilisé le premier programme informatique stocké dans son architecture von Neumann . La programmation de l'EDSAC était dans la première génération de langage de programmation .

  • La structure de base d'une instruction en langage assembleur est l'étiquette, l'opération, l'opérande et le commentaire.
  • Les étiquettes permettent au programmeur de travailler avec des noms de variables . L'assembleur traduira plus tard les étiquettes en adresses de mémoire physique .
  • Les opérations permettent au programmeur de travailler avec des mnémoniques. L'assembleur traduira plus tard les mnémoniques en numéros d'instruction.
  • Les opérandes indiquent à l'assembleur quelles données l'opération va traiter.
  • Les commentaires permettent au programmeur d'articuler un récit car les instructions seules sont vagues.
La principale caractéristique d'un programme en langage assembleur est qu'il forme un mappage un à un avec sa cible de langage machine correspondante.
  • La troisième génération de langage de programmation utilise des compilateurs et des interpréteurs pour exécuter des programmes informatiques. La caractéristique distinctive d'un langage de troisième génération est son indépendance vis-à-vis d'un matériel particulier. Ils ont commencé avec les langages Fortran (1958), COBOL (1959), ALGOL (1960) et BASIC (1964). En 1973, le langage de programmation C est apparu comme un langage de haut niveau qui produisait des instructions efficaces en langage machine. Alors que les langages de troisième génération ont historiquement généré de nombreuses instructions machine pour chaque instruction, C a des instructions qui peuvent générer une seule instruction machine. De plus, un compilateur d'optimisation peut annuler le programmeur et produire moins d'instructions machine que d'instructions. Aujourd'hui, tout un paradigme de langues remplit le spectre impératif de la troisième génération .

Langues impératives

Un programme informatique écrit dans un langage impératif

Les langages impératifs spécifient un algorithme séquentiel à l' aide de déclarations , d' expressions et d' instructions :

  • Une déclaration introduit un nom de variable dans le programme informatique et l'affecte à un type de données - par exemple :var x: integer;
  • Une expression donne une valeur – par exemple : 2 + 2donne 4
  • Une instruction peut affecter une expression à une variable ou utiliser la valeur d'une variable pour modifier le flux de contrôle du programme, par exemple :x := 2 + 2; if x = 4 then do_something();

Pour des exemples de langages impératifs, visitez Imperative_programming#Examples .

Langages déclaratifs

Les langages impératifs ont une critique majeure : l'affectation d'une expression à une variable non locale peut produire un effet secondaire imprévu . Les langages déclaratifs omettent généralement l'instruction d'affectation et le flux de contrôle. Ils décrivent quel calcul doit être effectué et non comment le calculer. Deux grandes catégories de langages déclaratifs sont les langages fonctionnels et les langages logiques .

En mathématiques, une fonction est une règle qui associe des éléments d'une expression à une plage de valeurs . Considérez la fonction :

times_10(x) = 10 * x

L' expression 10 * x est mappée par la fonction times_10()à une plage de valeurs . Une valeur se trouve être 20. Cela se produit lorsque x vaut 2. Ainsi, l'application de la fonction s'écrit mathématiquement comme suit :

times_10(2) = 20

Un compilateur de langage fonctionnel ne stockera pas cette valeur dans une variable. Au lieu de cela, il poussera la valeur sur la pile de l'ordinateur avant de remettre le compteur de programme à la fonction appelante. La fonction appelante extraira alors la valeur de la pile.

Les langages impératifs prennent en charge les fonctions. Par conséquent, la programmation fonctionnelle peut être réalisée dans un langage impératif, si le programmeur utilise la discipline. Cependant, un langage fonctionnel imposera cette discipline au programmeur par sa syntaxe. Les langages fonctionnels ont une syntaxe adaptée pour mettre l'accent sur le quoi .

Un programme fonctionnel est développé avec un ensemble de fonctions primitives suivi d'une seule fonction pilote. Considérez l' extrait :

function max(a,b){ /* code omitted */}

function min(a,b){ /* code omitted */}

function difference_between_largest_and_smallest(a,b,c) {

return max(a,max(b,c)) - min(a, min(b,c));

}

Les primitives sont max()et min(). La fonction du pilote est difference_between_largest_and_smallest(). Exécution :

put(difference_between_largest_and_smallest(10,4,7));produira 6.

Les langages fonctionnels sont utilisés dans la recherche en informatique pour explorer de nouvelles fonctionnalités linguistiques. De plus, leur absence d'effets secondaires les a rendus populaires dans la programmation parallèle et la programmation concurrente . Cependant, les développeurs d'applications préfèrent les fonctionnalités orientées objet des langages impératifs .

Pour des exemples de langages déclaratifs, visitez Declarative_programming#Examples .

Programmation informatique

Avant les langages de programmation, Betty Jennings et Fran Bilas ont programmé l' ENIAC en déplaçant les câbles et en réglant les commutateurs.

La programmation informatique (qui fait partie du développement logiciel et du génie logiciel ) est le processus d'écriture ou d'édition du code source . Dans un environnement formel, un analyste de systèmes recueillera des informations auprès des gestionnaires sur tous les processus de l'organisation à automatiser. Ce professionnel prépare ensuite un plan détaillé pour le système nouveau ou modifié. Le plan est analogue à un plan d'architecte.

Objectifs de performances

L'analyste de systèmes a pour objectif de fournir la bonne information à la bonne personne au bon moment. Les facteurs critiques pour atteindre cet objectif sont :

  1. La qualité de la sortie. Le résultat est-il utile à la prise de décision ?
  2. La précision de la sortie. Est-ce que cela reflète la situation réelle ?
  3. Le format de la sortie. La sortie est-elle facilement compréhensible ?
  4. La vitesse de sortie. Les informations sensibles au temps sont importantes lors de la communication avec le client en temps réel.

Objectifs de coût

La réalisation des objectifs de performance doit être équilibrée avec tous les coûts, y compris :

  1. Coûts de développement.
  2. Coûts d'unicité. Un système réutilisable peut être coûteux. Cependant, il pourrait être préféré à un système à usage limité.
  3. Coûts du matériel.
  4. Les coûts d'exploitation.

L'application d'un processus de développement de systèmes atténuera l'axiome : plus une erreur est détectée tard dans le processus, plus elle coûte cher à corriger.

Modèle cascade

Le modèle en cascade est une mise en œuvre d'un processus de développement de systèmes . Comme l'indique l' étiquette de la cascade , les phases de base se chevauchent :

  1. La phase d'investigation consiste à comprendre le problème sous-jacent.
  2. La phase d'analyse consiste à comprendre les solutions possibles.
  3. La phase de conception consiste à planifier la meilleure solution.
  4. La phase de mise en œuvre consiste à programmer la meilleure solution.
  5. La phase de maintenance dure tout au long de la vie du système. Des modifications du système après son déploiement peuvent être nécessaires. Des défauts peuvent exister, y compris des défauts de spécification, des défauts de conception ou des défauts de codage. Des améliorations peuvent être nécessaires. Une adaptation peut être nécessaire pour réagir à un environnement changeant.

Programmeur

Un programmeur informatique est un spécialiste chargé d'écrire ou de modifier le code source pour mettre en œuvre le plan détaillé. Une équipe de programmation sera probablement nécessaire car la plupart des systèmes sont trop volumineux pour être complétés par un seul programmeur. Cependant, l'ajout de programmeurs à un projet peut ne pas raccourcir le temps de réalisation. Au lieu de cela, cela peut réduire la qualité du système. Pour être efficaces, les modules du programme doivent être définis et distribués aux membres de l'équipe. De plus, les membres de l'équipe doivent interagir les uns avec les autres de manière significative et efficace.

La programmation à petite échelle est la programmation informatique dans un seul module. Il y a de fortes chances qu'un module exécute des modules situés dans d'autres fichiers de code source. La programmation à grande échelle consiste à concevoir des modules afin qu'ils se couplent efficacement les uns avec les autres.

Modules de programme

La programmation modulaire est une technique permettant d'affiner les programmes en langage impératif afin d'atténuer le vieillissement des logiciels . Un module de programme est une séquence d'instructions délimitées dans un bloc et identifiées ensemble par un nom. Les modules ont une fonction , un contexte et une logique :

  • La fonction d'un module est ce qu'il fait.
  • Le contexte d'un module sont les éléments en cours d'exécution.
  • La logique d'un module est la façon dont il exécute la fonction.

Le nom du module doit être dérivé d'abord par sa fonction , puis par son contexte . Sa logique ne devrait pas faire partie du nom. Par exemple, function compute_square_root( x )ou function compute_square_root_integer( i : integer )sont des noms de module appropriés. Cependant, function compute_square_root_by_division( x )ce n'est pas le cas.

Le degré d'interaction au sein d' un module est son niveau de cohésion . La cohésion est un jugement de la relation entre le nom d'un module et sa fonction . Le degré d'interaction entre les modules est le niveau de couplage . Le couplage est un jugement de la relation entre le contexte d'un module et les éléments sur lesquels il est exécuté.

Cohésion

Les niveaux de cohésion du pire au meilleur sont :

  • Cohésion coïncidente : un module a une cohésion coïncidente s'il remplit plusieurs fonctions, et les fonctions sont complètement indépendantes. Par exemple, function read_sales_record_print_next_line_convert_to_float(). La cohésion fortuite se produit dans la pratique si la direction applique des règles stupides. Par exemple, "Chaque module aura entre 35 et 50 instructions exécutables."
  • Cohésion logique : Un module a une cohésion logique s'il dispose d'une série de fonctions, mais qu'une seule d'entre elles est exécutée. Par exemple, function perform_arithmetic( perform_addition, a, b ).
  • Cohésion temporelle : Un module a une cohésion temporelle s'il remplit des fonctions liées au temps. Un exemple, function initialize_variables_and_open_files(). Autre exemple, stage_one(), stage_two(), ...
  • Cohésion procédurale : Un module a une cohésion procédurale s'il remplit plusieurs fonctions, mais seulement vaguement liées. Par exemple, function read_part_number_update_employee_record().
  • Cohésion communicationnelle : Un module a une cohésion communicationnelle s'il remplit plusieurs fonctions, mais étroitement liées. Par exemple, function read_part_number_update_sales_record().
  • Cohésion informationnelle : Un module a une cohésion informationnelle s'il remplit plusieurs fonctions, mais chaque fonction a ses propres points d'entrée et de sortie. De plus, les fonctions partagent la même structure de données. Les classes orientées objet fonctionnent à ce niveau.
  • Cohésion fonctionnelle : un module a une cohésion fonctionnelle s'il atteint un objectif unique en ne travaillant que sur des variables locales. De plus, il peut être réutilisable dans d'autres contextes.

Couplage

Les niveaux de couplage du pire au meilleur sont :

  • Couplage de contenu : Un module a un couplage de contenu s'il modifie une variable locale d'une autre fonction. COBOL avait l'habitude de le faire avec le verbe alter .
  • Couplage commun : Un module a un couplage commun s'il modifie une variable globale.
  • Couplage de contrôle : Un module a un couplage de contrôle si un autre module peut modifier son flux de contrôle . Par exemple, perform_arithmetic( perform_addition, a, b ). Au lieu de cela, le contrôle doit porter sur la composition de l'objet renvoyé.
  • Couplage de tampon : Un module a un couplage de tampon si un élément d'une structure de données passé en paramètre est modifié. Les classes orientées objet fonctionnent à ce niveau.
  • Couplage de données : Un module a un couplage de données si tous ses paramètres d'entrée sont nécessaires et qu'aucun d'entre eux n'est modifié. De plus, le résultat de la fonction est renvoyé sous la forme d'un objet unique.

Analyse des flux de données

Un exemple de diagramme de flux de données au niveau de la fonction.

L'analyse des flux de données est une méthode de conception utilisée pour réaliser des modules de cohésion fonctionnelle et de couplage de données . L'entrée de la méthode est un diagramme de flux de données . Un diagramme de flux de données est un ensemble d'ovales représentant des modules. Le nom de chaque module est affiché à l'intérieur de son ovale. Les modules peuvent être au niveau exécutable ou au niveau de la fonction.

Le diagramme comporte également des flèches reliant les modules les uns aux autres. Les flèches pointant vers les modules représentent un ensemble d'entrées. Chaque module ne doit avoir qu'une seule flèche pointant vers lui pour représenter son objet de sortie unique. (Facultativement, une flèche d'exception supplémentaire pointe.) Une chaîne d'ovales en guirlande transmettra un algorithme entier . Les modules d'entrée doivent démarrer le schéma. Les modules d'entrée doivent se connecter aux modules de transformation. Les modules de transformation doivent se connecter aux modules de sortie.

Programmation orientée objet

La programmation orientée objet consiste à exécuter des opérations ( fonctions ) sur des objets . L'idée de base est de regrouper les caractéristiques d'un phénomène dans un conteneur d'objets et de donner un nom au conteneur. Les opérations sur le phénomène sont également regroupées dans le conteneur. Programmation orientée objet développée en combinant le besoin de conteneurs et le besoin d'une programmation fonctionnelle sûre . Cette méthode de programmation n'a pas besoin d'être confinée à un langage orienté objet . Dans un langage orienté objet, un conteneur d'objets est appelé une classe . Dans un langage non orienté objet, une structure de données (également connue sous le nom d' enregistrement ) peut devenir un conteneur d'objets. Pour transformer une structure de données en un conteneur d'objets, les opérations doivent être écrites spécifiquement pour la structure. La structure résultante est appelée un type de données abstrait . Cependant, l' héritage sera absent. (Pour un point de référence, visitez Imperative_programming#C++ .) Néanmoins, cette lacune peut être surmontée.

Voici un fichier d'en-tête en langage de programmation C pour le type de données abstrait GRADE dans une application scolaire simple :

/* grade.h */
/* ------- */

/* Used to allow multiple source files to include */
/* this header file without duplication errors.   */
/* ---------------------------------------------- */
#ifndef GRADE_H
#define GRADE_H

typedef struct
{
    char letter;
} GRADE;

/* Constructor */
/* ----------- */
GRADE *grade_new( char letter );

int grade_numeric( char letter );
#endif

La grade_new()fonction exécute le même algorithme que l' opération du constructeur C++ .

Voici un fichier source en langage de programmation C pour le type de données abstrait GRADE dans une application scolaire simple :

/* grade.c */
/* ------- */
#include "grade.h"

GRADE *grade_new( char letter )
{
    GRADE *grade;

    /* Allocate heap memory */
    /* -------------------- */
    if ( ! ( grade = calloc( 1, sizeof( GRADE ) ) ) )
    {
        fprintf(stderr,
                "ERROR in %s/%s/%d: calloc() returned empty.\n",
                __FILE__,
                __FUNCTION__,
                __LINE__ );
        exit( 1 );
    }

    grade->letter = letter;
    return grade;
}

int grade_numeric( char letter )
{
    if ( ( letter == 'A' || letter == 'a' ) )
        return 4;
    else
    if ( ( letter == 'B' || letter == 'b' ) )
        return 3;
    else
    if ( ( letter == 'C' || letter == 'c' ) )
        return 2;
    else
    if ( ( letter == 'D' || letter == 'd' ) )
        return 1;
    else
    if ( ( letter == 'F' || letter == 'f' ) )
        return 0;
    else
        return -1;
}

Dans le constructeur, la fonction calloc()est utilisée à la place de malloc()car chaque cellule de mémoire sera définie sur zéro.

Voici un fichier d'en-tête en langage de programmation C pour le type de données abstrait PERSON dans une application scolaire simple :

/* person.h */
/* -------- */
#ifndef PERSON_H
#define PERSON_H

typedef struct
{
    char *name;
} PERSON;

/* Constructor */
/* ----------- */
PERSON *person_new( char *name );
#endif

Voici un fichier source en langage de programmation C pour le type de données abstrait PERSON dans une application scolaire simple :

/* person.c */
/* -------- */
#include "person.h"

PERSON *person_new( char *name )
{
    PERSON *person;

    if ( ! ( person = calloc( 1, sizeof( PERSON ) ) ) )
    {
        fprintf(stderr,
                "ERROR in %s/%s/%d: calloc() returned empty.\n",
                __FILE__,
                __FUNCTION__,
                __LINE__ );
        exit( 1 );
    }

    person->name = name;
    return person;
}

Voici un fichier d'en-tête du langage de programmation C pour le type de données abstrait STUDENT dans une application scolaire simple :

/* student.h */
/* --------- */
#ifndef STUDENT_H
#define STUDENT_H

#include "person.h"
#include "grade.h"

typedef struct
{
    /* A STUDENT is a subset of PERSON. */
    /* -------------------------------- */
    PERSON *person;

    GRADE *grade;
} STUDENT;

/* Constructor */
/* ----------- */
STUDENT *student_new( char *name );
#endif

Voici un fichier source en langage de programmation C pour le type de données abstrait STUDENT dans une application scolaire simple :

/* student.c */
/* --------- */
#include "student.h"
#include "person.h"

STUDENT *student_new( char *name )
{
    STUDENT *student;

    if ( ! ( student = calloc( 1, sizeof( STUDENT ) ) ) )
    {
        fprintf(stderr,
                "ERROR in %s/%s/%d: calloc() returned empty.\n",
                __FILE__,
                __FUNCTION__,
                __LINE__ );
        exit( 1 );
    }

    /* Execute the constructor of the PERSON superclass. */
    /* ------------------------------------------------- */
    student->person = person_new( name );
    return student;
}

Voici un programme pilote pour démonstration :

/* student_dvr.c */
/* ------------- */
#include <stdio.h>
#include "student.h"

int main( void )
{
    STUDENT *student = student_new( "The Student" );
    student->grade = grade_new( 'a' );

    printf( "%s: Numeric grade = %d\n",
            /* Whereas a subset exists, inheritance does not. */
            student->person->name,
            /* Functional programming is executing functions just-in-time (JIT) */
            grade_numeric( student->grade->letter ) );

	return 0;
}

Voici un makefile pour tout compiler :

# makefile
# --------
all: student_dvr

clean:
    rm student_dvr *.o

student_dvr: student_dvr.c grade.o student.o person.o
    gcc student_dvr.c grade.o student.o person.o -o student_dvr

grade.o: grade.c grade.h
    gcc -c grade.c

student.o: student.c student.h
    gcc -c student.c

person.o: person.c person.h
    gcc -c person.c

La stratégie formelle pour construire des objets orientés objet consiste à :

  • Identifiez les objets. Il s'agira très probablement de noms.
  • Identifiez les attributs de chaque objet. Qu'est-ce qui aide à décrire l'objet?
  • Identifiez les actions de chaque objet. Il s'agira très probablement de verbes.
  • Identifiez les relations d'un objet à l'autre. Il s'agira très probablement de verbes.

Par exemple:

  • Une personne est un être humain identifié par un nom.
  • Une note est une réalisation identifiée par une lettre.
  • Un étudiant est une personne qui obtient une note.

Catégories fonctionnelles

Un schéma montrant que l' utilisateur interagit avec le logiciel d'application . Le logiciel d'application interagit avec le système d'exploitation , qui interagit avec le matériel .

Les programmes informatiques peuvent être classés selon des lignes fonctionnelles. Les principales catégories fonctionnelles sont les logiciels d'application et les logiciels système . Le logiciel système comprend le système d'exploitation , qui associe le matériel informatique au logiciel d'application. L'objectif du système d'exploitation est de fournir un environnement dans lequel le logiciel d'application s'exécute de manière pratique et efficace. Le logiciel d'application et le logiciel système exécutent des programmes utilitaires . Au niveau matériel, un programme de microcode contrôle les circuits à travers l' unité centrale de traitement .

Logiciel d'application

Le logiciel d'application est la clé pour libérer le potentiel du système informatique. Le logiciel d'application d'entreprise regroupe les applications de comptabilité, de personnel, de client et de fournisseur. Les exemples incluent les logiciels de planification des ressources d'entreprise , de gestion de la relation client et de gestion de la chaîne d'approvisionnement .

Les applications d'entreprise peuvent être développées en interne sous la forme d'un logiciel propriétaire unique en son genre . Alternativement, ils peuvent être achetés en tant que logiciels prêts à l'emploi . Le logiciel acheté peut être modifié pour fournir un logiciel personnalisé . Si l'application est personnalisée, soit les ressources de l'entreprise sont utilisées, soit les ressources sont externalisées. Le développement de logiciels externalisé peut provenir du fournisseur de logiciels d'origine ou d'un développeur tiers.

Les avantages des logiciels propriétaires sont les fonctionnalités et les rapports peuvent être conformes aux spécifications. La direction peut également être impliquée dans le processus de développement et offrir un niveau de contrôle. La direction peut décider de contrecarrer la nouvelle initiative d'un concurrent ou de mettre en œuvre une exigence d'un client ou d'un fournisseur. Une fusion ou une acquisition nécessitera des changements de logiciels d'entreprise. Les inconvénients des logiciels propriétaires sont les coûts de temps et de ressources qui peuvent être considérables. De plus, des risques concernant les fonctionnalités et les performances peuvent se profiler.

Les avantages des logiciels prêts à l'emploi sont ses coûts initiaux identifiables, les besoins de base doivent être satisfaits, et ses performances et sa fiabilité ont fait leurs preuves. Les inconvénients des logiciels prêts à l'emploi sont qu'ils peuvent avoir des fonctionnalités inutiles qui déroutent les utilisateurs finaux, qu'ils peuvent manquer de fonctionnalités dont l'entreprise a besoin et que le flux de données peut ne pas correspondre aux processus de travail de l'entreprise.

Une approche pour obtenir économiquement une application d'entreprise personnalisée consiste à passer par un fournisseur de services applicatifs . Les entreprises spécialisées fournissent le matériel, les logiciels personnalisés et l'assistance aux utilisateurs finaux. Ils peuvent accélérer le développement de nouvelles applications car ils disposent d'un personnel compétent en matière de système d'information. Le plus grand avantage est qu'il libère les ressources internes de la dotation en personnel et de la gestion de projets informatiques complexes. De nombreux fournisseurs de services applicatifs ciblent les petites entreprises à croissance rapide avec des ressources système d'information limitées. D'autre part, les grandes entreprises dotées de systèmes majeurs auront probablement leur infrastructure technique en place. L'un des risques est de devoir confier à une organisation externe des informations sensibles. Un autre risque est de devoir faire confiance à la fiabilité de l'infrastructure du fournisseur.

Système opérateur

Un système d'exploitation est le logiciel de bas niveau qui prend en charge les fonctions de base d'un ordinateur, telles que la planification des processus et le contrôle des périphériques .

Dans les années 1950, le programmeur, qui était aussi l'opérateur, écrivait un programme et l'exécutait. Une fois l'exécution du programme terminée, la sortie peut avoir été imprimée ou perforée sur une bande de papier ou des cartes pour un traitement ultérieur. Le plus souvent, le programme ne fonctionnait pas. Le programmeur a ensuite regardé les lumières de la console et manipulé les commutateurs de la console. Si moins chanceux, une impression de mémoire a été faite pour une étude plus approfondie. Dans les années 1960, les programmeurs ont réduit le temps perdu en automatisant le travail de l'opérateur. Un programme appelé système d'exploitation était conservé dans l'ordinateur à tout moment.

Le terme système d'exploitation peut faire référence à deux niveaux de logiciel. Le système d'exploitation peut faire référence au programme du noyau qui gère les processus , la mémoire et les périphériques . Plus largement, le système d'exploitation peut faire référence à l'ensemble du logiciel central. Le package comprend un programme noyau, un interpréteur de ligne de commande , une interface utilisateur graphique , des programmes utilitaires et un éditeur .

Programme noyau

Un noyau connecte le logiciel d'application au matériel d'un ordinateur.

L'objectif principal du noyau est de gérer les ressources limitées d'un ordinateur :

La mémoire physique est dispersée autour de la RAM et du disque dur. La mémoire virtuelle est un bloc continu.
  • Lorsque le noyau charge initialement un exécutable en mémoire, il divise logiquement l'espace d'adressage en régions . Le noyau gère une table master-region et de nombreuses tables par région de processus (pregion) — une pour chaque processus en cours d'exécution . Ces tables constituent l' espace d'adressage virtuel . La table master-region est utilisée pour déterminer où se trouve son contenu dans la mémoire physique . Les tables de prérégion permettent à chaque processus d'avoir sa propre prérégion de programme (texte), prérégion de données et prérégion de pile.
  • La prérégion du programme stocke les instructions de la machine. Comme les instructions machine ne changent pas, la prérégion du programme peut être partagée par plusieurs processus du même exécutable.
  • Pour économiser du temps et de la mémoire, le noyau peut charger uniquement des blocs d'instructions d'exécution à partir du lecteur de disque, et non l'intégralité du fichier d'exécution.
  • Le noyau est responsable de la traduction des adresses virtuelles en adresses physiques . Le noyau peut demander des données au contrôleur de mémoire et, à la place, recevoir une erreur de page . Si tel est le cas, le noyau accède à l' unité de gestion de mémoire pour remplir la région de données physiques et traduire l'adresse.
  • Le noyau alloue de la mémoire à partir du tas à la demande d'un processus. Lorsque le processus en a terminé avec la mémoire, le processus peut demander sa libération . Si le processus se termine sans demander que toute la mémoire allouée soit libérée, le noyau effectue une récupération de place pour libérer la mémoire.
  • Le noyau garantit également qu'un processus n'accède qu'à sa propre mémoire, et non à celle du noyau ou d'autres processus.
  • Le programme du noyau doit effectuer la gestion du système de fichiers . Le noyau contient des instructions pour créer, récupérer, mettre à jour et supprimer des fichiers.
  • Le programme du noyau doit effectuer la gestion des périphériques . Le noyau fournit des programmes pour normaliser et simplifier l'interface avec la souris, le clavier, les lecteurs de disque, les imprimantes et d'autres périphériques. De plus, le noyau devrait arbitrer l'accès à un périphérique si deux processus le demandent en même temps.
  • Le programme du noyau doit effectuer la gestion du réseau . Le noyau transmet et reçoit des paquets au nom des processus. Un service clé consiste à trouver une route efficace vers le système cible.
  • Le programme du noyau doit fournir des fonctions au niveau du système que les programmeurs peuvent utiliser.
    • Les programmeurs accèdent aux fichiers via une interface relativement simple qui exécute à son tour une interface d'E/S de bas niveau relativement compliquée. L'interface de bas niveau comprend la création de fichiers, les descripteurs de fichiers, la recherche de fichiers, la lecture physique et l'écriture physique.
    • Les programmeurs créent des processus via une interface relativement simple qui exécute à son tour une interface de bas niveau relativement compliquée.
    • Les programmeurs effectuent l'arithmétique date/heure via une interface relativement simple qui exécute à son tour une interface temporelle de bas niveau relativement compliquée.
  • Le programme du noyau doit fournir un canal de communication entre les processus en cours d'exécution. Pour un grand système logiciel, il peut être souhaitable de concevoir le système en processus plus petits. Les processus peuvent communiquer entre eux en envoyant et en recevant des signaux .

A l'origine, les systèmes d'exploitation étaient programmés en assembleur ; cependant, les systèmes d'exploitation modernes sont généralement écrits dans des langages de niveau supérieur tels que C , Objective-C et Swift .

Programme utilitaire

Un programme utilitaire est conçu pour faciliter l'administration du système et l'exécution du logiciel. Les systèmes d'exploitation exécutent des programmes utilitaires matériels pour vérifier l'état des lecteurs de disque, de la mémoire, des haut-parleurs et des imprimantes. Un programme utilitaire peut optimiser le placement d'un fichier sur un disque encombré. Les programmes utilitaires système surveillent les performances du matériel et du réseau. Lorsqu'une métrique est en dehors d'une plage acceptable, une alerte de déclenchement est générée.

Les programmes utilitaires incluent des programmes de compression afin que les fichiers de données soient stockés sur moins d'espace disque. Les programmes compressés permettent également de gagner du temps lors de la transmission des fichiers de données sur le réseau. Les programmes utilitaires peuvent trier et fusionner des ensembles de données. Les programmes utilitaires détectent les virus informatiques .

Programme de microcode

PAS porte.
Porte NAND.
Porte NOR.
Porte ET.
OU porte.

Un programme de microcode est l'interpréteur de niveau inférieur qui contrôle le chemin des données des ordinateurs pilotés par logiciel. (Les progrès du matériel ont fait migrer ces opérations vers des circuits d'exécution matériels .) Les instructions de microcode permettent au programmeur d'implémenter plus facilement le niveau logique numérique - le matériel réel de l'ordinateur. Le niveau logique numérique est la frontière entre l'informatique et l'ingénierie informatique .

Une porte logique est un petit transistor qui peut renvoyer l'un des deux signaux suivants : activé ou désactivé.

  • Avoir un transistor forme la porte NOT .
  • La connexion de deux transistors en série forme la porte NAND .
  • La connexion de deux transistors en parallèle forme la porte NOR .
  • La connexion d'une porte NON à une porte NAND forme la porte ET .
  • La connexion d'une porte NOT à une porte NOR forme la porte OR .

Ces cinq portes forment les blocs de construction de l'algèbre binaire - les fonctions logiques numériques de l'ordinateur.

Les instructions de microcode sont des mnémoniques que les programmeurs peuvent utiliser pour exécuter des fonctions logiques numériques au lieu de les former en algèbre binaire. Ils sont stockés dans la mémoire de contrôle d'une unité centrale de traitement (CPU) . Ces instructions de niveau matériel déplacent les données tout au long du chemin de données .

Le cycle de micro-instruction commence lorsque le micro- séquenceur utilise son compteur de microprogramme pour extraire la prochaine instruction machine de la mémoire vive . L'étape suivante consiste à décoder l'instruction machine en sélectionnant la ligne de sortie appropriée vers le module matériel. La dernière étape consiste à exécuter l'instruction à l'aide de l'ensemble de portes du module matériel.

Une représentation symbolique d'un ALU.

Les instructions pour effectuer l'arithmétique sont passées par une unité logique arithmétique (ALU). L'ALU a des circuits pour effectuer des opérations élémentaires pour additionner, décaler et comparer des nombres entiers. En combinant et en bouclant les opérations élémentaires à travers l'ALU, le CPU effectue son arithmétique complexe.

Les instructions de microcode déplacent les données entre le CPU et le contrôleur de mémoire . Les instructions du microcode du contrôleur de mémoire manipulent deux registres . Le registre d'adresse mémoire est utilisé pour accéder à l'adresse de chaque cellule mémoire. Le registre de données de mémoire est utilisé pour définir et lire le contenu de chaque cellule.

Les instructions de microcode déplacent les données entre le CPU et les nombreux bus informatiques . Le bus du contrôleur de disque écrit et lit sur les disques durs . Les données sont également déplacées entre la CPU et d'autres unités fonctionnelles via le bus express d'interconnexion de composants périphériques.

Remarques

Références