Computer Programm -Computer program

Bei der imperativen Programmierung ist ein Computerprogramm eine Folge von Anweisungen in einer Programmiersprache , die ein Computer ausführen oder interpretieren kann. In der deklarativen Programmierung ist ein Computerprogramm eine Reihe von Anweisungen. Ein Computerprogramm ist eine Komponente von Software – die auch Dokumentation und andere immaterielle Komponenten umfasst.

Ein Computerprogramm in seiner für Menschen lesbaren Form wird als Quellcode bezeichnet . Der Quellcode benötigt zur Ausführung ein anderes Computerprogramm, da Computer nur ihre nativen Maschinenanweisungen ausführen können . Daher kann der Quellcode unter Verwendung des Compilers der Sprache in Maschinenanweisungen übersetzt werden . ( Maschinensprachliche Programme werden mit einem Assembler übersetzt .) Die resultierende Datei wird als ausführbare Datei bezeichnet . Alternativ kann der Quellcode im Interpreter der Sprache ausgeführt werden . Die Programmiersprache Java kompiliert in eine Zwischenform, die dann von einem Java-Interpreter ausgeführt wird .

Wenn die ausführbare Datei zur Ausführung angefordert wird , lädt das Betriebssystem sie in den Arbeitsspeicher und startet einen Prozess . Die zentrale Verarbeitungseinheit wird bald auf diesen Prozess umschalten , damit sie jeden Maschinenbefehl abrufen, dekodieren und dann ausführen kann.

Wird der Quellcode zur Ausführung angefordert, lädt das Betriebssystem den entsprechenden Interpreter in den Speicher und startet einen Prozess. Der Interpreter lädt dann den Quellcode in den Speicher, um jede Anweisung zu übersetzen und auszuführen . Das Ausführen des Quellcodes ist langsamer als das Ausführen einer ausführbaren Datei. Außerdem muss der Interpreter auf dem Rechner installiert sein.

Hallo-Welt-Programm

Das "Hallo, Welt!" Programm wird verwendet, um die grundlegende Syntax einer Sprache zu veranschaulichen . Die Syntax der interpretierten Sprache Basic (1964) wurde bewusst eingeschränkt, um die Sprache leicht erlernbar zu machen. Beispielsweise werden Variablen nicht deklariert , bevor sie verwendet werden. Außerdem werden Variablen automatisch auf Null initialisiert. Hier ist ein einfaches Programm, um eine Liste von Zahlen zu mitteln :

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

Sobald die Mechanik der grundlegenden Computerprogrammierung erlernt ist, stehen anspruchsvollere und leistungsfähigere Sprachen zur Verfügung, um große Computersysteme zu bauen.

Geschichte

Verbesserungen in der Softwareentwicklung sind das Ergebnis von Verbesserungen in der Computerhardware . In jeder Phase der Geschichte der Hardware änderte sich die Aufgabe der Computerprogrammierung dramatisch.

Analytische Engine

Lovelaces Beschreibung aus Note G.

1837 ließ sich Charles Babbage von Jacquards Webstuhl inspirieren, um zu versuchen, die Analytical Engine zu bauen . Die Namen der Komponenten des Rechengeräts wurden der Textilindustrie entlehnt. In der Textilindustrie wurde Garn aus dem Lager zum Walken gebracht. Das Gerät hatte einen "Speicher", der Speicher für 1.000 Zahlen mit jeweils 50 Dezimalstellen war. Nummern aus dem "Laden" wurden zur Verarbeitung in die "Mühle" übertragen. Es wurde mit zwei Sätzen perforierter Karten programmiert. Ein Satz leitete die Operation und der andere Satz gab die Variablen ein. Nach mehr als 17.000 Pfund britischer Regierungsgelder funktionierten die Tausenden von Zahnrädern und Zahnrädern jedoch nie vollständig zusammen.

Ada Lovelace arbeitete für Charles Babbage, um eine Beschreibung der Analytical Engine (1843) zu erstellen. Die Beschreibung enthielt Anmerkung G, in der eine Methode zur Berechnung von Bernoulli-Zahlen mit der Analytical Engine vollständig beschrieben wurde. Diese Notiz wird von einigen Historikern als das erste Computerprogramm der Welt anerkannt.

Universelle Turing-Maschine

Universelle Turing-Maschine.svg

1936 führte Alan Turing die Universal Turing Machine ein – ein theoretisches Gerät, das jede Berechnung modellieren kann. Es ist eine endliche Maschine , die ein unendlich langes Lese-/Schreibband hat. Die Maschine kann das Band hin und her bewegen und seinen Inhalt ändern, während sie einen Algorithmus ausführt . Die Maschine startet im Anfangszustand, durchläuft eine Folge von Schritten und hält an, wenn sie auf den Haltezustand stößt. Alle heutigen Computer sind Turing-komplett .

ENIAC

Glenn A. Beck wechselt eine Röhre in ENIAC.

Der Electronic Numerical Integrator And Computer (ENIAC) wurde zwischen Juli 1943 und Herbst 1945 gebaut. Es war ein vollständiger Allzweckcomputer von Turing , der 17.468 Vakuumröhren verwendete , um die Schaltkreise zu erstellen . Im Kern war es eine Reihe von Pascalines , die miteinander verdrahtet waren. Seine 40 Einheiten wogen 30 Tonnen, belegten 1.800 Quadratfuß (167 m 2 ) und verbrauchten im Leerlauf 650 US-Dollar pro Stunde ( in der Währung der 1940er Jahre ) an Strom. Es hatte 20 Basis-10- Akkumulatoren . Die Programmierung des ENIAC dauerte bis zu zwei Monate. Drei Funktionstische waren auf Rädern und mussten zu festen Funktionsplatten gerollt werden. Funktionstische wurden mit Funktionstafeln verbunden, indem schwere schwarze Kabel in Steckbretter gesteckt wurden . Jeder Funktionstisch hatte 728 Drehknöpfe. Zur Programmierung des ENIAC gehörte auch die Einstellung einiger der 3.000 Schalter. Das Debuggen eines Programms dauerte eine Woche. Es lief von 1947 bis 1955 auf dem Aberdeen Proving Ground , berechnete Wasserstoffbombenparameter, sagte Wettermuster voraus und erstellte Schießtabellen, um Artilleriegeschütze auszurichten.

Computer mit gespeicherten Programmen

Anstatt Kabel anzuschließen und Schalter zu drehen, lädt ein Computer mit gespeicherten Programmen seine Anweisungen in den Speicher, genau wie er seine Daten in den Speicher lädt. Infolgedessen konnte der Computer schnell programmiert werden und Berechnungen mit sehr hoher Geschwindigkeit durchführen. Presper Eckert und John Mauchly bauten die ENIAC. Die beiden Ingenieure stellten das Konzept der gespeicherten Programme in einem dreiseitigen Memo vom Februar 1944 vor. Später, im September 1944, begann Dr. John von Neumann mit der Arbeit am ENIAC-Projekt. Am 30. Juni 1945 veröffentlichte von Neumann den First Draft of a Report on the EDVAC , der die Strukturen des Computers mit den Strukturen des menschlichen Gehirns gleichsetzte. Das Design wurde als von Neumann-Architektur bekannt . Die Architektur wurde 1949 gleichzeitig in den Konstruktionen der EDVAC- und EDSAC -Computer eingesetzt.

Das IBM System/360 (1964) war eine Reihe von sechs Computern mit jeweils derselben Befehlssatzarchitektur . Das Modell 30 war das kleinste und billigste. Kunden können dieselbe Anwendungssoftware aktualisieren und behalten . Das Modell 75 war das hochwertigste. Jedes System/360-Modell verfügte über Multiprogramming – mit mehreren Prozessen gleichzeitig im Speicher . Wenn ein Prozess auf Input/Output wartete , konnte ein anderer rechnen.

IBM plante, jedes Modell mit PL/1 zu programmieren . Es wurde ein Komitee gebildet, dem COBOL- , Fortran- und ALGOL- Programmierer angehörten. Ziel war es, eine Sprache zu entwickeln, die umfassend, einfach zu verwenden und erweiterbar ist und Cobol und Fortran ersetzen würde. Das Ergebnis war eine große und komplexe Sprache, deren Kompilierung viel Zeit in Anspruch nahm .

Schalter für die manuelle Eingabe an einem Data General Nova 3, hergestellt Mitte der 1970er Jahre

Computer, die bis in die 1970er Jahre hergestellt wurden, hatten Frontplattenschalter für die manuelle Programmierung. Das Computerprogramm wurde zu Referenzzwecken auf Papier geschrieben. Eine Anweisung wurde durch eine Konfiguration von Ein/Aus-Einstellungen dargestellt. Nach dem Einstellen der Konfiguration wurde eine Ausführungsschaltfläche gedrückt. Dieser Vorgang wurde dann wiederholt. Computerprogramme wurden auch automatisch über Lochstreifen oder Lochkarten eingegeben . Nachdem das Medium geladen war, wurde die Startadresse über Schalter eingestellt und der Execute-Button gedrückt.

Sehr große Integration

Ein integrierter VLSI- Schaltungschip .

Ein wichtiger Meilenstein in der Softwareentwicklung war die Erfindung der VLSI-Schaltung ( Very Large Scale Integration ) (1964). Nach dem Zweiten Weltkrieg wurde die auf Röhren basierende Technologie durch Punktkontakttransistoren (1947) und Bipolartransistoren (Ende der 1950er Jahre) ersetzt, die auf einer Leiterplatte montiert waren . In den 1960er Jahren ersetzte die Luft- und Raumfahrtindustrie die Leiterplatte durch einen integrierten Schaltkreischip .

Robert Noyce , Mitbegründer von Fairchild Semiconductor (1957) und Intel (1968), erzielte eine technologische Verbesserung, um die Produktion von Feldeffekttransistoren zu verfeinern (1963). Ziel ist es, den elektrischen Widerstand und die Leitfähigkeit eines Halbleiterübergangs zu verändern . Zunächst werden natürlich vorkommende Silikatminerale nach dem Siemens-Verfahren in Polysiliziumstäbe umgewandelt . Der Czochralski-Prozess wandelt die Stäbe dann in einen monokristallinen Silizium - Boule-Kristall um . Der Kristall wird dann in dünne Scheiben geschnitten, um ein Wafersubstrat zu bilden . Der planare Prozess der Fotolithografie integriert dann unipolare Transistoren, Kondensatoren , Dioden und Widerstände auf dem Wafer, um eine Matrix aus Metall-Oxid-Halbleiter (MOS)-Transistoren aufzubauen. Der MOS-Transistor ist die Hauptkomponente in integrierten Schaltungschips .

Ursprünglich wurde die Funktion von integrierten Schaltungschips während der Herstellung festgelegt. In den 1960er Jahren verlagerte sich die Steuerung des elektrischen Flusses auf die Programmierung einer Matrix aus Nur-Lese-Speichern (ROM). Die Matrix ähnelte einer zweidimensionalen Anordnung von Sicherungen. Der Prozess zum Einbetten von Anweisungen in die Matrix bestand darin, die nicht benötigten Verbindungen auszubrennen. Es gab so viele Verbindungen, dass Firmware - Programmierer ein Computerprogramm auf einen anderen Chip schrieben, um das Brennen zu überwachen. Die Technologie wurde als programmierbares ROM bekannt . 1971 installierte Intel das Computerprogramm auf dem Chip und nannte es Intel 4004 Mikroprozessor .

IBMs System/360 (1964) CPU war kein Mikroprozessor.

Die Begriffe Mikroprozessor und Zentraleinheit (CPU) werden heute synonym verwendet. CPUs sind jedoch älter als Mikroprozessoren. Zum Beispiel hatte das IBM System/360 (1964) eine CPU, die aus Leiterplatten hergestellt war, die diskrete Komponenten auf Keramiksubstraten enthielten .

Sac-Zustand 8008

Künstlerische Darstellung des Mikrocomputers Intel 8008 der Sacramento State University (1972).

Der Intel 4004 (1971) war ein 4- Bit - Mikroprozessor, der für den Betrieb des Busicom- Rechners entwickelt wurde. Fünf Monate nach seiner Veröffentlichung veröffentlichte Intel den Intel 8008 – einen 8-Bit-Mikroprozessor. Bill Pentz leitete ein Team an der Sacramento State , um den ersten Mikrocomputer mit dem Intel 8008 zu bauen – den Sac State 8008 (1972). Sein Zweck bestand darin, Patientenakten zu speichern. Der Computer unterstützte ein Festplattenbetriebssystem zum Ausführen eines Memorex -Festplattenlaufwerks mit 3 Megabyte . Es hatte ein Farbdisplay und eine Tastatur, die in einer einzigen Konsole untergebracht waren. Das Plattenbetriebssystem wurde unter Verwendung von IBMs Basic Assembly Language (BAL) programmiert . Die Krankenaktenanwendung wurde unter Verwendung eines BASIC- Interpreters programmiert. Der Computer war jedoch eine evolutionäre Sackgasse, weil er extrem teuer war. Außerdem wurde es in einem öffentlichen Universitätslabor für einen bestimmten Zweck gebaut. Nichtsdestotrotz trug das Projekt zur Entwicklung des Befehlssatzes Intel 8080 (1974) bei .

x86-Serie

Der ursprüngliche IBM Personal Computer (1981) verwendete einen Intel 8088-Mikroprozessor.

1978 begann die moderne Softwareentwicklungsumgebung, als Intel den Intel 8080 auf den Intel 8086 aufrüstete . Intel vereinfachte den Intel 8086, um den billigeren Intel 8088 herzustellen . IBM nahm den Intel 8088 auf, als sie in den PC -Markt eintraten (1981). Als die Verbrauchernachfrage nach PCs zunahm, stieg auch die Mikroprozessorentwicklung von Intel. Die Entwicklungsfolge ist als x86-Serie bekannt . Die x86-Assemblersprache ist eine Familie abwärtskompatibler Maschinenbefehle . Maschinenbefehle, die in früheren Mikroprozessoren erstellt wurden, wurden während der Mikroprozessor-Upgrades beibehalten. Dadurch konnten Verbraucher neue Computer kaufen, ohne neue Anwendungssoftware kaufen zu müssen . Die Hauptkategorien von Anweisungen sind:

Programmierumgebung

Das DEC VT100 (1978) war ein weit verbreitetes Computerterminal .

VLSI-Schaltungen ermöglichten es der Programmierumgebung , sich von einem Computerterminal (bis in die 1990er Jahre) zu einem Computer mit grafischer Benutzeroberfläche (GUI) zu entwickeln. Computerterminals beschränkten Programmierer auf eine einzelne Shell , die in einer Befehlszeilenumgebung ausgeführt wurde . In den 1970er Jahren wurde die Quellcodebearbeitung im Vollbildmodus durch eine textbasierte Benutzeroberfläche möglich . Unabhängig von der verfügbaren Technologie ist das Ziel, in einer Programmiersprache zu programmieren .

Programmiersprachen

Eine Programmiersprache ist ein Satz von Schlüsselwörtern , Symbolen , Bezeichnern und Regeln, mit denen Programmierer Anweisungen an den Computer übermitteln können. Sie folgen einer Reihe von Regeln, die als Syntax bezeichnet werden .

Programmiersprachen beziehen ihre Grundlage aus formalen Sprachen . Der Zweck der Definition einer Lösung in Bezug auf ihre formale Sprache besteht darin, einen Algorithmus zur Lösung des Unterstreichungsproblems zu generieren. Ein Algorithmus ist eine Abfolge einfacher Anweisungen, die ein Problem lösen.

Generationen von Programmiersprachen

Die Entwicklung der Programmiersprache begann, als das EDSAC (1949) das erste gespeicherte Computerprogramm in seiner von Neumann-Architektur verwendete . Die Programmierung des EDSAC erfolgte in der ersten Generation der Programmiersprache .

  • Die zweite Generation der Programmiersprache ist die Assemblersprache . Die Assemblersprache ermöglicht es dem Programmierer, mnemonische Anweisungen zu verwenden, anstatt sich an Anweisungsnummern zu erinnern. Ein Assembler übersetzt jede Assemblersprachen-Mnemonik in ihre Maschinensprachennummer. Beispielsweise kann auf dem PDP-11 auf die Operation 24576 im Quellcode als ADD verwiesen werden. Die vier Grundrechenarten haben Assembleranweisungen wie ADD, SUB, MUL und DIV. Computer haben auch Anweisungen wie DW (Define Word ), um Speicherzellen zu reservieren . Dann kann der MOV-Befehl ganze Zahlen zwischen Registern und Speicher kopieren.
  • Die Grundstruktur einer Anweisung in Assemblersprache besteht aus Bezeichnung, Operation, Operand und Kommentar.
  • Labels ermöglichen dem Programmierer, mit Variablennamen zu arbeiten . Der Assembler wird später Labels in physische Speicheradressen übersetzen .
  • Operationen ermöglichen dem Programmierer, mit Mnemotechniken zu arbeiten. Der Assembler wird später Mnemoniken in Befehlsnummern übersetzen.
  • Operanden teilen dem Assembler mit, welche Daten die Operation verarbeitet.
  • Kommentare ermöglichen es dem Programmierer, eine Erzählung zu artikulieren, da die Anweisungen allein vage sind.
Das Schlüsselmerkmal eines Assemblersprachenprogramms ist, dass es eine Eins-zu-eins-Abbildung zu seinem entsprechenden Maschinensprachenziel bildet.
  • Die dritte Generation von Programmiersprachen verwendet Compiler und Interpreter , um Computerprogramme auszuführen. Das Unterscheidungsmerkmal einer Sprache der dritten Generation ist ihre Unabhängigkeit von einer bestimmten Hardware. Sie begannen mit den Sprachen Fortran (1958), COBOL (1959), ALGOL (1960) und BASIC (1964). 1973 entstand die Programmiersprache C als Hochsprache , die effiziente Anweisungen in Maschinensprache produzierte. Während Sprachen der dritten Generation historisch viele Maschinenanweisungen für jede Anweisung generierten, verfügt C über Anweisungen, die eine einzelne Maschinenanweisung generieren können. Darüber hinaus könnte ein optimierender Compiler den Programmierer außer Kraft setzen und weniger Maschinenanweisungen als Anweisungen produzieren. Heute füllt ein ganzes Paradigma von Sprachen das Spektrum der imperativen dritten Generation aus.

Imperative Sprachen

Ein Computerprogramm, das in einer imperativen Sprache geschrieben ist

Imperative Sprachen spezifizieren einen sequentiellen Algorithmus mit Deklarationen , Ausdrücken und Anweisungen :

  • Eine Deklaration führt einen Variablennamen in das Computerprogramm ein und weist ihm einen Datentyp zu – zum Beispiel:var x: integer;
  • Ein Ausdruck ergibt einen Wert – zum Beispiel: 2 + 2ergibt 4
  • Eine Anweisung kann einer Variablen einen Ausdruck zuweisen oder den Wert einer Variablen verwenden, um den Kontrollfluss des Programms zu ändern – zum Beispiel:x := 2 + 2; if x = 4 then do_something();

Beispiele für imperative Sprachen finden Sie unter Imperative_programming#Examples .

Deklarative Sprachen

Imperative Sprachen haben einen großen Kritikpunkt: Das Zuweisen eines Ausdrucks zu einer nicht-lokalen Variablen kann einen unbeabsichtigten Nebeneffekt erzeugen . Deklarative Sprachen lassen im Allgemeinen die Zuweisungsanweisung und den Kontrollfluss weg. Sie beschreiben, welche Berechnung durchgeführt werden soll und nicht , wie sie zu berechnen ist. Zwei große Kategorien deklarativer Sprachen sind funktionale Sprachen und logische Sprachen .

In der Mathematik ist eine Funktion eine Regel, die Elemente eines Ausdrucks einem Bereich von Werten zuordnet . Betrachten Sie die Funktion:

times_10(x) = 10 * x

Der Ausdruck 10 * x wird von der Funktion times_10()einem Wertebereich zugeordnet . Ein Wert ist zufällig 20. Dies tritt auf, wenn x 2 ist. Die Anwendung der Funktion wird also mathematisch wie folgt geschrieben:

times_10(2) = 20

Ein funktionaler Sprachcompiler speichert diesen Wert nicht in einer Variablen. Stattdessen wird der Wert auf den Stack des Computers verschoben, bevor der Programmzähler auf die aufrufende Funktion zurückgesetzt wird. Die aufrufende Funktion holt dann den Wert aus dem Stack.

Imperative Sprachen unterstützen Funktionen. Daher kann funktionale Programmierung in einer imperativen Sprache erreicht werden, wenn der Programmierer Disziplin anwendet. Eine funktionale Sprache wird dem Programmierer diese Disziplin jedoch durch ihre Syntax aufzwingen. Funktionale Sprachen haben eine Syntax, die darauf zugeschnitten ist, das was hervorzuheben .

Ein funktionales Programm wird mit einem Satz primitiver Funktionen entwickelt, gefolgt von einer einzelnen Treiberfunktion. Betrachten Sie den Ausschnitt :

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));

}

Die Primitiven sind max()und min(). Die Treiberfunktion ist difference_between_largest_and_smallest(). Ausführung:

put(difference_between_largest_and_smallest(10,4,7));gibt 6 aus.

Funktionale Sprachen werden in der Informatikforschung verwendet , um neue Sprachmerkmale zu erforschen. Darüber hinaus hat ihr Fehlen von Nebenwirkungen sie bei der parallelen Programmierung und der gleichzeitigen Programmierung beliebt gemacht . Anwendungsentwickler bevorzugen jedoch die objektorientierten Merkmale imperativer Sprachen .

Beispiele für deklarative Sprachen finden Sie unter Declarative_programming#Examples .

Computerprogrammierung

Vor Programmiersprachen programmierten Betty Jennings und Fran Bilas den ENIAC , indem sie Kabel bewegten und Schalter einstellten.

Computerprogrammierung (Teil der Softwareentwicklung und Softwaretechnik ) ist der Prozess des Schreibens oder Bearbeitens von Quellcode . In einer formellen Umgebung sammelt ein Systemanalytiker Informationen von Managern über alle zu automatisierenden Prozesse der Organisation. Dieser erstellt dann einen detaillierten Plan für das neue oder modifizierte System. Der Plan ist analog zum Bauplan eines Architekten.

Leistungsziele

Der Systemanalytiker hat das Ziel, die richtigen Informationen zur richtigen Zeit an die richtige Person zu liefern. Die entscheidenden Faktoren, um dieses Ziel zu erreichen, sind:

  1. Die Qualität der Ausgabe. Ist die Ausgabe nützlich für die Entscheidungsfindung?
  2. Die Genauigkeit der Ausgabe. Spiegelt es die wahre Situation wider?
  3. Das Format der Ausgabe. Ist die Ausgabe leicht verständlich?
  4. Die Geschwindigkeit der Ausgabe. Zeitkritische Informationen sind wichtig, wenn mit dem Kunden in Echtzeit kommuniziert wird.

Kostenziele

Das Erreichen von Leistungszielen sollte mit allen Kosten abgewogen werden, einschließlich:

  1. Entwicklungskosten.
  2. Einzigartigkeit kostet. Ein wiederverwendbares System kann teuer sein. Es könnte jedoch einem System mit begrenzter Verwendung vorgezogen werden.
  3. Hardwarekosten.
  4. Betriebskosten.

Die Anwendung eines Systementwicklungsprozesses mildert das Axiom: Je später im Prozess ein Fehler erkannt wird, desto teurer ist die Korrektur.

Wasserfall-Modell

Das Wasserfallmodell ist eine Implementierung eines Systementwicklungsprozesses . Wie das Wasserfall- Label andeutet, überlappen sich die grundlegenden Phasen:

  1. Die Untersuchungsphase dient dazu, das zugrunde liegende Problem zu verstehen.
  2. Die Analysephase besteht darin, die möglichen Lösungen zu verstehen.
  3. Die Designphase dient dazu, die beste Lösung zu planen.
  4. In der Implementierungsphase wird die beste Lösung programmiert.
  5. Die Wartungsphase erstreckt sich über die gesamte Lebensdauer des Systems. Nach der Bereitstellung können Änderungen am System erforderlich sein. Fehler können vorhanden sein, einschließlich Spezifikationsfehler, Konstruktionsfehler oder Codierungsfehler. Eventuell sind Verbesserungen notwendig. Anpassungen können erforderlich sein, um auf ein sich änderndes Umfeld zu reagieren.

Computerprogrammierer

Ein Computerprogrammierer ist ein Spezialist, der für das Schreiben oder Modifizieren des Quellcodes verantwortlich ist, um den detaillierten Plan umzusetzen. Wahrscheinlich wird ein Programmierteam benötigt, da die meisten Systeme zu groß sind, um von einem einzelnen Programmierer fertiggestellt zu werden. Das Hinzufügen von Programmierern zu einem Projekt verkürzt jedoch möglicherweise nicht die Fertigstellungszeit. Stattdessen kann es die Qualität des Systems verringern. Um effektiv zu sein, müssen Programmmodule definiert und an die Teammitglieder verteilt werden. Außerdem müssen die Teammitglieder auf sinnvolle und effektive Weise miteinander interagieren.

Programmierung im Kleinen ist Computerprogrammierung innerhalb eines einzelnen Moduls. Es besteht die Möglichkeit, dass ein Modul Module ausführt, die sich in anderen Quellcodedateien befinden. Programmieren im Großen und Ganzen ist das Entwerfen von Modulen, damit sie effektiv miteinander gekoppelt werden können.

Programmmodule

Die modulare Programmierung ist eine Technik zur Verfeinerung imperativer Sprachprogramme , um die Softwarealterung zu verringern . Ein Programmmodul ist eine Folge von Anweisungen, die innerhalb eines Blocks eingeschlossen und gemeinsam durch einen Namen gekennzeichnet sind. Module haben eine Funktion , einen Kontext und eine Logik :

  • Die Funktion eines Moduls ist, was es tut.
  • Der Kontext eines Moduls sind die Elemente, die ausgeführt werden.
  • Die Logik eines Moduls ist, wie es die Funktion ausführt.

Der Name des Moduls sollte zuerst von seiner Funktion und dann von seinem Kontext abgeleitet werden . Seine Logik sollte nicht Teil des Namens sein. Zum Beispiel sind function compute_square_root( x )oder function compute_square_root_integer( i : integer )geeignete Modulnamen. Ist function compute_square_root_by_division( x )es jedoch nicht.

Der Grad der Interaktion innerhalb eines Moduls ist sein Grad an Kohäsion . Kohäsion ist eine Beurteilung der Beziehung zwischen dem Namen eines Moduls und seiner Funktion . Der Grad der Interaktion zwischen Modulen ist die Ebene der Kopplung . Kopplung ist eine Beurteilung der Beziehung zwischen dem Kontext eines Moduls und den Elementen, auf denen ausgeführt wird.

Zusammenhalt

Die Ebenen der Kohäsion vom schlechtesten zum besten sind:

  • Zufällige Kohäsion : Ein Modul hat zufällige Kohäsion, wenn es mehrere Funktionen ausführt und die Funktionen völlig unabhängig voneinander sind. Zum Beispiel function read_sales_record_print_next_line_convert_to_float(). Zufällige Kohäsion tritt in der Praxis auf, wenn das Management dumme Regeln durchsetzt. Beispiel: „Jedes Modul wird zwischen 35 und 50 ausführbare Anweisungen haben.“
  • Logischer Zusammenhalt: Ein Modul hat einen logischen Zusammenhalt, wenn es eine Reihe von Funktionen zur Verfügung hat, aber nur eine davon ausgeführt wird. Zum Beispiel function perform_arithmetic( perform_addition, a, b ).
  • Zeitliche Kohäsion : Ein Modul hat zeitliche Kohäsion, wenn es zeitbezogene Funktionen ausführt. Ein Beispiel, function initialize_variables_and_open_files(). Ein weiteres Beispiel, stage_one(), stage_two(), ...
  • Prozedurale Kohäsion : Ein Modul hat prozedurale Kohäsion, wenn es mehrere Funktionen erfüllt, aber nur lose miteinander verbunden ist. Zum Beispiel function read_part_number_update_employee_record().
  • Kommunikationskohäsion : Ein Modul hat Kommunikationskohäsion, wenn es mehrere Funktionen ausführt, aber eng miteinander verbunden sind. Zum Beispiel function read_part_number_update_sales_record().
  • Informationskohäsion : Ein Modul hat Informationskohäsion, wenn es mehrere Funktionen ausführt, aber jede Funktion ihre eigenen Ein- und Ausgangspunkte hat. Darüber hinaus teilen sich die Funktionen die gleiche Datenstruktur. Objektorientierte Klassen arbeiten auf dieser Ebene.
  • Funktionale Kohäsion : Ein Modul hat funktionale Kohäsion, wenn es ein einziges Ziel erreicht, indem es nur mit lokalen Variablen arbeitet. Darüber hinaus kann es in anderen Zusammenhängen wiederverwendbar sein.

Kupplung

Die Kopplungsstufen vom schlechtesten zum besten sind:

  • Inhaltskopplung : Ein Modul hat Inhaltskopplung, wenn es eine lokale Variable einer anderen Funktion modifiziert. COBOL tat dies früher mit dem Alter- Verb.
  • Gemeinsame Kopplung : Ein Modul hat eine gemeinsame Kopplung, wenn es eine globale Variable modifiziert.
  • Kontrollkopplung : Ein Modul hat eine Kontrollkopplung, wenn ein anderes Modul seinen Kontrollfluss ändern kann . Zum Beispiel perform_arithmetic( perform_addition, a, b ). Stattdessen sollte die Kontrolle über die Zusammensetzung des zurückgegebenen Objekts liegen.
  • Stempelkopplung : Ein Modul hat eine Stempelkopplung, wenn ein Element einer als Parameter übergebenen Datenstruktur modifiziert wird. Objektorientierte Klassen arbeiten auf dieser Ebene.
  • Datenkopplung : Ein Modul hat eine Datenkopplung, wenn alle seine Eingabeparameter benötigt werden und keiner von ihnen modifiziert wird. Außerdem wird das Ergebnis der Funktion als einzelnes Objekt zurückgegeben.

Datenflussanalyse

Ein Beispiel für ein Datenflussdiagramm auf Funktionsebene.

Die Datenflussanalyse ist eine Entwurfsmethode, die verwendet wird, um Module funktionaler Kohäsion und Datenkopplung zu erreichen . Die Eingabe für die Methode ist ein Datenflussdiagramm . Ein Datenflussdiagramm ist eine Reihe von Ovalen, die Module darstellen. Der Name jedes Moduls wird in seinem Oval angezeigt. Module können sich auf der ausführbaren Ebene oder der Funktionsebene befinden.

Das Diagramm hat auch Pfeile, die Module miteinander verbinden. Pfeile, die in Module zeigen, repräsentieren eine Reihe von Eingängen. Jedes Modul sollte nur einen Pfeil haben, der von ihm zeigt, um sein einzelnes Ausgangsobjekt darzustellen. (Optional weist ein zusätzlicher Ausnahmepfeil darauf hin.) Eine Daisy-Chain von Ovalen vermittelt einen vollständigen Algorithmus . Die Eingangsmodule sollten das Diagramm beginnen. Die Eingangsmodule sollten mit den Transformationsmodulen verbunden sein. Die Transformationsmodule sollten mit den Ausgangsmodulen verbunden sein.

Objekt orientierte Programmierung

Objektorientierte Programmierung führt Operationen ( Funktionen ) auf Objekten aus . Die Grundidee besteht darin, die Eigenschaften eines Phänomens in einem Objektcontainer zusammenzufassen und dem Container einen Namen zu geben. Die Operationen zu dem Phänomen sind ebenfalls in dem Container gruppiert. Objektorientierte Programmierung , die durch die Kombination der Notwendigkeit von Containern und der Notwendigkeit einer sicheren funktionalen Programmierung entwickelt wurde . Dieses Programmierverfahren muss nicht auf eine objektorientierte Sprache beschränkt sein . In einer objektorientierten Sprache wird ein Objektcontainer als Klasse bezeichnet . In einer nicht objektorientierten Sprache kann eine Datenstruktur (die auch als Datensatz bezeichnet wird ) zu einem Objektcontainer werden. Um eine Datenstruktur in einen Objektcontainer umzuwandeln, müssen Operationen speziell für die Struktur geschrieben werden. Die resultierende Struktur wird als abstrakter Datentyp bezeichnet . Die Vererbung wird jedoch fehlen. (Einen Bezugspunkt finden Sie unter Imperative_programming#C++ .) Nichtsdestotrotz kann dieser Mangel überwunden werden.

Hier ist eine C-Programmiersprachen- Header-Datei für den abstrakten Datentyp GRADE in einer einfachen Schulanwendung:

/* 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

Die grade_new()Funktion führt denselben Algorithmus wie die C++- Konstruktoroperation aus .

Hier ist eine C-Programmiersprachen- Quelldatei für den abstrakten Datentyp GRADE in einer einfachen Schulanwendung:

/* 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;
}

Im Konstruktor calloc()wird stattdessen die Funktion verwendet, malloc()da jede Speicherzelle auf Null gesetzt wird.

Hier ist eine Header-Datei der Programmiersprache C für den abstrakten Datentyp PERSON in einer einfachen Schulanwendung:

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

typedef struct
{
    char *name;
} PERSON;

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

Hier ist eine C-Programmiersprachen- Quelldatei für den abstrakten Datentyp PERSON in einer einfachen Schulanwendung:

/* 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;
}

Hier ist eine Header-Datei der Programmiersprache C für den abstrakten Datentyp STUDENT in einer einfachen Schulanwendung:

/* 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

Hier ist eine C-Programmiersprachen- Quelldatei für den abstrakten Datentyp STUDENT in einer einfachen Schulanwendung:

/* 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;
}

Hier ist ein Treiberprogramm zur Demonstration:

/* 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;
}

Hier ist ein Makefile , um alles zu kompilieren:

# 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

Die formale Strategie zum Erstellen objektorientierter Objekte lautet:

  • Identifizieren Sie die Objekte. Höchstwahrscheinlich werden dies Substantive sein.
  • Identifizieren Sie die Attribute jedes Objekts. Was hilft, das Objekt zu beschreiben?
  • Identifizieren Sie die Aktionen jedes Objekts. Höchstwahrscheinlich werden dies Verben sein.
  • Identifizieren Sie die Beziehungen von Objekt zu Objekt. Höchstwahrscheinlich werden dies Verben sein.

Zum Beispiel:

  • Eine Person ist ein Mensch, der durch einen Namen identifiziert wird.
  • Eine Note ist eine Leistung, die durch einen Buchstaben gekennzeichnet ist.
  • Ein Student ist eine Person, die eine Note verdient.

Funktionale Kategorien

Ein Diagramm, das zeigt, wie der Benutzer mit der Anwendungssoftware interagiert . Die Anwendungssoftware interagiert mit dem Betriebssystem , das mit der Hardware interagiert .

Computerprogramme können entlang Funktionslinien kategorisiert werden. Die Hauptfunktionskategorien sind Anwendungssoftware und Systemsoftware . Systemsoftware umfasst das Betriebssystem , das Computerhardware mit Anwendungssoftware koppelt . Der Zweck des Betriebssystems besteht darin, eine Umgebung bereitzustellen, in der Anwendungssoftware auf bequeme und effiziente Weise ausgeführt wird. Sowohl Anwendungssoftware als auch Systemsoftware führen Dienstprogramme aus . Auf der Hardwareebene steuert ein Mikrocodeprogramm die Schaltungen in der gesamten zentralen Verarbeitungseinheit .

Anwendungssoftware

Anwendungssoftware ist der Schlüssel zur Erschließung des Potenzials des Computersystems. Unternehmensanwendungssoftware bündelt Buchhaltungs-, Personal-, Kunden- und Lieferantenanwendungen. Beispiele hierfür sind Enterprise Resource Planning , Customer Relationship Management und Supply Chain Management Software .

Unternehmensanwendungen können intern als einzigartige proprietäre Software entwickelt werden . Alternativ können sie als Standardsoftware erworben werden . Gekaufte Software kann modifiziert werden, um benutzerdefinierte Software bereitzustellen . Wird die Anwendung angepasst, werden entweder die Ressourcen des Unternehmens genutzt oder die Ressourcen ausgelagert. Die ausgelagerte Softwareentwicklung kann vom ursprünglichen Softwareanbieter oder einem Drittentwickler stammen.

Die Vorteile proprietärer Software sind Funktionen und Berichte, die genau den Spezifikationen entsprechen können. Das Management kann auch am Entwicklungsprozess beteiligt sein und ein gewisses Maß an Kontrolle bieten. Das Management kann entscheiden, der neuen Initiative eines Konkurrenten entgegenzuwirken oder eine Kunden- oder Lieferantenanforderung umzusetzen. Eine Fusion oder Übernahme erfordert Änderungen an der Unternehmenssoftware. Die Nachteile proprietärer Software sind die Zeit- und Ressourcenkosten, die erheblich sein können. Darüber hinaus können sich Risiken in Bezug auf Funktionen und Leistung abzeichnen.

Die Vorteile von Standardsoftware sind ihre identifizierbaren Anschaffungskosten, die Grundbedürfnisse sollten erfüllt werden und ihre Leistung und Zuverlässigkeit haben sich bewährt. Die Nachteile von Standardsoftware sind, dass sie möglicherweise unnötige Funktionen hat, die Endbenutzer verwirren, dass Funktionen fehlen, die das Unternehmen benötigt, und dass der Datenfluss möglicherweise nicht mit den Arbeitsprozessen des Unternehmens übereinstimmt.

Ein Ansatz zum wirtschaftlichen Erwerb einer maßgeschneiderten Unternehmensanwendung ist der Einsatz eines Anwendungsdienstanbieters . Spezialunternehmen stellen die Hardware, kundenspezifische Software und Endbenutzerunterstützung bereit. Sie können die Entwicklung neuer Anwendungen beschleunigen, da sie über qualifiziertes Personal für Informationssysteme verfügen. Der größte Vorteil besteht darin, dass interne Ressourcen von der Personalbeschaffung und Verwaltung komplexer Computerprojekte befreit werden. Viele Anwendungsdienstanbieter zielen auf kleine, schnell wachsende Unternehmen mit begrenzten Informationssystemressourcen ab. Auf der anderen Seite haben größere Unternehmen mit großen Systemen wahrscheinlich ihre technische Infrastruktur. Ein Risiko besteht darin, sensible Informationen einer externen Organisation anvertrauen zu müssen. Ein weiteres Risiko besteht darin, auf die Zuverlässigkeit der Infrastruktur des Anbieters vertrauen zu müssen.

Betriebssystem

Ein Betriebssystem ist die Low-Level-Software, die die Grundfunktionen eines Computers unterstützt, wie z . B. das Planen von Prozessen und das Steuern von Peripheriegeräten .

In den 1950er Jahren schrieb der Programmierer, der auch der Bediener war, ein Programm und führte es aus. Nachdem das Programm die Ausführung beendet hat, kann die Ausgabe gedruckt oder zur späteren Verarbeitung auf Papierstreifen oder Karten gestanzt worden sein. Meistens funktionierte das Programm nicht. Der Programmierer betrachtete dann die Konsolenlichter und fummelte an den Konsolenschaltern herum. Wenn weniger Glück hatte, wurde ein Speicherausdruck für weitere Studien gemacht. In den 1960er Jahren reduzierten Programmierer die Zeitverschwendung, indem sie die Arbeit des Bedieners automatisierten. Auf dem Computer befand sich zu jeder Zeit ein Programm, das als Betriebssystem bezeichnet wurde.

Der Begriff Betriebssystem kann sich auf zwei Softwareebenen beziehen. Das Betriebssystem kann sich auf das Kernelprogramm beziehen , das die Prozesse , den Speicher und die Geräte verwaltet . Allgemeiner kann sich das Betriebssystem auf das gesamte Paket der zentralen Software beziehen. Das Paket enthält ein Kernelprogramm, einen Befehlszeileninterpreter , eine grafische Benutzeroberfläche , Dienstprogramme und einen Editor .

Kernel-Programm

Ein Kernel verbindet die Anwendungssoftware mit der Hardware eines Computers.

Der Hauptzweck des Kernels besteht darin, die begrenzten Ressourcen eines Computers zu verwalten:

Physischer Speicher ist über RAM und die Festplatte verstreut. Virtueller Speicher ist ein fortlaufender Block.
  • Wenn der Kernel anfänglich eine ausführbare Datei in den Speicher lädt , teilt er den Adressraum logisch in Regionen ein . Der Kernel verwaltet eine Master-Region-Tabelle und viele Pro-Process-Region-Tabellen (P-Region) – eine für jeden laufenden Prozess . Diese Tabellen bilden den virtuellen Adressraum . Die Master-Region-Tabelle wird verwendet, um zu bestimmen, wo sich ihr Inhalt im physischen Speicher befindet . Die Pregion-Tabellen ermöglichen jedem Prozess, seine eigene Programm-(Text)-Pregion, Daten-Pregion und Stack-Pregion zu haben.
  • Die Programmvorregion speichert Maschinenbefehle. Da sich Maschinenbefehle nicht ändern, kann die Programmpräregion von vielen Prozessen derselben ausführbaren Datei gemeinsam genutzt werden.
  • Um Zeit und Speicherplatz zu sparen, lädt der Kernel möglicherweise nur Blöcke von Ausführungsanweisungen vom Plattenlaufwerk, nicht die gesamte Ausführungsdatei vollständig.
  • Der Kernel ist für die Übersetzung virtueller Adressen in physische Adressen verantwortlich . Der Kernel kann Daten vom Speichercontroller anfordern und stattdessen einen Seitenfehler erhalten . Wenn dies der Fall ist, greift der Kernel auf die Speicherverwaltungseinheit zu, um den physischen Datenbereich zu füllen und die Adresse zu übersetzen.
  • Der Kernel weist auf Anfrage eines Prozesses Speicher aus dem Heap zu. Wenn der Prozess mit dem Speicher fertig ist, kann der Prozess verlangen, dass er freigegeben wird . Wenn der Prozess beendet wird, ohne dass der gesamte zugewiesene Speicher freigegeben werden soll, führt der Kernel eine Garbage Collection durch, um den Speicher freizugeben.
  • Der Kernel stellt auch sicher, dass ein Prozess nur auf seinen eigenen Speicher zugreift und nicht auf den des Kernels oder anderer Prozesse.
  • Das Kernel - Programm sollte die Dateisystemverwaltung durchführen . Der Kernel enthält Anweisungen zum Erstellen, Abrufen, Aktualisieren und Löschen von Dateien.
  • Das Kernelprogramm sollte die Geräteverwaltung durchführen . Der Kernel stellt Programme bereit, um die Schnittstelle zu Maus, Tastatur, Laufwerken, Druckern und anderen Geräten zu standardisieren und zu vereinfachen. Darüber hinaus sollte der Kernel den Zugriff auf ein Gerät vermitteln, wenn zwei Prozesse ihn gleichzeitig anfordern.
  • Das Kernel - Programm sollte das Netzwerkmanagement durchführen . Der Kernel sendet und empfängt Pakete im Auftrag von Prozessen. Eine Schlüsseldienstleistung besteht darin, einen effizienten Weg zum Zielsystem zu finden.
  • Das Kernel-Programm sollte Funktionen auf Systemebene bereitstellen, die Programmierer verwenden können.
    • Programmierer greifen auf Dateien über eine relativ einfache Schnittstelle zu, die wiederum eine relativ komplizierte E/A-Schnittstelle auf niedriger Ebene ausführt. Die Low-Level-Schnittstelle umfasst Dateierstellung, Dateideskriptoren , Dateisuche, physisches Lesen und physisches Schreiben.
    • Programmierer erstellen Prozesse über eine relativ einfache Schnittstelle, die wiederum eine relativ komplizierte Low-Level-Schnittstelle ausführt.
    • Programmierer führen Datums-/Zeitarithmetik über eine relativ einfache Schnittstelle durch, die wiederum eine relativ komplizierte Zeitschnittstelle auf niedriger Ebene ausführt.
  • Das Kernprogramm sollte einen Kommunikationskanal zwischen ausführenden Prozessen bereitstellen. Bei einem großen Softwaresystem kann es wünschenswert sein, das System in kleinere Prozesse zu integrieren. Prozesse können miteinander kommunizieren, indem sie Signale senden und empfangen .

Ursprünglich wurden Betriebssysteme in Assembler programmiert ; Moderne Betriebssysteme sind jedoch typischerweise in höheren Programmiersprachen wie C , Objective-C und Swift geschrieben .

Dienstprogramm

Ein Dienstprogramm soll die Systemverwaltung und Softwareausführung unterstützen. Betriebssysteme führen Hardware-Hilfsprogramme aus, um den Status von Laufwerken, Speicher, Lautsprechern und Druckern zu prüfen. Ein Dienstprogramm kann die Platzierung einer Datei auf einer überfüllten Platte optimieren. Systemdienstprogramme überwachen die Hardware- und Netzwerkleistung. Wenn eine Metrik außerhalb eines akzeptablen Bereichs liegt, wird eine Auslösewarnung generiert.

Zu den Dienstprogrammen gehören Komprimierungsprogramme, sodass Datendateien auf weniger Speicherplatz gespeichert werden. Komprimierte Programme sparen außerdem Zeit, wenn Dateien über das Netzwerk übertragen werden. Dienstprogramme können Datensätze sortieren und zusammenführen. Hilfsprogramme erkennen Computerviren .

Microcode-Programm

NICHT Tor.
NAND-Gatter.
NOR-Gatter.
UND-Gatter.
ODER-Gatter.

Ein Microcode-Programm ist der Interpreter der untersten Ebene, der den Datenpfad von softwaregesteuerten Computern steuert . (Fortschritte in der Hardware haben diese Operationen zu Hardware-Ausführungsschaltkreisen migriert.) Mikrocode-Anweisungen ermöglichen es dem Programmierer, die digitale Logikebene – die echte Hardware des Computers – einfacher zu implementieren . Die digitale Logikebene ist die Grenze zwischen Informatik und Technischer Informatik .

Ein Logikgatter ist ein winziger Transistor , der eines von zwei Signalen zurückgeben kann: ein oder aus.

  • Ein Transistor bildet das NICHT-Gate .
  • Die Reihenschaltung zweier Transistoren bildet das NAND-Gatter .
  • Das Parallelschalten zweier Transistoren bildet das NOR-Gatter .
  • Das Verbinden eines NICHT-Gatters mit einem NAND-Gatter bildet das UND-Gatter .
  • Das Verbinden eines NICHT-Gatters mit einem NOR-Gatter bildet das ODER-Gatter .

Diese fünf Gatter bilden die Bausteine ​​der binären Algebra – die digitalen Logikfunktionen des Computers.

Mikrocode-Anweisungen sind Mnemotechniken , die Programmierer verwenden können, um digitale Logikfunktionen auszuführen, anstatt sie in binärer Algebra zu bilden. Sie werden in einem Steuerspeicher einer Zentraleinheit (CPU) gespeichert . Diese Anweisungen auf Hardwareebene bewegen Daten über den gesamten Datenpfad .

Der Mikrobefehlszyklus beginnt, wenn der Mikrosequenzer seinen Mikroprogrammzähler verwendet, um den nächsten Maschinenbefehl aus dem Speicher mit wahlfreiem Zugriff zu holen . Der nächste Schritt besteht darin, den Maschinenbefehl zu decodieren , indem die richtige Ausgangsleitung zum Hardwaremodul ausgewählt wird. Der letzte Schritt besteht darin , die Anweisung unter Verwendung des Gattersatzes des Hardwaremoduls auszuführen .

Eine symbolische Darstellung einer ALU.

Anweisungen zum Ausführen von Arithmetik werden durch eine Arithmetik-Logik-Einheit (ALU) geleitet. Die ALU hat Schaltungen zum Durchführen elementarer Operationen zum Addieren, Verschieben und Vergleichen von ganzen Zahlen. Durch Kombinieren und Schleifen der elementaren Operationen durch die ALU führt die CPU ihre komplexe Arithmetik durch.

Microcode-Anweisungen bewegen Daten zwischen der CPU und dem Speichercontroller . Mikrocodebefehle des Speichercontrollers manipulieren zwei Register . Das Speicheradressenregister wird verwendet, um auf die Adresse jeder Speicherzelle zuzugreifen. Das Speicherdatenregister wird verwendet, um den Inhalt jeder Zelle einzustellen und zu lesen.

Mikrocodebefehle bewegen Daten zwischen der CPU und den vielen Computerbussen . Der Plattencontrollerbus schreibt auf und liest von Festplattenlaufwerken . Daten werden auch zwischen der CPU und anderen Funktionseinheiten über den Verbindungs-Express-Bus für periphere Komponenten bewegt.

Anmerkungen

Verweise