Computer Programm
A Computer Programm ist eine Sequenz oder eine Reihe von Anweisungen in a Programmiersprache Für ein Computer zu ausführen. Computerprogramme sind eine Komponente von Software, was auch beinhaltet Dokumentation und andere immaterielle Komponenten.[1]
Ein Computerprogramm in seiner menschlichen lesbaren Form heißt Quellcode. Quellcode benötigt ein anderes Computerprogramm zu ausführen Weil Computer ihren Native nur ausführen können Maschinenanweisungen. Daher kann Quellcode mithilfe der Sprache in Maschinenanweisungen übersetzt werden Compiler. (Maschinensprache Programme werden mit einem übersetzt Assembler.) Die resultierende Datei wird als eine bezeichnet ausführbar. Alternativ kann Quellcode innerhalb der Sprache ausgeführt werden Dolmetscher. Die Programmiersprache Java kompiliert in ein eine Zwischenform was dann von a ausgeführt wird Java -Dolmetscher.[2]
Wenn die ausführbare Datei für die Ausführung angefordert wird, dann die dann die Betriebssystem Ladungen es in Erinnerung und beginnt a Prozess.[3] Das Zentrale Verarbeitungseinheit wird bald Schalter zu diesem Prozess, damit es kann holen, dekodieren und dann ausführen jeder Maschinenanweisung.[4]
Wenn der Quellcode für die Ausführung angefordert wird, lädt das Betriebssystem den entsprechenden Interpreter in den Speicher und startet einen Prozess. Der Interpreter lädt den Quellcode dann in den Speicher, um sie zu übersetzen und auszuführen Aussage.[2] Das Ausführen des Quellcodes ist langsamer als eine ausführbare Datei auszuführen. Darüber hinaus muss der Dolmetscher am Computer installiert werden.
Beispiel Computerprogramm
Das "Hallo Welt!" Programm wird verwendet, um die Grundlagen einer Sprache zu veranschaulichen Syntax. Die Syntax der interpretierte Sprache grundlegend (1964) war absichtlich darauf beschränkt, die Sprache leicht zu lernen.[5] Zum Beispiel, Variablen sind nicht erklärt vor der Verwendung.[6] Außerdem werden Variablen automatisch auf Null initialisiert.[6] Hier ist ein Beispiel Computerprogramm in Basic, to Durchschnitt Eine Liste von Zahlen:[7]
10 EINGANG "Wie viele Zahlen zum Durchschnitt?", A 20 ZUM I = 1 ZU A 30 EINGANG "Nummer eingeben:", B 40 LASSEN C = C + B 50 NÄCHSTE I 60 LASSEN D = C/A 70 DRUCKEN "Der Durchschnitt ist", D 80 ENDE
Sobald die Mechanik der grundlegenden Computerprogrammierung gelernt ist, stehen ausgefeiltere und leistungsfähigere Sprachen zur Verfügung, um große Computersysteme zu erstellen.[8]
Geschichte
Verbesserungen in Software-Entwicklung sind das Ergebnis von Verbesserungen in Computerhardware. In jeder Phase in der Geschichte von Hardware die Aufgabe von Computerprogrammierung dramatisch geändert.
Analytischer Motor
1837, Charles Babbage wurde inspiriert von Jacquards Webstuhl versuchen, das zu bauen Analytischer Motor.[9] Die Namen der Komponenten des Berechnungsgeräts wurden aus der Textilindustrie entlehnt. In der Textilindustrie wurde Garn aus dem Laden gebracht, um gemahlen zu werden. Das Gerät hatte einen "Speicher", der Speicher für jeweils 1.000 Zahlen von 50 Dezimalstellen war.[10] Die Zahlen aus dem "Geschäft" wurden zur Verarbeitung in die "Mühle" übertragen. Es wurde mit zwei Sätzen perforierter Karten programmiert. Ein Satz zielte den Vorgang und der andere eingestellte Einstell der Variablen.[9] [11] Nach mehr als 17.000 Pfund des Geldes der britischen Regierung arbeiteten die Tausenden von Rädern und Zahnrädern nie vollständig zusammen.[12]
Ada Lovelace arbeitete für Charles Babbage, um eine Beschreibung der Analysemotor (1843) zu erstellen.[13] Die Beschreibung enthielt Note G, bei der eine Methode zum Berechnen vollständig detailliert wurde Bernoulli -Zahlen Verwenden der analytischen Motor. Diese Notiz wird von einigen Historikern als erstes Computerprogramm der Welt anerkannt.[12]
Universelle Turing -Maschine
1936, Alan Turing stellte die vor Universelle Turing -Maschine, ein theoretisches Gerät, das jede Berechnung modellieren kann.[14] Es ist ein Finite-State-Maschine Das hat ein unendlich langes Lese-/Schreibband. Die Maschine kann das Klebeband hin und her bewegen und ihren Inhalt ändern, wenn es eine ausführt Algorithmus. Die Maschine beginnt im Ausgangszustand, durchläuft eine Abfolge von Schritten und hält an, wenn sie auf den Haltestatus stößt.[15] Alle heutigen Computer sind Turing vollständig.[16]
Eniac
Das Elektronischer numerischer Integrator und Computer (Eniac) wurde zwischen Juli 1943 und Herbst 1945 erbaut Turing vollständig, allgemeiner Computer, der 17.468 verwendete Vakuumröhren um das zu erstellen Schaltungen. Im Kern war es eine Reihe von Pascaline zusammen verkabelt.[17] Die 40 Einheiten wogen 30 Tonnen, besetzte 1.800 Quadratfuß2) und 650 US -Dollar pro Stunde konsumiert (In den 1940er Jahren Währung) im Leerlauf in Elektrizität.[17] Es hatte 20 Basis-10 Akkumulatoren. Das Programmieren des Enials dauerte bis zu zwei Monate.[17] Drei Funktionstabellen waren auf Rädern und mussten auf feste Funktionsträger gerollt werden. Funktionstabellen wurden an Funktionstoffe angeschlossen, indem schwere schwarze Kabel an eingesteckt wurden Plugboards. Jede Funktionstabelle hatte 728 rotierende Knöpfe. Das Programmieren des Eniacs umfasste auch einige der 3.000 Schalter. Das Debuggen eines Programms dauerte eine Woche.[18] Es lief von 1947 bis 1955 um Aberdeen Proving GroundBerechnung von Wasserstoffbombenparametern, Vorhersage von Wettermustern und Herstellung von Schusstabellen, um Artillerie -Kanonen zu zielen.[19]
Computerspeicherprogramme
Anstatt Kabel einzuschließen und Schalter zu drehen, a Computerprotokollcomputer Laden Sie seine Anweisungen in Speicher, so wie sie seine Daten in den Speicher laden.[20] Infolgedessen könnte der Computer schnell programmiert werden und Berechnungen mit sehr schnellen Geschwindigkeiten durchführen.[21] Presper Eckert und John Mauchly baute den Eniac. Die beiden Ingenieure stellten die vor Speicherprogrammkonzept in einem dreiseitigen Memo vom Februar 1944.[22] Später im September 1944, Dr. John von Neumann begann am Eniac -Projekt zu arbeiten. Am 30. Juni 1945 veröffentlichte von Neumann die Erster Entwurf eines Berichts über den EDVAC die die Strukturen des Computers mit den Strukturen des menschlichen Gehirns gleichzusetzen.[21] Das Design wurde als das bekannt Von Neumann Architektur. Die Architektur wurde gleichzeitig in den Konstruktionen der Konstruktionen eingesetzt Edvac und Edsac Computer im Jahr 1949.[23]
Das IBM System/360 (1964) war eine Linie von sechs Computern, von denen jeweils der gleiche hatte Anweisungsset Architektur. Das Modell 30 war der kleinste und billigste. Kunden konnten das gleiche aktualisieren und behalten Anwendungssoftware.[24] Das Modell 75 war die Premium. Jedes System/360 -Modell wurde vorgestellt Multiprogrammierung[24]- Multiple Prozesse in Erinnerung auf einmal. Wenn ein Prozess darauf wartete Input-OutputEin anderer könnte berechnen.
IBM geplant, damit jedes Modell mithilfe von Mitarbeitern programmiert werden soll PL/1.[25] Es wurde ein Komitee gebildet, der enthielt Cobol, Forran und Algol Programmierer. Ziel war es, eine umfassende, einfach zu bedienende, extendierende Sprache zu entwickeln und Cobol und Forran zu ersetzen.[25] Das Ergebnis war eine große und komplexe Sprache, die lange dauerte kompilieren.[26]
Computer, die bis in die 1970er Jahre hergestellt wurden, hatten Front-Panel-Schalter für die manuelle Programmierung.[27] Das Computerprogramm wurde als Referenz auf Papier geschrieben. Eine Anweisung wurde durch eine Konfiguration der Ein-/Aus -Einstellungen dargestellt. Nach dem Einstellen der Konfiguration wurde eine Ausführungstaste gedrückt. Dieser Vorgang wurde dann wiederholt. Computerprogramme wurden auch automatisch über ein eingegeben Papier Klebeband oder geschlagene Karten. Nach dem Laden des Mediums wurde die Startadresse über Switches eingestellt und die Execute -Taste gedrückt.[27]
Sehr große Integration
Ein großer Meilenstein in der Softwareentwicklung war die Erfindung der Sehr große Integration (VLSI) Circuit (1964).[28] Folgen Zweiter WeltkriegDie technologische Röhrenbasis wurde durch ersetzt durch Punktkontakttransistoren (1947) und Bipolare Junction -Transistoren (Ende der 1950er Jahre) auf einem montiert Leiterplatte.[28] In den 1960er Jahren, das Luft- und Raumfahrt Die Industrie ersetzte die Leiterplatte durch eine integrierter Schaltungschip.[28]
Robert Noyce, Mitbegründer von Fairchild Semiconductor (1957) und Intel (1968) erzielten eine technologische Verbesserung, um die zu verfeinern Produktion von Feldeffekttransistoren (1963).[29] Das Ziel ist es, die zu verändern elektrischer Widerstand und Leitfähigkeit von a Semiconductor Junction. Erstens natürlich vorkommt Silikatmineralien werden in Polysilicium Stäbe mit dem Siemens Prozess.[30] Das Czochralski -Prozess Umgewandelt dann die Stäbe in a monokristallines Silizium, Boule Kristall.[31] Das Kristall wird dann dünn geschnitten, um a zu bilden Wafer Substrat. Das Planarprozess von Photolithographie dann integriert unipolare Transistoren, Kondensatoren, Dioden, und Widerstände auf den Wafer, um eine Matrix von zu bauen Metal -Oxid -Jemonductor (MOS) Transistoren.[32][33] Der MOS -Transistor ist die Hauptkomponente in Integrierte Schaltungschips.[29]
Ursprünglich hatten integrierte Schaltungschips ihre Funktion während der Herstellung festgelegt. In den 1960er Jahren wanderte die Steuerung des elektrischen Flusses auf das Programmieren a Matrix von Nur-Lese-Speicher (ROM). Die Matrix ähnelte einer zweidimensionalen Reihe von Sicherungen.[28] Der Prozess, um Anweisungen in die Matrix einzubetten, bestand darin, die nicht benötigten Verbindungen auszubrennen.[28] Es gab so viele Verbindungen, Firmware Programmierer schrieben a Computer Programm auf einem anderen Chip, um das Verbrennen zu überwachen.[28] Die Technologie wurde bekannt als als Programmierbares ROM. 1971 Intel installierte das Computerprogramm auf dem Chip und nannte es das Intel 4004 Mikroprozessor.[34]
Die Begriffe Mikroprozessor und Zentrale Verarbeitungseinheit (CPU) werden jetzt austauschbar verwendet. CPUs geht jedoch vor Mikroprozessoren. Zum Beispiel die IBM System/360 (1964) hatte eine CPU aus Leiterplatten mit diskreten Komponenten auf Keramiksubstraten.[35]
SAC STAAT 8008
Der Intel 4004 (1971) war ein 4-bisschen Mikroprozessor für die Ausführung des Bussicom Taschenrechner. Fünf Monate nach seiner Veröffentlichung veröffentlichte Intel die Intel 8008ein 8-Bit-Mikroprozessor. Bill Pentz führte ein Team bei Sacramento Staat um den ersten zu bauen Mikrocomputer Verwenden des Intel 8008: die SAC STAAT 8008 (1972).[36] Sein Ziel war es, Patientenkröten zu speichern. Der Computer unterstützte a Festplattenbetriebssystem zu laufen a Memorex, 3-Megabyte, Festplatte.[28] Es hatte eine Farbanzeige und eine Tastatur, die in einer einzigen Konsole verpackt war. Das Festplattenbetriebssystem wurde mit Verwendung programmiert IBMs grundlegende Montagesprache (BAL). Die Anwendung von medizinischen Unterlagen wurde mit a programmiert BASIC Dolmetscher.[28] Der Computer war jedoch ein evolutionäres Sackgassen, da er äußerst teuer war. Außerdem wurde es in einem öffentlichen Universitätslabor für einen bestimmten Zweck errichtet.[36] Trotzdem trug das Projekt zur Entwicklung der bei Intel 8080 (1974) Befehlssatz.[28]
X86 -Serie
1978 begann die moderne Softwareentwicklungsumgebung, als Intel die aktualisierte Intel 8080 zum Intel 8086. Intel vereinfachte den Intel 8086, um den billigeren Hersteller zu produzieren Intel 8088.[37] IBM umarmte den Intel 8088, als sie in das eintraten persönlicher Computer Markt (1981). Wie Verbraucher fordern Bei den PC -Computern stieg auch die Entwicklung von Intel von Intel. Die Folge der Entwicklung ist als die bekannt X86 -Serie. Das x86 Assemblersprache ist eine Familie von rückwärtskompatibel Maschinenanweisungen. Die in früheren Mikroprozessoren erzeugten Maschinenanweisungen wurden in Mikroprozessor -Upgrades beibehalten. Dies ermöglichte es den Verbrauchern, neue Computer zu kaufen, ohne neue kaufen zu müssen Anwendungssoftware. Die Hauptkategorien von Anweisungen sind:[a]
- Speicheranweisungen zum Festlegen und Zugriff auf Nummern und Saiten in Arbeitsspeicher.
- Ganze Zahl Arithmetik-Logikeinheit (ALU) Anweisungen zur Durchführung der primären arithmetischen Operationen auf Ganzzahlen.
- Schwimmpunkte ALU -Anweisungen zur Durchführung der primären arithmetischen Operationen auf reale Nummern.
- Rufen Sie Stack an Anweisungen zum Schieben und Pop Wörter benötigt, um Speicher und Schnittstelle mit Funktionen.
- Einzelanweisung, mehrere Daten (SIMD) Anweisungen[b] Um die Geschwindigkeit zu erhöhen, wenn mehrere Prozessoren verfügbar sind, um dasselbe durchzuführen Algorithmus auf an Datenarray.
Programmierumgebung ändern
VLSI -Schaltkreise ermöglichten die Programmierumgebung von a voranschreiten Computerterminal (bis in die 1990er Jahre) zu a grafische Benutzeroberfläche (GUI) Computer. Computerterminals beschränkten Programmierer auf eine einzige Hülse Laufen in a Befehlszeilenumgebung. In den 1970er Jahren wurde die Bearbeitung des Vollbild-Quellcodecodes durch a möglich Textbasierte Benutzeroberfläche. Unabhängig von der verfügbaren Technologie ist das Ziel, in a zu programmieren Programmiersprache.
Programmierparadigmen und Sprachen
Programmiersprache Es gibt Merkmale, um Bausteine zu bieten, die kombiniert werden sollen, um Programmierideale auszudrücken.[38] Idealerweise sollte eine Programmiersprache:[38]
- Ideen direkt im Code ausdrücken.
- Unabhängige Ideen unabhängig ausdrücken.
- Drücken Sie Beziehungen zwischen Ideen direkt im Code aus.
- Ideen frei kombinieren.
- Kombinieren Sie Ideen nur, wo Kombinationen sinnvoll sind.
- Einfach einfache Ideen ausdrücken.
Der Programmierstil einer Programmiersprache, um diese Bausteine bereitzustellen Programmierparadigmen.[39] Zum Beispiel können verschiedene Paradigmen unterscheiden:[39]
- prozedurale Sprachen, Funktionssprachen, und Logische Sprachen.
- verschiedene Ebenen von Datenabstration.
- verschiedene Ebenen von Klassenhierarchie.
- Verschiedene Eingabenebenen Datentypen, wie in Behältertypen und generische Programmierung.
Jedes dieser Programmierstile hat zur Synthese von verschiedenen beigetragen Programmiersprachen.[39]
A Programmiersprache ist ein Satz von Schlüsselwörter, Symbole, Kennungenund Regeln, nach denen Programmierer dem Computer Anweisungen mitteilen können.[40] Sie befolgen eine Reihe von Regeln, die als a genannt werden Syntax.[40]
- Schlüsselwörter sind reservierte Wörter zur Form Erklärungen und Aussagen.
- Symbole sind Zeichen zu formen Operationen, Zuordnungen, Steuerfluss, und Grenzwerte.
- Kennungen sind Wörter, die von Programmierern erstellt werden, um zu formen Konstanten, Variablennamen, Strukturnamen, und Funktionsnamen.
- Syntaxregeln sind in der definiert Backus -Naur -Form.
Programmiersprachen holen Sie sich ihre Basis aus formelle Sprachen.[41] Der Zweck der Definition einer Lösung in Bezug auf ihre formelle Sprache ist eine zu generieren Algorithmus das Unterstreichungsproblem zu lösen.[41] Ein Algorithmus ist eine Folge einfacher Anweisungen, die ein Problem lösen.[42]
Generationen der Programmiersprache
Die Entwicklung der Programmiersprache begann, als die Edsac (1949) verwendeten die erste gespeichertes Computerprogramm in seinem Von Neumann Architektur.[43] Das Programmieren des EDSAC war im ersten Generierung der Programmiersprache.
- Das erste Generation der Programmiersprache ist Maschinensprache.[44] Maschinensprache Erfordert der Programmierer, Anweisungen mithilfe der Verwendung einzugeben Anweisungsnummern genannt Maschinensprache. Zum Beispiel die Operation hinzufügen auf der PDP-11 hat Anweisungsnummer 24576.[45]
- Das Zweite Generation der Programmiersprache ist Montagesprache.[44] Montagesprache ermöglicht dem Programmierer die Verwendung mnemonisch Anweisungen anstatt sich an Anleitungsnummern zu erinnern. Ein Assembler Übersetzt jede Assemblersprache Mnemonik in seine Maschinensprachnummer. Zum Beispiel kann auf der PDP-11 der Vorgang 24576 als Hinzufügen im Quellcode bezeichnet werden.[45] Die vier grundlegenden arithmetischen Operationen haben Montageanweisungen wie Add, Sub, Mul und Div.[45] Computer haben auch Anweisungen wie DW (definieren Wort) reservieren Erinnerung Zellen. Dann kann die MOV -Anweisung kopieren Ganzzahlen zwischen Register und Erinnerung.
-
- Die Grundstruktur einer Assemblersprachanweisung ist Etikett, Betrieb, Operand und Kommentar.[46]
- Etiketten Erlauben Sie dem Programmierer, mit dem arbeiten zu können Variablennamen. Der Assembler wird später Etiketten in physisch übersetzen Speicheradressen.
- Operationen Erlauben Sie dem Programmierer, mit Mnemonik zu arbeiten. Der Assembler wird später Mnemonics in Anweisungsnummern übersetzen.
- Operanden Teilen Sie dem Assembler mit, welche Daten der Vorgang verarbeiten wird.
- Kommentare Erlauben Sie dem Programmierer, eine Erzählung zu artikulieren, da die Anweisungen allein vage sind.
- Das Hauptmerkmal eines Assemblersprachenprogramms besteht darin, dass es eine Eins-zu-Eins-Zuordnung zu seinem entsprechenden Maschinensprachenziel bildet.[47]
- Das dritte Generation der Programmiersprache Verwendet Compiler und Dolmetscher Computerprogramme ausführen. Das Unterscheidungsmerkmal von a dritte Generation Sprache ist ihre Unabhängigkeit einer bestimmten Hardware.[48] Frühe Sprachen enthalten Forran (1958), Cobol (1959), Algol (1960) und BASIC (1964).[44] 1973 die C Programmiersprache tauchte als a auf hochrangige Sprache Das erzeugte effiziente Anweisungen für Maschinensprachen.[49] Wohingegen dritte Generation Sprachen erzeugten historisch viele Maschinenanweisungen für jede Aussage.[50] C hat Aussagen, die eine einzelne Maschinenbefehls erzeugen können.[c] Außerdem an Compiler optimieren Könnte den Programmierer überschreiben und weniger Maschinenanweisungen als Anweisungen erstellen. Heute ein ganzer Ganzes Paradigma von Sprachen füllen die Imperativ, dritte Generation Spektrum.
- Das vierte Generation der Programmiersprache betont, welche Ausgabeergebnisse gewünscht werden, und nicht wie Programmieranweisungen konstruiert werden sollten.[44] Deklarative Sprachen Versuch zu begrenzen Nebenwirkungen und erlauben Programmierern, Code mit relativ wenigen Fehlern zu schreiben.[44] Eine beliebte vierte Generation Sprache heißt Strukturierte Abfragesprache (SQL).[44] Datenbank Entwickler müssen nicht mehr jeweils einzeln verarbeiten. Eine einfache Anweisung kann auch Ausgabedatensätze generieren, ohne verstehen zu müssen, wie er abgerufen wird.
Imperative Sprachen
Imperative Sprachen Geben Sie ein sequentielles an Algorithmus Verwendung Erklärungen, Ausdrücke, und Aussagen:[51]
- A Erklärung führt a ein Variable Name zum Computer Programm und weist es einem zu Datentyp[52] - zum Beispiel:
var x: Ganzzahl;
- Ein Ausdruck ergibt einen Wert - zum Beispiel:
2 + 2
ergibt 4 - A Aussage könnte zuordnen Ein Ausdruck zu einer Variablen oder verwenden Sie den Wert einer Variablen, um das Programm zu ändern Steuerfluss - zum Beispiel:
x: = 2 + 2; wenn x = 4 dann do_something ();
Forran
Forran (1958) wurde als "die IBM Mathematical Formel übers System" enthüllt. Es wurde für wissenschaftliche Berechnungen ohne Saite Handhabungseinrichtungen. Zusammen mit Erklärungen, Ausdrücke, und Aussagen, es unterstützte:
Es gelang es, weil:
- Programmier- und Debugging -Kosten lagen unter den Computerausführungskosten.
- Es wurde von IBM unterstützt.
- Anwendungen zu dieser Zeit waren wissenschaftlich.[53]
Nicht -IBM -Anbieter schrieb jedoch auch Forran Compiler, aber mit einer Syntax, die wahrscheinlich den Compiler von IBM nicht bestehen würde.[53] Das American National Standards Institute (ANSI) entwickelte 1966 den ersten FORTRAN -Standard. 1978 wurde Fortran 77 bis 1991 zum Standard. Forran 90 unterstützt:
- Aufzeichnungen.
- Zeiger zu Arrays.
Cobol
Cobol (1959) steht für "gemeinsame geschäftsorientierte Sprache". Forran manipulierte Symbole. Es wurde bald erkannt, dass Symbole keine Zahlen sein mussten, also wurden Saiten eingeführt.[54] Das US -Verteidigungsministerium Beeinflussen Cobols Entwicklung mit Grace Hopper ein großer Beitrag zu sein. Die Aussagen waren englischartig und ausführlich. Ziel war es, eine Sprache zu entwerfen, damit Manager die Programme lesen konnten. Das Fehlen strukturierter Aussagen behinderte jedoch dieses Ziel.[55]
Die Entwicklung von COBOL wurde eng kontrolliert, sodass Dialekte nicht entstanden waren, um ANSI -Standards zu erfordern. Infolge Objekt orientierte Programmierung.[55]
Algol
Algol (1960) steht für "algorithmische Sprache". Es hatte einen tiefgreifenden Einfluss auf das Programmiersprache.[56] Es stand aus einem Ausschuss europäischer und amerikanischer Programmiersprachenexperten, verwendete Standard -mathematische Notation und hatte ein lesbares strukturiertes Design. Algol definierte als Erster seine Syntax Verwendung der Backus -Naur -Form.[56] Dies führte zu Syntax-inszeniert Compiler. Es fügte Funktionen hinzu wie:
- Blockstruktur, wo Variablen lokal zu ihrem Block waren.
- Arrays mit variablen Grenzen.
- "für" Loops.
- Funktionen.
- Rekursion.[56]
Zu den direkten Nachkommen von Algol gehören Pascal, Modula-2, Ada, Delphi und Oberon auf einem Zweig. Auf einer anderen Niederlassung gibt es C, C ++ und Java.[56]
Basic
BASIC (1964) steht für "Anfänger -symbolischer Anweisungscode" Anfänger ". Es wurde bei entwickelt bei Dartmouth College für alle ihre Schüler lernen.[7] Wenn ein Schüler nicht zu einer mächtigeren Sprache ging, würde sich der Schüler noch an Basic erinnern.[7] Ein grundlegender Dolmetscher wurde in der installiert Mikrocomputer Ende der 1970er Jahre hergestellt. Als die Mikrocomputerindustrie wuchs, auch die Sprache.[7]
Grundlegende Pionierarbeit die interaktive Sitzung.[7] Es bot an Betriebssystem Befehle in seiner Umgebung:
- Der Befehl "neu" erstellte einen leeren Schiefer.
- Aussagen sofort bewertet.
- Aussagen könnten durch die Vorgehensweise mit einer Zeilennummer programmiert werden.
- Der Befehl 'List' zeigte das Programm an.
- Der Befehl "Run" wurde das Programm ausgeführt.
Die grundlegende Syntax war jedoch für große Programme zu einfach.[7] Neuere Dialekte haben Struktur und objektorientierte Erweiterungen hinzugefügt. Microsoft's Visual Basic wird immer noch weit verbreitet und produziert a grafische Benutzeroberfläche.[6]
C
C Programmiersprache (1973) haben seinen Namen, weil die Sprache BCPL wurde ersetzt durch B, und AT & T Bell Labs genannt die nächste Version "C." Sein Ziel war es, die zu schreiben Unix Betriebssystem.[49] C ist eine relativ kleine Sprache, die es einfach macht, Compiler zu schreiben. Das Wachstum spiegelte das Hardwarewachstum in den 1980er Jahren wider.[49] Sein Wachstum war auch, weil es die Einrichtungen von hat Montagesprache, verwendet aber a hochrangige Syntax. Es fügte erweiterte Funktionen hinzu wie:
- Inline -Assembler.
- Arithmetik auf Zeigern.
- Zeiger auf Funktionen.
- Bitoperationen.
- frei kombiniert Komplex Betreiber.[49]
C Ermöglicht dem Programmierer, zu steuern, welcher Bereich der Speicherdaten gespeichert werden soll. Globale Variablen und Statische Variablen die wenigsten benötigen Taktzyklen lagern. Das Stapel wird automatisch für die Standardvariable verwendet Erklärungen. Haufen Speicher wird an a zurückgegeben Zeigervariable von dem malloc ()
Funktion.
- Das globale und statische Daten Region liegt knapp über der Programm Region. (Die Programmregion wird technisch als die genannt Text Region. Hier werden Maschinenanweisungen gespeichert.)
- Die globale und statische Datenregion beträgt technisch gesehen zwei Regionen.[57] Eine Region heißt die initialisiert Datensegment, wobei Variablen, die mit Standardwerten deklariert sind, gespeichert werden. Die andere Region heißt die Block gestartet vom Segment, wo Variablen ohne Standardwerte deklariert werden.
- Variablen in der gespeicherten globale und statische Daten Region haben ihre Adressen auf Compile-Zeit einstellen. Sie behalten ihre Werte während des gesamten Lebens des Prozesses.
- Die globale und statische Region speichert die globale Variablen das werden über (außerhalb) deklariert
hauptsächlich()
Funktion.[58] Globale Variablen sind sichtbar fürhauptsächlich()
und jede andere Funktion im Quellcode.
- Die globale und statische Region speichert die globale Variablen das werden über (außerhalb) deklariert
- Andererseits variable Erklärungen innerhalb von von
hauptsächlich()
, andere Funktionen oder innerhalb{
}
Block -Abgrenzer sind Lokale Variablen. Lokale Variablen umfassen ebenfalls auch formaler Parameter Variablen. Parametervariablen sind in die Klammern von Funktionsdefinitionen eingeschlossen.[59] Sie liefern eine Schnittstelle zur Funktion.
- Lokale Variablen mit dem deklariert
statisch
Präfix werden auch in der gespeichert globale und statische Daten Region.[57] Im Gegensatz zu globalen Variablen sind statische Variablen nur innerhalb der Funktion oder des Blocks sichtbar. Statische Variablen behalten immer ihren Wert. Eine Beispielnutzung wäre die Funktionint increment_counter () {static int counter = 0; Zähler ++; Rückkehrzähler;}
- Lokale Variablen mit dem deklariert
- Das Stapel Region ist ein zusammenhängender Speicherblock in der Nähe der oberen Speicheradresse.[60] Variablen, die im Stapel platziert sind, sind von oben nach unten (nicht unten nach oben) gefüllt.[60] A Stapelzeiger ist ein Spezialzweck registrieren Das verfolgt die letzte Speicheradresse.[60] Variablen werden über die Stapel in den Stapel gegeben Montagesprache Anweisung drücken. Daher werden die Adressen dieser Variablen während festgelegt Laufzeit. Die Methode für Stapelvariablen, um ihre zu verlieren Umfang ist über die Pop -Anweisung.
- Lokale Variablen ohne die deklariert
statisch
Präfix, einschließlich formaler Parametervariablen,[61] werden genannt Automatische Variablen[58] und werden im Stapel aufbewahrt.[57] Sie sind in der Funktion oder im Block sichtbar und verlieren ihren Geltungsbereich, wenn sie die Funktion oder den Block verlassen.
- Lokale Variablen ohne die deklariert
- Das Haufen Die Region befindet sich unter dem Stapel.[57] Es ist von unten nach oben besiedelt. Das Betriebssystem verwaltet den Haufen mit a Haufenzeiger und eine Liste der zugewiesenen Speicherblöcke.[62] Wie der Stack werden die Adressen von HAVE -Variablen während der Laufzeit festgelegt. Ein aus dem Gedächtnis Fehler tritt auf, wenn sich der Haufenzeiger und der Stapelzeiger treffen.
- C Bietet die
malloc ()
Bibliotheksfunktion zu zuweisen Heap -Speicher.[63] Das Ausfüllen des Heaps mit Daten ist eine zusätzliche Kopienfunktion. Variablen, die im Haufen gespeichert sind, werden wirtschaftlich an Funktionen unter Verwendung von Zeigern übergeben. Ohne Hinweise müsste der gesamte Datenblock über den Stapel an die Funktion übergeben werden.
- C Bietet die
C ++
In den 1970ern, Software -Ingenieure benötigte Sprachunterstützung, um große Projekte in die Abteilung zu bringen Module.[64] Ein offensichtliches Merkmal bestand darin, große Projekte zu zersetzen physisch in getrennte Dateien. Ein weniger offensichtliches Merkmal bestand darin, große Projekte zu zersetzen logisch hinein abstrakt Datentypen.[64] Zu dieser Zeit unterstützten Sprachen Beton (Skalar) Datenatypen wie ganze Zahl Zahlen, Schwimmpunkt Zahlen und Saiten von Figuren. Konkrete Datentypen haben ihre Darstellung als Teil ihres Namens.[65] Abstrakte Datentypen sind Strukturen von konkreten Datentypen mit einem neuen Namen zugewiesen. Zum Beispiel a aufführen von Ganzzahlen könnte genannt werden INTEGER_LIST
.
In objektorientiertem Jargon werden abstrakte Datenatypen aufgerufen Klassen. Allerdings a Klasse ist nur eine Definition; Es wird kein Gedächtnis zugewiesen. Wenn eine Speicherin an eine Klasse zugeordnet wird, wird es als eine genannt Objekt.[66]
Objektorientierte imperative Sprachen entwickelt durch Kombination der Notwendigkeit von Klassen und der Notwendigkeit eines Safe Funktionelle Programmierung.[67] Eine Funktion in einer objektorientierten Sprache wird einer Klasse zugeordnet. Eine zugewiesene Funktion wird dann als als bezeichnet Methode, Mitgliedsfunktion, oder Betrieb. Objekt orientierte Programmierung führt aus Operationen an Objekte.[68]
Objektorientierte Sprachen Unterstützen Sie eine Syntax zum Modellieren Untergruppe/Superset Beziehungen. Im Mengenlehre, ein Element einer Untergruppe erbt alle in der Superset enthaltenen Attribute. Zum Beispiel ist ein Schüler eine Person. Daher ist die Gruppe der Schüler eine Teilmenge der Personenmenge. Infolgedessen erben die Schüler alle Attribute, die allen Personen gemeinsam sind. Darüber hinaus haben die Schüler einzigartige Attribute, die andere Personen nicht haben. Objektorientierte Sprachen Modell Untergruppe/Superset Beziehungen verwenden Nachlass.[69] Objekt orientierte Programmierung wurde Ende der neunziger Jahre zum dominanten Sprachparadigma.[64]
C ++ (1985) wurde ursprünglich "C mit Klassen" bezeichnet.[70] Es wurde entwickelt, um sich zu erweitern C's Fähigkeiten durch Hinzufügen der objektorientierten Einrichtungen der Sprache Simula.[71]
Ein objektorientiertes Modul besteht aus zwei Dateien. Die Definitionsdatei wird als die Datei bezeichnet Header-Datei. Hier ist ein C ++ Header-Datei für die Klassenklasse In einer einfachen Schulanwendung:
// grade.h // ------- // wird verwendet, um mehrere Quelldateien einzuschließen zu lassen // Diese Header -Datei ohne Duplizierungsfehler. // ---------------------------------------------- #IFNDEF GRADE_H #define grade_h Klasse KLASSE { Öffentlichkeit: // Dies ist der Konstruktorbetrieb. // ---------------------------------- KLASSE ( Const verkohlen Buchstabe ); // Dies ist eine Klassenvariable. // ------------------------- verkohlen Buchstabe; // Dies ist eine Mitgliedsoperation. // --------------------------- int grade_numeric( Const verkohlen Buchstabe ); // Dies ist eine Klassenvariable. // ------------------------- int numerisch; }; #endif
A Konstrukteur Die Operation ist eine Funktion mit demselben Namen wie der Klassenname.[72] Es wird ausgeführt, wenn der aufrufende Betrieb die ausführt Neu
Aussage.
Die andere Datei eines Moduls ist die Quelldatei. Hier ist eine C ++ - Quelldatei für die Klassenklasse In einer einfachen Schulanwendung:
// grade.cpp // --------- #enthalten "grade.h" KLASSE::KLASSE( Const verkohlen Buchstabe ) { // Referenz auf das Objekt mit dem Schlüsselwort 'This'. // ---------------------------------------------- Dies->Buchstabe = Buchstabe; // Dies ist der zeitliche Zusammenhalt // ------------------------- Dies->numerisch = grade_numeric( Buchstabe ); } int KLASSE::grade_numeric( Const verkohlen Buchstabe ) { wenn ( ( Buchstabe == 'EIN' || Buchstabe == 'a' ) ) Rückkehr 4; anders wenn ( ( Buchstabe == 'B' || Buchstabe == 'b' ) ) Rückkehr 3; anders wenn ( ( Buchstabe == 'C' || Buchstabe == 'c' ) ) Rückkehr 2; anders wenn ( ( Buchstabe == 'D' || Buchstabe == 'd' ) ) Rückkehr 1; anders wenn ( ( Buchstabe == 'F' || Buchstabe == 'f' ) ) Rückkehr 0; anders Rückkehr -1; }
Hier ist ein C ++ Header-Datei für die Personklasse In einer einfachen Schulanwendung:
// Person.h // -------- #ifndef person_h #define Person_h Klasse PERSON { Öffentlichkeit: PERSON ( Const verkohlen *Name ); Const verkohlen *Name; }; #endif
Hier ist ein C ++ Quelldatei für die Personklasse In einer einfachen Schulanwendung:
// Person.cpp // ---------- #enthalten "Person.h" PERSON::PERSON ( Const verkohlen *Name ) { Dies->Name = Name; }
Hier ist ein C ++ Header-Datei für die Schülerklasse In einer einfachen Schulanwendung:
// student.h // --------- #ifndef student_h #define student_h #enthalten "Person.h" #enthalten "grade.h" // Ein Schüler ist eine Teilmenge von Person. // -------------------------------- Klasse SCHÜLER : Öffentlichkeit PERSON{ Öffentlichkeit: SCHÜLER ( Const verkohlen *Name ); KLASSE *Klasse; }; #endif
Hier ist ein C ++ Quelldatei für die Schülerklasse In einer einfachen Schulanwendung:
// student.cpp // ----------- #enthalten "Student.h" #enthalten "Person.h" SCHÜLER::SCHÜLER ( Const verkohlen *Name ): // Führen Sie den Konstruktor der Person Superklasse aus. // ------------------------------------------------- PERSON( Name ) { // Nichts weiter zu tun. // ------------------- }
Hier ist ein Treiberprogramm zur Demonstration:
// student_dvr.cpp // --------------- #enthalten #enthalten "Student.h" int hauptsächlich( Leere ) { SCHÜLER *Schüler = Neu SCHÜLER( "Der Student" ); Schüler->Klasse = Neu KLASSE( 'a' ); std::Cout // Beachten Sie, dass der Schüler den Namen der Person erbt << Schüler->Name << ": Numerische Klasse =" << Schüler->Klasse->numerisch << "\n"; Rückkehr 0; }
Hier ist ein Makefile Alles kompilieren:
# Makefile # -------- alle: student_dvr sauber: rm student_dvr *.ostudent_dvr: student_dvr.CPP Klasse.o Schüler.o Person.o c ++ student_dvr.cpp grade.o student.o person.o -o student_dvrgrade.o: Klasse.CPP Klasse.h c ++ -c Grad.cppStudent.O: Schüler.CPP Schüler.h c ++ -c student.cppPerson.o: Person.CPP Person.h c ++ -c Person.cpp
Deklarative Sprachen
Imperative Sprachen eine Hauptkritik haben: einen Ausdruck zu A zuweisen nicht lokal Variable kann eine unbeabsichtigte erzeugen Nebeneffekt.[73] Deklarative Sprachen Lassen Sie im Allgemeinen die Zuordnungsanweisung und den Kontrollfluss weg. Sie beschreiben was Berechnung sollte durchgeführt werden und nicht wie es berechnen. Zwei breite Kategorien deklarativer Sprachen sind Funktionssprachen und Logische Sprachen.
Das Prinzip hinter a funktionale Sprache ist zu verwenden Lambda -Kalkül als Leitfaden für eine gut definierte semantisch.[74] In der Mathematik ist eine Funktion eine Regel, die Elemente von einem abbildert Ausdruck zu einer Reihe von Werte. Betrachten Sie die Funktion:
times_10 (x) = 10 * x
Das Ausdruck 10 * x
wird von der Funktion zugeordnet times_10 ()
zu einer Reihe von Werte. Einer Wert Es ist 20. Dies geschieht, wenn x 2. ist. Die Anwendung der Funktion ist also mathematisch geschrieben wie:
times_10 (2) = 20
A funktionale Sprache Der Compiler speichert diesen Wert nicht in einer Variablen. Stattdessen wird es drücken der Wert auf dem Computer des Computers Stapel Vor dem Einstellen der Programm zähler Zurück zur Aufruffunktion. Die Aufruffunktion wird dann Pop der Wert aus dem Stapel.[75]
Imperative Sprachen Unterstützen Sie Funktionen. Deswegen, Funktionelle Programmierung Kann in einer imperativen Sprache erreicht werden, wenn der Programmierer Disziplin verwendet. Allerdings a funktionale Sprache Wird diese Disziplin dem Programmierer durch seine Syntax zwingen. Funktionale Sprachen haben eine Syntax, die auf die Betonung des Schwerpunkts zugeschnitten ist was.[76]
Ein Funktionsprogramm wird mit einer Reihe primitiver Funktionen entwickelt, gefolgt von einer einzelnen Treiberfunktion.[73] Bedenke die Snippet:
Funktion max (a, b) { / * Code weggelassen * /}
Funktion min (a, b) { / * Code weggelassen * /}
Funktionsdifferenz_between_largest_and_smallest (a, b, c) {
return max (a, max (b, c)) - min (a, min (b, c));
}
Die Primitiven sind max ()
und Mindest()
. Die Treiberfunktion ist differenz_between_largest_and_smallest ()
. Ausführung:
put (Differenz_between_largest_and_smallest (10,4,7));
wird ausgeben 6.
Funktionssprachen werden in verwendet Informatik Forschung zur Erforschung neuer Sprachmerkmale.[77] Darüber hinaus hat ihr Mangel an Nebenwirkungen sie in beliebter gemacht Parallele Programmierung und gleichzeitige Programmierung.[78] Anwendungsentwickler bevorzugen jedoch die Objektorientierte Merkmale von Imperative Sprachen.[78]
Lispeln
Lispeln (1958) steht für "Listenprozessor".[79] Es ist auf den Prozess zugeschnitten Listen. Eine vollständige Struktur der Daten wird durch Erstellen von Listenlisten gebildet. Im Gedächtnis a Baumdatenstruktur ist gebaut. Intern kostet die Baumstruktur gut für rekursiv Funktionen.[80] Die Syntax zum Bau eines Baum Elemente innerhalb von Klammern. Das Folgende ist eine Liste von drei Elementen. Die ersten beiden Elemente sind selbst Listen von zwei Elementen:
((A b) (Hallo Welt) 94)
LISP hat Funktionen zum Extrahieren und Rekonstruktion von Elementen.[81] Die Funktion Kopf()
Gibt eine Liste zurück, die das erste Element in der Liste enthält. Die Funktion Schwanz()
Gibt eine Liste zurück, die alles außer dem ersten Element enthält. Die Funktion cons ()
Gibt eine Liste zurück, die die Verkettung anderer Listen ist. Daher gibt der folgende Ausdruck die Liste zurück x
:
Nachteile (Kopf (x), Schwanz (x))
Ein Nachteil von Lisp ist, wenn viele Funktionen verschachtelt sind, können die Klammern verwirrend aussehen.[76] Modern LISP Umgebungen Helfen Sie mit der Übereinstimmung mit Klammern. Abgesehen davon unterstützt Lisp die Imperative Sprache Operationen der Zuordnungserklärung und Goto -Schleifen.[82] Ebenfalls, Lispeln ist nicht mit dem besorgt Datentyp der Elemente zur Kompilierung.[83] Stattdessen weist es die Datenatypen bei zu (und kann neu zuweisen) Laufzeit. Das Zuweisen des Datentyps zur Laufzeit wird aufgerufen Dynamische Bindung.[84] Während die dynamische Bindung die Flexibilität der Sprache erhöht, können Programmierfehler bis spät in die Softwareentwicklungsprozess.[84]
Das Schreiben großer, zuverlässiger und lesbarer LiSP -Programme erfordert Voraussicht. Wenn das Programm ordnungsgemäß geplant ist, kann es viel kürzer sein als ein Äquivalent Imperative Sprache Programm.[76] Lispeln wird weit verbreitet in künstliche Intelligenz. Die Nutzung wurde jedoch nur akzeptiert, weil es hat Imperative Sprache Operationen, unbeabsichtigte Nebenwirkungen ermöglichen.[78]
Ml
Ml (1973)[85] steht für "Meta -Sprache". ML -Überprüfungen, um sicherzustellen, dass nur Daten desselben Typs miteinander verglichen werden.[86] Diese Funktion hat beispielsweise einen Eingabeparameter (eine Ganzzahl) und gibt eine Ganzzahl zurück:
Spaß times_10(n : int) : int = 10 * n;
Ml ist nicht auf Klammernsektion wie Lispeln. Das Folgende ist eine Anwendung von times_10 ()
:
times_10 2
Es gibt "20: int" zurück. (Sowohl die Ergebnisse als auch der Datentyp werden zurückgegeben.)
Wie Lispeln, Ml ist auf Prozesslisten zugeschnitten. nicht wie LispelnJedes Element ist der gleiche Datentyp.[87] Darüber hinaus, Ml weist den Datentyp eines Elements bei zu Kompilierungszeit. Das Zuweisen des Datentyps bei der Kompilierungszeit wird aufgerufen statische Bindung. Die statische Bindung erhöht die Zuverlässigkeit, da der Compiler den Kontext von Variablen überprüft, bevor sie verwendet werden.[88]
Prolog
Prolog (1972) steht für "Programmierung in Logik". Es wurde entwickelt, um zu verarbeiten natürliche Sprachen.[89] Die Bausteine eines Prolog -Programms sind Objekte und ihre Beziehungen zu anderen Objekten. Objekte sind gebaut, indem sie wahr sagen Fakten über sie.[90]
Mengenlehre Fakten werden gebildet, indem Sätze Objekte zugewiesen werden. Die Syntax ist setName (Objekt).
- Katze ist ein Tier.
Tier (Katze).
- Maus ist ein Tier.
Tier (Maus).
- Tom ist eine Katze.
Katze (Tom).
- Jerry ist eine Maus.
Maus (Jerry).
Adjektiv Fakten werden verwendet Adjektiv (Objekt).
- Katze ist groß.
große Katze).
- Maus ist klein.
kleine Maus).
Beziehungen werden unter Verwendung mehrerer Elemente in den Klammern gebildet. In unserem Beispiel haben wir Verb (Objekt, Objekt)
und Verb (Adjektiv, Adjektiv)
.
- Maus isst Käse.
Essen (Maus, Käse).
- Große Tiere essen kleine Tiere.
Essen (groß, klein).
Nachdem alle Fakten und Beziehungen eingegeben wurden, kann eine Frage gestellt werden:
- Wird Tom Jerry essen?
?- essen (Tom, Jerry).
Die Verwendung von Prolog hat sich zu einer zielorientierten Sprache erweitert.[91] In einer zielorientierten Anwendung wird das Ziel durch Bereitstellung einer Liste von Unterläufen definiert. Anschließend wird jedes Subzog definiert, indem eine Liste seiner Unterläufe usw. weiter bereitgestellt wird. Wenn ein Pfad der Untergürte keine Lösung finden, ist diese Subziele dann eine Lösung zurückgezogen und ein anderer Weg wird systematisch versucht.[90] Zu den praktischen Anwendungen gehört die Lösung der kürzestes Pfadproblem[89] und produzieren Stammbäume.[92]
Objekt orientierte Programmierung
Objekt orientierte Programmierung ist eine Programmiermethode zum Ausführen Operationen (Funktionen) an Objekte.[93] Die Grundidee besteht darin, die Eigenschaften von a zu gruppieren Phänomen in einen Objektbehälter und geben Sie dem Container einen Namen. Das Operationen Auf dem Phänomen werden ebenfalls in den Behälter gruppiert.[93] Objekt orientierte Programmierung entwickelt durch Kombination der Notwendigkeit von Behältern und der Notwendigkeit von Safe Funktionelle Programmierung.[94] Diese Programmiermethode muss nicht auf eine beschränkt sein objektorientierte Sprache.[95] In einer objektorientierten Sprache wird ein Objektbehälter a genannt Klasse. In einer nichtobjektorientierten Sprache a Datenstruktur (was auch als als bekannt ist Aufzeichnung) kann ein Objektbehälter werden. Um eine Datenstruktur in einen Objektcontainer zu verwandeln, müssen Operationen speziell für die Struktur geschrieben werden. Die resultierende Struktur wird als eine bezeichnet abstrakter Datentyp.[96] Jedoch, Nachlass wird fehlen. Trotzdem kann dieses Mangel überwunden werden.
Hier ist ein C Programmiersprache Header-Datei für die Grad abstrakter Datentyp In einer einfachen Schulanwendung:
/ * grade.h */ / * ------- */ / * Wird verwendet, um mehrere Quelldateien zu ermöglichen */enthalten /* Diese Header -Datei ohne Duplizierungsfehler. */ / * ------------------------------------------ *///////// #IFNDEF GRADE_H #define grade_h Typedef Struktur { verkohlen Buchstabe; } KLASSE; /* Konstrukteur */ / * ----------- */ KLASSE *grade_new( verkohlen Buchstabe ); int grade_numeric( verkohlen Buchstabe ); #endif
Das grade_new ()
Funktion führt den gleichen Algorithmus wie das C ++ durch Konstrukteur Betrieb.
Hier ist eine C -Programmiersprache Quelldatei für die Grad abstrakter Datentyp In einer einfachen Schulanwendung:
/ * grade.c */ / * ------- */ #enthalten "grade.h" KLASSE *grade_new( verkohlen Buchstabe ) { KLASSE *Klasse; / * HEAP -Speicher zuweisen *// / * -------------------- *// wenn ( ! ( Klasse = CALLOC( 1, Größe von( KLASSE ) ) ) ) { fprintf(Stderr, "Fehler in%s/%s/%d: calloc () leer zurückgegeben.\n", __DATEI__, __FUNKTION__, __LINIE__ ); Ausfahrt( 1 ); } Klasse->Buchstabe = Buchstabe; Rückkehr Klasse; } int grade_numeric( verkohlen Buchstabe ) { wenn ( ( Buchstabe == 'EIN' || Buchstabe == 'a' ) ) Rückkehr 4; anders wenn ( ( Buchstabe == 'B' || Buchstabe == 'b' ) ) Rückkehr 3; anders wenn ( ( Buchstabe == 'C' || Buchstabe == 'c' ) ) Rückkehr 2; anders wenn ( ( Buchstabe == 'D' || Buchstabe == 'd' ) ) Rückkehr 1; anders wenn ( ( Buchstabe == 'F' || Buchstabe == 'f' ) ) Rückkehr 0; anders Rückkehr -1; }
Im Konstruktor die Funktion CALLOC ()
wird anstelle von verwendet malloc ()
Weil jede Speicherzelle auf Null gesetzt wird.
Hier ist eine C -Programmiersprache Header-Datei für die Person abstrakter Datentyp In einer einfachen Schulanwendung:
/ * Person.h */ / * -------- *//// #ifndef person_h #define Person_h Typedef Struktur { verkohlen *Name; } PERSON; /* Konstrukteur */ / * ----------- */ PERSON *Person_New( verkohlen *Name ); #endif
Hier ist eine C -Programmiersprache Quelldatei für die Person abstrakter Datentyp In einer einfachen Schulanwendung:
/ * Person.c */ / * -------- *//// #enthalten "Person.h" PERSON *Person_New( verkohlen *Name ) { PERSON *Person; wenn ( ! ( Person = CALLOC( 1, Größe von( PERSON ) ) ) ) { fprintf(Stderr, "Fehler in%s/%s/%d: calloc () leer zurückgegeben.\n", __DATEI__, __FUNKTION__, __LINIE__ ); Ausfahrt( 1 ); } Person->Name = Name; Rückkehr Person; }
Hier ist eine C -Programmiersprache Header-Datei für die Student abstrakter Datentyp In einer einfachen Schulanwendung:
/ * student.h */ / * ---------- */// #ifndef student_h #define student_h #enthalten "Person.h" #enthalten "grade.h" Typedef Struktur { /* Ein Schüler ist eine Teilmenge von Person. */ / * -------------------------------- */ PERSON *Person; KLASSE *Klasse; } SCHÜLER; /* Konstrukteur */ / * ----------- */ SCHÜLER *student_new( verkohlen *Name ); #endif
Hier ist eine C -Programmiersprache Quelldatei für die Student abstrakter Datentyp In einer einfachen Schulanwendung:
/ * student.c */ / * ---------- */// #enthalten "Student.h" #enthalten "Person.h" SCHÜLER *student_new( verkohlen *Name ) { SCHÜLER *Schüler; wenn ( ! ( Schüler = CALLOC( 1, Größe von( SCHÜLER ) ) ) ) { fprintf(Stderr, "Fehler in%s/%s/%d: calloc () leer zurückgegeben.\n", __DATEI__, __FUNKTION__, __LINIE__ ); Ausfahrt( 1 ); } /* Führen Sie den Konstruktor der Person Superklasse aus. */ /* --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - */ Schüler->Person = Person_New( Name ); Rückkehr Schüler; }
Hier ist ein Treiberprogramm zur Demonstration:
/ * student_dvr.c */ / * -------------- *//// #enthalten #enthalten "Student.h" int hauptsächlich( Leere ) { SCHÜLER *Schüler = student_new( "Der Student" ); Schüler->Klasse = grade_new( 'a' ); printf( " %s: numerische Klasse = %d\n", /* Während eine Untergruppe existiert, ist die Vererbung dies nicht. */ Schüler->Person->Name, / * Funktionale Programmierung führt Funktionen Just-in-Time (JIT) *//// grade_numeric( Schüler->Klasse->Buchstabe ) ); Rückkehr 0; }
Hier ist ein Makefile Alles kompilieren:
# Makefile # -------- alle: student_dvr sauber: rm student_dvr *.ostudent_dvr: student_dvr.c Klasse.o Schüler.o Person.o gcc student_dvr.c Grad.o student.o person.o -o student_dvrgrade.o: Klasse.c Klasse.h gcc -c grade.cStudent.O: Schüler.c Schüler.h GCC -C Student.CPerson.o: Person.c Person.h gcc -c Person.c
Die formale Strategie zum Aufbau von objektorientierten Objekten ist:[97]
- 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 mit einem Namen identifiziert wird.
- Eine Note ist eine Leistung, die durch einen Brief identifiziert wird.
- Ein Schüler ist eine Person, die eine Note verdient.
Syntax und Semantik
Das Syntax einer Programmiersprache ist eine Liste von Produktionsregeln die es regieren bilden.[98] Eine Programmiersprache einer bilden ist die korrekte Platzierung seiner Erklärungen, Ausdrücke, und Aussagen.[99] Das Kompliment der Syntax einer Sprache ist ihre ihre Sprache Semantik. Das Semantik Beschreiben Sie die an verschiedenen syntaktischen Konstrukte verbundenen Bedeutungen.[98] Ein syntaktisches Konstrukt erfordert möglicherweise eine semantische Beschreibung, da ein Formular eine ungültige Interpretation aufweist.[100] Auch verschiedene Sprachen haben möglicherweise die gleiche Syntax; Ihr Verhalten kann jedoch unterschiedlich sein.
Die Syntax einer Sprache wird formell beschrieben, indem die Auflistung aufgelistet ist Produktionsregeln. Während die Syntax von a Natürliche Sprache ist extrem kompliziert, eine Untergruppe der englischen Sprache kann diese Produktionsregel -Auflistung haben:[101]
- a Satz besteht aus a Substantiv-Phrase gefolgt von einem Verbalphrase;
- a Substantiv-Phrase besteht aus einem zusammen Artikel gefolgt von an Adjektiv gefolgt von einem Substantiv;
- a Verbalphrase besteht aus a Verb gefolgt von einem Substantiv-Phrase;
- ein Artikel ist der';
- ein Adjektiv ist 'groß' oder
- ein Adjektiv ist klein';
- a Substantiv ist 'Katze' oder
- a Substantiv ist 'Maus';
- a Verb ist 'isst';
Die Wörter in Fettdruck sind als "Nicht-Terminale" bezeichnet. Die Wörter in "einzelnen Zitaten" werden als "Terminals" bezeichnet.[102]
Aus dieser Produktionsregel -Auflistung können vollständige Sätze unter Verwendung einer Reihe von Ersetzungen gebildet werden.[103] Der Prozess ist zu ersetzen Nicht-Terminale mit beiden gültig Nicht terminal oder ein gültiges Terminal. Der Ersatzvorgang wiederholt sich bis nur Terminals bleiben übrig. Ein gültiger Satz ist:
- Satz
- Substantiv-Phrase Verbalphrase
- Artikel Adjektiv Substantiv Verbalphrase
- das Adjektiv Substantiv Verbalphrase
- das groß Substantiv Verbalphrase
- das groß Katze Verbalphrase
- das groß Katze Verb Substantiv-Phrase
- das groß Katze isst Substantiv-Phrase
- das groß Katze isst Artikel Adjektiv Substantiv
- das groß Katze isst das Adjektiv Substantiv
- das groß Katze isst das klein Substantiv
- das groß Katze isst das klein Maus
Eine andere Kombination führt jedoch zu einem ungültigen Satz:
- das klein Maus isst das groß Katze
Daher a semantisch ist notwendig, um die Bedeutung eines korrekt zu beschreiben Essen Aktivität.
Einer Produktionsregel Die Auflistungsmethode wird als die genannt Backus -Naur -Form (BNF).[104] BNF beschreibt die Syntax einer Sprache und hat selbst eine Syntax. Diese rekursive Definition ist ein Beispiel für a Meta-Sprache.[98] Das Syntax von BNF beinhaltet:
-
:: =
was übersetzt besteht aus a [n] Wenn ein Nicht-Tterminal rechts ist. Es übersetzt ist Wenn ein Terminal rechts ist. -
|
was übersetzt oder. -
<
und>
welche umgeben Nicht-Terminale.
Mit BNF kann eine Untergruppe der englischen Sprache dies haben Produktionsregel Auflistung:
<Satz> :: = <Substantiv-Phrase> <Verbalphrase> <Substantiv-Phrase> :: = <Artikel> <Adjektiv> <Substantiv> <Verbalphrase> :: = <Verb> <Substantiv-Phrase> <Artikel> :: = das<Adjektiv> :: = groß | klein<Substantiv> :: = Katze | Maus<Verb> :: = isst
Verwenden von BNF, ein signiertes.ganze Zahl hat die Produktionsregel Auflistung:[105]
<Signiertes Intreiber> :: = <Schild> <ganze Zahl> <Schild> :: = + | - -<ganze Zahl> :: = <Ziffer> | <Ziffer> <ganze Zahl> <Ziffer> :: = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
Beachten Sie die rekursive Produktionsregel:
<ganze Zahl> :: = <Ziffer> | <Ziffer> <ganze Zahl>
Dies ermöglicht eine unendliche Anzahl von Möglichkeiten. Daher a semantisch ist notwendig, um eine Einschränkung der Anzahl der Ziffern zu beschreiben.
Beachten Sie die führende Null -Möglichkeit in den Produktionsregeln:
<ganze Zahl> :: = <Ziffer> | <Ziffer> <ganze Zahl> <Ziffer> :: = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
Daher a semantisch ist notwendig zu beschreiben, dass führende Nullen ignoriert werden müssen.
Es stehen zwei formale Methoden zur Beschreibung zur Verfügung Semantik. Sie sind Denotationssemantik und Axiomatische Semantik.[106]
Software -Engineering und Computerprogrammierung
Softwareentwicklung ist eine Vielzahl von Techniken zur Herstellung von Qualitätssoftware.[107] Computerprogrammierung ist der Prozess des Schreibens oder Bearbeitens Quellcode. In einer formalen Umgebung a System-Analytiker sammelt Informationen von Managern über alle Prozesse der Organisation, um sie zu automatisieren. Dieser Fachmann bereitet dann a vor Detaillierter Plan Für das neue oder modifizierte System.[108] Der Plan ist analog zum Blaupause eines Architekten.[108]
Leistungsziele
Der Systemanalyst hat das Ziel, die richtigen Informationen zur richtigen Zeit an die richtige Person zu liefern.[109] Die kritischen Faktoren, um dieses Ziel zu erreichen, sind:[109]
- Die Qualität der Ausgabe. Ist die Ausgabe nützlich für die Entscheidungsfindung?
- Die Genauigkeit der Ausgabe. Spiegelt es die wahre Situation wider?
- Das Format der Ausgabe. Ist die Ausgabe leicht verstanden?
- Die Geschwindigkeit der Ausgabe. Zeitsensible Informationen sind wichtig, wenn Sie in Echtzeit mit dem Kunden kommunizieren.
Kostenziele
Das Erreichen der Leistungsziele sollte mit allen Kosten ausgeglichen werden, einschließlich:[110]
- Entwicklungskosten.
- Einzigartigkeitskosten. Ein wiederverwendbares System kann teuer sein. Es kann jedoch gegenüber einem begrenzten Nutzungssystem bevorzugt werden.
- Hardwarekosten.
- Betriebskosten.
Anwendung a Systementwicklungsprozess Minder Sie das Axiom: Je später im Prozess ein Fehler festgestellt wird, desto teurer ist er zu korrigieren.[111]
Wasserfall-Modell
Das Wasserfall-Modell ist eine Implementierung von a Systementwicklungsprozess.[112] Als die Wasserfall Die Etikett impliziert, dass sich die grundlegenden Phasen gegenseitig überlappen:[113]
- Das Untersuchungsphase ist das zugrunde liegende Problem zu verstehen.
- Das Analysephase ist die möglichen Lösungen zu verstehen.
- Das Design-Phase ist die beste Lösung zu planen.
- Das Implementierungsphase ist die beste Lösung zu programmieren.
- Das Wartungsphase dauert während des gesamten Lebens des Systems. Änderungen am System nach dem Einsatz können erforderlich sein.[114] Es können Fehler bestehen, einschließlich Spezifikationsfehler, Konstruktionsfehler oder Codierungsfehler. Verbesserungen können erforderlich sein. Eine Anpassung kann erforderlich sein, um auf eine sich ändernde Umgebung zu reagieren.
Computerprogrammierer
A Computerprogrammierer ist ein Spezialist, der für das Schreiben oder Ändern des Quellcodes verantwortlich ist, um den detaillierten Plan zu implementieren.[108] Ein Programmierteam wird wahrscheinlich benötigt, da die meisten Systeme zu groß sind, um von einem einzelnen Programmierer abzuschließen.[115] Das Hinzufügen von Programmierern zu einem Projekt kann jedoch die Abschlusszeit nicht verkürzt. Stattdessen kann es die Qualität des Systems verringern.[115] Um effektiv zu sein, müssen Programmmodule definiert und an Teammitglieder verteilt werden.[115] Außerdem müssen Teammitglieder auf sinnvolle und effektive Weise miteinander interagieren.[115]
Computerprogrammierer können sein Programmierung in den Klassen: Programmierung innerhalb eines einzelnen Moduls.[116] Es besteht die Möglichkeit, dass ein Modul Module ausführt, die sich in anderen Quellcodedateien befinden. Daher können Computerprogrammierer sein Programmierung in der großen Zeit: Programmiermodule, damit sie effektiv miteinander koppeln.[116]
Programmmodule
Modulare Programmierung ist eine Technik zum Verfeinern Imperative Sprache Programme. Raffinierte Programme können die Softwaregröße, die separaten Verantwortlichkeiten reduzieren und dadurch mildern Softwarealterung. EIN Programmmodul ist eine Abfolge von Aussagen, die innerhalb a begrenzt sind Block und zusammen mit einem Namen identifiziert.[117] Module haben a Funktion, Kontext, und Logik:[118]
- Das Funktion eines Moduls ist das, was es tut.
- Das Kontext eines Moduls sind die Elemente, auf die durchgeführt wird.
- Das Logik eines Moduls ist, wie es die Funktion ausführt.
Der Name des Moduls sollte zuerst durch seine abgeleitet werden Funktiondann durch seine Kontext. Es ist Logik sollte nicht Teil des Namens sein.[118] Zum Beispiel, Funktion compute_square_root (x)
oder Funktion compute_square_root_integer (i: Integer)
sind geeignete Modulnamen. Jedoch, Funktion compute_square_root_by_division (x)
ist nicht.
Der Grad der Wechselwirkung innerhalb Ein Modul ist sein Niveau von Zusammenhalt.[118] Zusammenhalt ist ein Urteil über die Beziehung zwischen dem Namen eines Moduls und seinem Funktion. Der Grad der Wechselwirkung zwischen Module ist die Ebene von Kupplung.[119] Kupplung ist ein Urteil über die Beziehung zwischen dem eines Moduls Kontext und die Elemente, auf die aufgeführt wird.
Zusammenhalt
Der Zusammenhalt von schlimmsten zum besten ist:[120]
- Zufälliger Zusammenhalt: Ein Modul hat zufälligen Zusammenhalt, wenn es mehrere Funktionen ausführt, und die Funktionen sind völlig nichts miteinander zu tun. Zum Beispiel,
Funktion read_sales_record_print_next_line_convert_to_float ()
. Zufälliger Zusammenhalt tritt in der Praxis auf, wenn das Management dumme Regeln erzwingt. Zum Beispiel "hat jedes Modul zwischen 35 und 50 ausführbare Anweisungen."[120] - Logischer Zusammenhalt: Ein Modul hat einen logischen Zusammenhalt, wenn es eine Reihe von Funktionen zur Verfügung stellt, aber nur eines von ihnen wird ausgeführt. Zum Beispiel,
Funktion Perform_arithmetic (Perform_addition, a, b)
. - Zeitlicher Zusammenhalt: Ein Modul hat einen zeitlichen Zusammenhalt, wenn es Funktionen im Zusammenhang mit der Zeit erbringt. Ein Beispiel,
Funktion initialize_variables_and_open_files ()
. Ein anderes Beispiel,Bühne eins()
,Stage_two ()
, ... - Verfahrenszusammenhalt: Ein Modul verfügt über einen prozeduralen Zusammenhalt, wenn es mehrere Funktionen ausführt, jedoch nur locker miteinander verbunden ist. Zum Beispiel,
Funktion read_part_number_update_jorometee_record ()
. - Kommunikationskohäsion: Ein Modul verfügt über einen Kommunikationskohäsion, wenn es mehrere Funktionen ausführt, aber eng verwandt ist. Zum Beispiel,
Funktion read_part_number_update_sales_record ()
. - Informationskohäsion: Ein Modul verfügt über einen informativen Zusammenhalt, wenn es mehrere Funktionen ausführt, aber jede Funktion hat ihre eigenen Eingangs- und Ausstiegspunkte. Darüber hinaus teilen die Funktionen dieselbe Datenstruktur. Objektorientierte Klassen funktionieren auf dieser Ebene.
- Funktioneller Zusammenhalt: Ein Modul hat einen funktionalen Zusammenhalt, wenn es ein einziges Ziel erreicht, das nur für lokale Variablen funktioniert. Darüber hinaus kann es in anderen Kontexten wiederverwendbar sein.
Kupplung
Die Kupplungsniveaus von schlimmsten zum besten sind:[119]
- Inhaltskupplung: Ein Modul hat eine Inhaltskupplung, wenn es eine lokale Variable einer anderen Funktion ändert. Cobol tat dies früher mit dem ändern Verb.
- Gemeinsame Kopplung: Ein Modul hat eine gemeinsame Kopplung, wenn es eine globale Variable ändert.
- Kontrollkupplung: Ein Modul hat eine Steuerung, wenn ein anderes Modul es ändern kann Steuerfluss. Zum Beispiel,
Perform_arithmetic (Perform_Addition, a, b)
. Stattdessen sollte die Kontrolle über das Make -up des zurückgegebenen Objekts liegen. - Briefmarkenkopplung: Ein Modul verfügt über eine Stempelkopplung, wenn ein Element einer als Parameter übergebenen Datenstruktur geändert wird. Objektorientierte Klassen funktionieren auf dieser Ebene.
- Datenkopplung: Ein Modul hat eine Datenkopplung, wenn alle seine Eingabeparameter benötigt werden und keines davon geändert wird. Darüber hinaus wird das Ergebnis der Funktion als einzelnes Objekt zurückgegeben.
Datenflussanalyse
Datenflussanalyse ist eine Entwurfsmethode, mit der Module von erreicht werden Funktioneller Zusammenhalt und Datenkopplung.[121] Die Eingabe der Methode ist a Datenflussdiagramm. Ein Datenstromdiagramm ist ein Satz 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 verfügt auch über Pfeile, die Module miteinander verbinden. Pfeile, die in Module zeigen, stellen eine Reihe von Eingängen dar. Jedes Modul sollte nur einen Pfeil aus ihm zeigen, um sein einzelnes Ausgabeobjekt darzustellen. (Optional weist ein zusätzlicher Ausnahmepfeil hervor.) A Daisy-Chain von Ovalen wird eine ganze vermitteln Algorithmus. Die Eingangsmodule sollten das Diagramm starten. Die Eingangsmodule sollten eine Verbindung zu den Transformationsmodulen herstellen. Die Transformationsmodule sollten eine Verbindung zu den Ausgangsmodulen herstellen.[122]
Funktionskategorien
Computerprogramme kann entlang funktionaler Linien kategorisiert werden. Die wichtigsten funktionalen Kategorien sind Anwendungssoftware und Systemsoftware. Systemsoftware enthält die Betriebssystem, welche Paare Computerhardware mit Anwendungssoftware.[123] Der Zweck des Betriebssystems besteht darin, eine Umgebung bereitzustellen, in der Anwendungssoftware bequem und effizient ausgeführt wird.[123] Sowohl Anwendungssoftware als auch Systemsoftware führen aus Dienstprogramme. Auf Hardwareebene a Mikrocode -Programm kontrolliert die Schaltungen im gesamten Zentrale Verarbeitungseinheit.
Anwendungssoftware
Anwendungssoftware ist der Schlüssel zur Erschließung des Potenzials des Computersystems.[124] Enterprise Application Software Bündel Accounting-, Personal-, Kunden- und Lieferantenanwendungen. Beispiele beinhalten Unternehmensressourcenplanung, Kundenbeziehungsmanagement, und Supply Chain Management -Software.
Enterprise-Anwendungen können als einzigartige Sachgebiet intern entwickelt werden proprietäre Software.[124] Alternativ können sie als gekauft werden als Off-the-Shelf-Software. Gekaufte Software kann geändert werden, um bereitzustellen kundenspezifische Software. Wenn die Anwendung angepasst wird, werden entweder die Ressourcen des Unternehmens verwendet oder die Ressourcen ausgelagert. Die ausgelagerte Softwareentwicklung kann vom ursprünglichen Softwareanbieter oder einem Drittentwickler stammen.[124]
Die Vorteile der proprietären Software sind Funktionen und Berichte können genau zur Spezifikation sein.[125] Das Management kann auch am Entwicklungsprozess beteiligt sein und ein Maß an Kontrolle bieten. Das Management kann sich entscheiden, der neuen Initiative eines Wettbewerbers entgegenzuwirken oder eine Kunden- oder Lieferantenanforderung zu implementieren. Eine Fusion oder Akquisition erfordert Änderungen der Unternehmenssoftware.[125] Die Nachteile der proprietären Software sind die Zeit und die Ressourcenkosten können umfangreich sein.[125] Darüber hinaus können Risiken in Bezug auf Merkmale und Leistungen vorliegen.
Die Vorteile von Software aus der Hand sind ihre identifizierbaren Vorabkosten, die Grundbedürfnisse sollten erfüllt werden und seine Leistung und Zuverlässigkeit haben eine Erfolgsbilanz.[125] Die Nachteile von Off-the-Shelf-Software sind möglicherweise unnötige Funktionen, die Endbenutzer verwirren, es fehlen die Funktionen, die das Unternehmen benötigt, und der Datenfluss stimmt möglicherweise nicht mit den Arbeitsprozessen des Unternehmens überein.[125]
Ein Ansatz zur wirtschaftlichen Erlangung einer individuellen Unternehmensanwendung ist über eine Anwendungsanbieter.[126] Spezialunternehmen bieten die Hardware-, benutzerdefinierte Software- und Endbenutzerunterstützung. Sie können die Entwicklung neuer Anwendungen beschleunigen, da sie Mitarbeiter des erfahrenen Informationssystems besitzen. Der größte Vorteil ist, dass es interne Ressourcen von der Personalabteilung und Verwaltung komplexer Computerprojekte befreit.[126] Viele Anwendungsdienstanbieter richten sich an kleine, schnell wachsende Unternehmen mit begrenzten Ressourcen für Informationssysteme.[126] Andererseits werden größere Unternehmen mit großen Systemen wahrscheinlich ihre technische Infrastruktur bestehen. Ein Risiko besteht darin, einer externen Organisation mit sensiblen Informationen vertrauen zu müssen. Ein weiteres Risiko besteht darin, der Infrastrukturzuverlässigkeit des Anbieters zu vertrauen.[126]
Betriebssystem
Ein Betriebssystem ist die Software mit niedriger Ebene, die die grundlegenden Funktionen eines Computers unterstützt, wie z. Planung Prozesse und Kontrolle Peripheriegeräte.[123]
In den 1950er Jahren schrieb der Programmierer, der auch der Betreiber war, ein Programm und leitete es. Nachdem das Programm ausgeführt wurde, wurde die Ausgabe möglicherweise gedruckt oder für die spätere Verarbeitung auf Papierband oder Karten gestanzt.[27] Meistens hat das Programm nicht funktioniert. Der Programmierer betrachtete dann die Konsolenlichter und fummelte mit den Konsolenschaltern. Bei weniger Glück wurde ein Speicherausdruck für weitere Untersuchungen gemacht. In den 1960er Jahren reduzierten Programmierer die Zeitverschwendung, indem sie den Job des Betreibers automatisieren. Ein Programm namens ein Betriebssystem wurde immer im Computer gehalten.[127]
Der Begriff Betriebssystem kann sich auf zwei Softwareebenen beziehen.[128] Das Betriebssystem kann sich auf die beziehen Kernelprogramm das verwaltet das Prozesse, Erinnerung, und Geräte. Im weiteren Sinne kann sich das Betriebssystem auf das gesamte Paket der zentralen Software beziehen. Das Paket enthält ein Kernel -Programm, Befehlszeilen-Interpreter, grafische Benutzeroberfläche, Dienstprogramme, und Editor.[128]
Kernelprogramm
Der Hauptzweck des Kernels besteht darin, die begrenzten Ressourcen eines Computers zu verwalten:
- Das Kernel -Programm sollte durchgeführt werden Prozessplanung.[129] Der Kerner erstellt a Prozesssteuerungsblock Wenn ein Programm für die Ausführung ausgewählt wird. Ein ausführendes Programm erhält jedoch einen exklusiven Zugriff auf die Zentrale Verarbeitungseinheit nur für a Zeitscheibe. Um jedem Benutzer mit dem zu versorgen Aussehen des kontinuierlichen Zugangs, der Kernel schnell Vorbewegungen Jeder Prozesssteuerungsblock, um einen anderen auszuführen. Das Ziel für Systementwickler ist minimieren Versandlatenz.
- Das Kernel -Programm sollte durchgeführt werden Speicherverwaltung.
- Wenn der Kernel anfangs Ladungen eine ausführbare Datei in den Speicher, es unterteilt den Adressraum logischerweise in Regionen.[130] Der Kernel unterhält eine Master-Region-Tabelle und viele Tische pro Prozess-Region (Pregion)-eine für jedes Laufen Prozess.[130] Diese Tabellen bilden die Virtueller Adressraum. Die Master-Region-Tabelle wird verwendet, um festzustellen, wo sich der Inhalt befindet physikalischer Speicher. Die Pregion -Tabellen ermöglichen es jedem Prozess, ein eigenes Programm (Text) Pregion, Data Pregion und Stack Pregion zu haben.
- Das Programm Pregion speichert Maschinenanweisungen. Da sich die Maschinenanweisungen nicht ändern, kann das Programm -Pregion von vielen Prozessen derselben ausführbaren Datei geteilt werden.[130]
- Um Zeit und Speicher zu sparen, kann der Kernel nur Ausführungsanweisungen aus dem Festplattenlaufwerk laden, nicht die gesamte Ausführungsdatei vollständig.[129]
- Der Kernel ist verantwortlich für die Übersetzung virtueller Adressen in physische Adressen. Der Kernel kann Daten von der anfordern Speichercontroller und stattdessen eine erhalten a Seitenfehler.[131] Wenn ja, greift der Kernel auf die zu Speicherverwaltungseinheit Um den physischen Datenbereich zu bevölkern und die Adresse zu übersetzen.[132]
- Der Kernel verteilt das Gedächtnis an die Haufen auf Anfrage durch einen Prozess.[63] Wenn der Vorgang mit dem Speicher abgeschlossen ist, kann der Vorgang dies beantragen, um dies zu sein befreit. Wenn der Prozess ausgeht, ohne alle zugewiesenen Speicher befreit zu werden, führt der Kernel durch Müllsammlung den Gedächtnis zu befreien.
- Der Kernel versichert auch, dass ein Prozess nur auf sein eigenes Gedächtnis und nicht auf den des Kernels oder anderen Prozesse zugreift.[129]
- Das Kernel -Programm sollte durchgeführt werden Dateisystemverwaltung.[129] Der Kernel verfügt über Anweisungen zum Erstellen, Abrufen, Aktualisieren und Löschen von Dateien.
- Das Kernel -Programm sollte durchgeführt werden Geräteverwaltung.[129] Der Kernel bietet Programme zur Standardisierung und Vereinfindung der Schnittstelle zu Maus, Tastatur, Festplattenantrieben, Druckern und anderen Geräten. Darüber hinaus sollte der Kernel den Zugriff auf ein Gerät entlasten, wenn zwei Prozesse es gleichzeitig anfordern.
- Das Kernel -Programm sollte durchgeführt werden Netzwerk Management.[133] Der Kernel überträgt und empfängt Pakete im Namen von Prozessen. Ein wichtiger Service besteht darin, einen effizienten zu finden Route zum Zielsystem.
- Das Kernel -Programm sollte bereitstellen Systemebene Funktionen für Programmierer zu verwenden.[134]
- Programmierer greifen über eine relativ einfache Schnittstelle auf Dateien zu, die wiederum eine relativ komplizierte E/A-Schnittstelle ausführt. Die Schnittstelle auf niedriger Ebene enthält die Erstellung von Dateien. Dateideskriptoren, Dateisuche, physisches Lesen und physisches Schreiben.
- Programmierer erstellen Prozesse über eine relativ einfache Schnittstelle, die wiederum eine relativ komplizierte Schnittstelle auf niedriger Ebene ausführt.
- Programmierer führen das Datum/die Uhrarithmetik über eine relativ einfache Schnittstelle durch, die wiederum eine relativ komplizierte Zeit mit niedriger Ebene ausführt.[135]
- Das Kernel -Programm sollte a bereitstellen Kommunikationskanal zwischen Ausführungsprozessen.[136] Für ein großes Softwaresystem kann es wünschenswert sein zu Techniker Das System in kleinere Prozesse. Prozesse können durch Senden und Empfangen miteinander kommunizieren Signale.
Ursprünglich wurden Betriebssysteme in programmiert Montage; Moderne Betriebssysteme sind jedoch in der Regel in Sprachen auf höherer Ebene wie geschrieben wie C, Ziel c, und Schnell.[d]
Dienstprogramm
A Dienstprogramm ist entwickelt, um die Systemverwaltung und die Softwareausführung zu unterstützen. Betriebssysteme führen Hardware -Dienstprogramme aus, um den Status von Datenträgern, Speicher, Sprechern und Druckern zu überprüfen.[137] Ein Versorgungsprogramm kann die Platzierung einer Datei auf einer überfüllten Festplatte optimieren. System Utility -Programme überwachen die Hardware- und Netzwerkleistung. Wenn sich eine Metrik außerhalb eines akzeptablen Bereichs befindet, wird eine Auslöseralarm erzeugt.[138]
Die Versorgungsprogramme enthalten Komprimierungsprogramme, sodass Datendateien auf weniger Speicherplatz gespeichert werden.[137] Komprimierte Programme sparen auch Zeit, wenn Datendateien über das Netzwerk übertragen werden.[137] Dienstprogramme können Datensätze sortieren und zusammenführen.[138] Dienstprogramme erkennen Computer Virus.[138]
Mikrocode -Programm
A Mikrocode -Programm ist der Dolmetscher der unteren Ebene, der die steuert Datenweg von softwareorientierten Computern.[139] (Fortschritte in der Hardware- haben diese Operationen auf migriert Hardware -Ausführungsschaltungen.))[139] Mit Microcode -Anweisungen können der Programmierer die einfacher implementieren digitale Logikstufe[140]- Die echte Hardware des Computers. Die digitale Logikstufe ist die Grenze zwischen Informatik und Technische Informatik.[141]
A Logik -Tor ist winzig Transistor Das kann eines von zwei Signalen zurückgeben: ein- oder ausgeschaltet.[142]
- Ein Transistor bildet die Kein Tor.
- Anschließen von zwei Transistoren in Serienformen die NAND -Tor.
- Anschluss von zwei Transistoren in parallelen Formen die Noch Tor.
- Das Verbinden eines Nicht -Tors mit einem NAND -Tor bildet die Und Tor.
- Das Verbinden eines Gates mit einem oder Gate bildet die Oder Tor.
Diese fünf Tore bilden die Bausteine von Binäralgebra- Die digitalen Logikfunktionen des Computers.
Mikrocode -Anweisungen sind Mnemonik Programmierer können digitale Logikfunktionen ausführen, anstatt sie in binären Algebra zu bilden. Sie werden in einem gespeichert Zentrale Verarbeitungseinheit (ZENTRALPROZESSOR) Steuergeschäft.[143] Diese Anweisungen auf Hardwareebene verschieben Daten im gesamten Datenweg.
Der Mikroinstruktionszyklus beginnt, wenn der Mikrosequencer verwendet seinen Mikroprogramm -Zähler zu bringen der nächste Maschinenanweisung aus Arbeitsspeicher.[144] Der nächste Schritt ist zu dekodieren Die Maschinenanweisung durch Auswahl der richtigen Ausgangsleitung zum Hardwaremodul.[145] Der letzte Schritt ist zu ausführen Der Befehl mit dem Tatsatz des Hardware -Moduls.
Anweisungen zur Ausführung von Arithmetik werden durch eine geleitet Arithmetik-Logikeinheit (Alu).[146] Die ALU verfügt über Schaltungen, um Elementaroperationen auszuführen, um Ganzzahlen hinzuzufügen, zu verschieben und zu vergleichen. Durch Kombinieren und Schleifen der Elementaroperationen durch die ALU führt die CPU ihre komplexe Arithmetik durch.
Mikrocode -Anweisungen verschieben Daten zwischen der CPU und der Speichercontroller. Speichercontroller -Mikrocode -Anweisungen manipulieren zwei Register. Das Speicheradressregister wird verwendet, um auf die Adresse jeder Speicherzelle zuzugreifen. Das Speicherdatenregister wird verwendet, um den Inhalt jeder Zelle zu setzen und zu lesen.[147]
Mikrocode -Anweisungen verschieben Daten zwischen der CPU und den vielen Computerbusse. Das Diskontrollerbus schreibt an und liest von Festplattenfahrten. Daten werden auch zwischen der CPU und anderen Funktionseinheiten über die verschoben Peripheriekomponente Interconnect Express Bus.[148]
Anmerkungen
Verweise
- ^ "ISO/IEC 2382: 2015". ISO. 2020-09-03. Abgerufen 2022-05-26.
[Software umfasst] alle oder Teil der Programme, Verfahren, Regeln und zugehörigen Dokumentationen eines Informationsverarbeitungssystems.
- ^ a b Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 7. ISBN 0-201-71012-9.
- ^ Silberschatz, Abraham (1994). Betriebssystemkonzepte, vierte Ausgabe. Addison-Wesley. p. 98. ISBN 978-0-201-50480-4.
- ^ Tanenbaum, Andrew S. (1990). Strukturierte Computerorganisation, dritte Ausgabe. Prentice Hall. p.32. ISBN 978-0-13-854662-5.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 30. ISBN 0-201-71012-9.
Ihre Absicht war es, eine Sprache zu produzieren, die für die Schüler sehr einfach zu lernen war [.]
- ^ a b c Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 31. ISBN 0-201-71012-9.
- ^ a b c d e f Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 30. ISBN 0-201-71012-9.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 30. ISBN 0-201-71012-9.
Die Idee war, dass die Schüler nur Gelegenheitsbenutzer sein oder von grundlegender bis hin zu anspruchsvolleren und leistungsfähigeren Sprachen übergehen können [.]
- ^ a b McCartney, Scott (1999). Eniac - Die Triumphe und Tragödien des ersten Computers der Welt. Walker und Gesellschaft. p.16. ISBN 978-0-8027-1348-3.
- ^ Tanenbaum, Andrew S. (1990). Strukturierte Computerorganisation, dritte Ausgabe. Prentice Hall. p.14. ISBN 978-0-13-854662-5.
- ^ Bromley, Allan G. (1998). "Charles Babbag's Analytical Engine, 1838" (PDF). IEEE Annals of the History of Computing. 20 (4): 29–45. doi:10.1109/85.728228. S2CID 2285332.
- ^ a b Tanenbaum, Andrew S. (1990). Strukturierte Computerorganisation, dritte Ausgabe. Prentice Hall. p.15. ISBN 978-0-13-854662-5.
- ^ J. Fuegi; J. Francis (Oktober - Dezember 2003), "Lovelace & Babbage und die Schaffung der 'Notizen von 1843'",", Annalen der Geschichte des Computers, 25 (4): 16, 19, 25, doi:10.1109/mahc.2003.1253887
- ^ Rosen, Kenneth H. (1991). Diskrete Mathematik und ihre Anwendungen. McGraw-Hill, Inc. p.654. ISBN 978-0-07-053744-6.
Turing -Maschinen können alle Berechnungen modellieren, die auf einer Computermaschine durchgeführt werden können.
- ^ Linz, Peter (1990). Eine Einführung in formelle Sprachen und Automaten. D. C. Heath and Company. p. 234. ISBN 978-0-669-17342-0.
- ^ Linz, Peter (1990). Eine Einführung in formelle Sprachen und Automaten. D. C. Heath and Company. p. 243. ISBN 978-0-669-17342-0.
[A] ll Die gemeinsamen mathematischen Funktionen, egal wie kompliziert es ist, sind erfüllbar.
- ^ a b c McCartney, Scott (1999). Eniac - Die Triumphe und Tragödien des ersten Computers der Welt. Walker und Gesellschaft. p.102. ISBN 978-0-8027-1348-3.
- ^ McCartney, Scott (1999). Eniac - Die Triumphe und Tragödien des ersten Computers der Welt. Walker und Gesellschaft. p.94. ISBN 978-0-8027-1348-3.
- ^ McCartney, Scott (1999). Eniac - Die Triumphe und Tragödien des ersten Computers der Welt. Walker und Gesellschaft. p.107. ISBN 978-0-8027-1348-3.
- ^ McCartney, Scott (1999). Eniac - Die Triumphe und Tragödien des ersten Computers der Welt. Walker und Gesellschaft. p.120. ISBN 978-0-8027-1348-3.
- ^ a b McCartney, Scott (1999). Eniac - Die Triumphe und Tragödien des ersten Computers der Welt. Walker und Gesellschaft. p.118. ISBN 978-0-8027-1348-3.
- ^ McCartney, Scott (1999). Eniac - Die Triumphe und Tragödien des ersten Computers der Welt. Walker und Gesellschaft. p.119. ISBN 978-0-8027-1348-3.
- ^ McCartney, Scott (1999). Eniac - Die Triumphe und Tragödien des ersten Computers der Welt. Walker und Gesellschaft. p.123. ISBN 978-0-8027-1348-3.
- ^ a b Tanenbaum, Andrew S. (1990). Strukturierte Computerorganisation, dritte Ausgabe. Prentice Hall. p.21. ISBN 978-0-13-854662-5.
- ^ a b Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 27. ISBN 0-201-71012-9.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 29. ISBN 0-201-71012-9.
- ^ a b c Silberschatz, Abraham (1994). Betriebssystemkonzepte, vierte Ausgabe. Addison-Wesley. p. 6. ISBN 978-0-201-50480-4.
- ^ a b c d e f g h i "Bill Pentz-ein bisschen Hintergrund: Der Nachkriegsmarsch nach VLSI". Digibarn -Computermuseum. August 2008. Abgerufen 31. Januar, 2022.
- ^ a b Zum digitalen Zeitalter: Forschungslabors, Start-up-Unternehmen und der Aufstieg von MOS. Johns Hopkins University Press. 2002. ISBN 9780801886393. Abgerufen 3. Februar, 2022.
- ^ Chalamala, Babu (2017). "Herstellung von Siliziummaterialien für Mikroelektronik und Solar PV". Sandia National Laboratories. Abgerufen 8. Februar, 2022.
- ^ "Herstellung von ICs, die einen Basiswafer machen". Britannica. Abgerufen 8. Februar, 2022.
- ^ "Einführung in NMOS- und PMOS -Transistoren". Anysilicon. 4. November 2021. Abgerufen 5. Februar, 2022.
- ^ "Mikroprozessordefinition". Britannica. Abgerufen 1. April, 2022.
- ^ "Chip Hall of Fame: Intel 4004 Mikroprozessor". Institut für Elektro- und Elektronikingenieure. 2. Juli 2018. Abgerufen 31. Januar, 2022.
- ^ "360 Revolution" (PDF). Vater, Sohn & Co. 1990. Abgerufen 5. Februar, 2022.
- ^ a b "Innerhalb des lang verlorenen ersten Mikrocomputers der Welt". C/Netz. 8. Januar 2010. Abgerufen 31. Januar, 2022.
- ^ "Bill Gates, Microsoft und der IBM -PC". InfoWorld. 23. August 1982. Abgerufen 1. Februar 2022.
- ^ a b Stroustrup, Bjarne (2013). Die C ++ - Programmiersprache, vierte Ausgabe. Addison-Wesley. p. 10. ISBN 978-0-321-56384-2.
- ^ a b c Stroustrup, Bjarne (2013). Die C ++ - Programmiersprache, vierte Ausgabe. Addison-Wesley. p. 11. ISBN 978-0-321-56384-2.
- ^ a b Treir, Ralph M. (2003). Prinzipien der Informationssysteme, Sechste Ausgabe. Thomson. p. 159. ISBN 0-619-06489-7.
- ^ a b Linz, Peter (1990). Eine Einführung in formelle Sprachen und Automaten. D. C. Heath and Company. p. 2. ISBN 978-0-669-17342-0.
- ^ Weiss, Mark Allen (1994). Datenstrukturen und Algorithmusanalyse in C ++. Benjamin/Cummings Publishing Company, Inc. p. 29. ISBN 0-8053-5443-3.
- ^ Tanenbaum, Andrew S. (1990). Strukturierte Computerorganisation, dritte Ausgabe. Prentice Hall. p.17. ISBN 978-0-13-854662-5.
- ^ a b c d e f Treir, Ralph M. (2003). Prinzipien der Informationssysteme, Sechste Ausgabe. Thomson. p. 160. ISBN 0-619-06489-7.
- ^ a b c Tanenbaum, Andrew S. (1990). Strukturierte Computerorganisation, dritte Ausgabe. Prentice Hall. p.399. ISBN 978-0-13-854662-5.
- ^ Tanenbaum, Andrew S. (1990). Strukturierte Computerorganisation, dritte Ausgabe. Prentice Hall. p.400. ISBN 978-0-13-854662-5.
- ^ Tanenbaum, Andrew S. (1990). Strukturierte Computerorganisation, dritte Ausgabe. Prentice Hall. p.398. ISBN 978-0-13-854662-5.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 26. ISBN 0-201-71012-9.
- ^ a b c d Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 37. ISBN 0-201-71012-9.
- ^ Treir, Ralph M. (2003). Prinzipien der Informationssysteme, Sechste Ausgabe. Thomson. p. 160. ISBN 0-619-06489-7.
Mit der dritten Generation und der Programmiersprachen auf höherer Ebene übersetzt jede Aussage in der Sprache in mehreren Anweisungen in Maschinensprache.
- ^ Wilson, Leslie B. (1993). Vergleichende Programmiersprachen, zweite Ausgabe. Addison-Wesley. p. 75. ISBN 978-0-201-56885-1.
- ^ Stroustrup, Bjarne (2013). Die C ++ - Programmiersprache, vierte Ausgabe. Addison-Wesley. p. 40. ISBN 978-0-321-56384-2.
- ^ a b Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 16. ISBN 0-201-71012-9.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 24. ISBN 0-201-71012-9.
- ^ a b Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 25. ISBN 0-201-71012-9.
- ^ a b c d Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 19. ISBN 0-201-71012-9.
- ^ a b c d "Speicherlayout von C -Programmen". 12. September 2011.
- ^ a b Kernighan, Brian W.; Ritchie, Dennis M. (1988). Die C -Programmiersprache zweite Ausgabe. Prentice Hall. p. 31. ISBN 0-13-110362-8.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 128. ISBN 0-201-71012-9.
- ^ a b c Kerrisk, Michael (2010). Die Linux -Programmierschnittstelle. Keine Stärkepresse. p. 121. ISBN 978-1-59327-220-3.
- ^ Kerrisk, Michael (2010). Die Linux -Programmierschnittstelle. Keine Stärkepresse. p. 122. ISBN 978-1-59327-220-3.
- ^ Kernighan, Brian W.; Ritchie, Dennis M. (1988). Die C -Programmiersprache zweite Ausgabe. Prentice Hall. p. 185. ISBN 0-13-110362-8.
- ^ a b Kernighan, Brian W.; Ritchie, Dennis M. (1988). Die C -Programmiersprache zweite Ausgabe. Prentice Hall. p. 187. ISBN 0-13-110362-8.
- ^ a b c Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 38. ISBN 0-201-71012-9.
- ^ Stroustrup, Bjarne (2013). Die C ++ - Programmiersprache, vierte Ausgabe. Addison-Wesley. p. 65. ISBN 978-0-321-56384-2.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 193. ISBN 0-201-71012-9.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 39. ISBN 0-201-71012-9.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 35. ISBN 0-201-71012-9.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 192. ISBN 0-201-71012-9.
- ^ Stroustrup, Bjarne (2013). Die C ++ - Programmiersprache, vierte Ausgabe. Addison-Wesley. p. 22. ISBN 978-0-321-56384-2.
- ^ Stroustrup, Bjarne (2013). Die C ++ - Programmiersprache, vierte Ausgabe. Addison-Wesley. p. 21. ISBN 978-0-321-56384-2.
- ^ Stroustrup, Bjarne (2013). Die C ++ - Programmiersprache, vierte Ausgabe. Addison-Wesley. p. 49. ISBN 978-0-321-56384-2.
- ^ a b Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 218. ISBN 0-201-71012-9.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 217. ISBN 0-201-71012-9.
- ^ Weiss, Mark Allen (1994). Datenstrukturen und Algorithmusanalyse in C ++. Benjamin/Cummings Publishing Company, Inc. p. 103. ISBN 0-8053-5443-3.
Wenn es einen Funktionsaufruf gibt, müssen alle wichtigen Informationen gespeichert werden, z. Um zurückzukehren, stellt es ... alle Register wieder her. Es macht dann den Rückkehr. Offensichtlich kann all diese Arbeiten mit einem Stapel erledigt werden, und genau das passiert in praktisch jeder Programmiersprache, die eine Rekursion implementiert.
- ^ a b c Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 230. ISBN 0-201-71012-9.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 240. ISBN 0-201-71012-9.
- ^ a b c Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 241. ISBN 0-201-71012-9.
- ^ Jones, Robin; Maynard, Clive; Stewart, Ian (6. Dezember 2012). Die Kunst der Lisp -Programmierung. Springer Science & Business Media. p. 2. ISBN 9781447117193.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 220. ISBN 0-201-71012-9.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 221. ISBN 0-201-71012-9.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 229. ISBN 0-201-71012-9.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 227. ISBN 0-201-71012-9.
- ^ a b Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 222. ISBN 0-201-71012-9.
- ^ Gordon, Michael J. C. (1996). "Von LCF bis Hol: eine kurze Geschichte". Abgerufen 2021-10-30.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 233. ISBN 0-201-71012-9.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 235. ISBN 0-201-71012-9.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 55. ISBN 0-201-71012-9.
- ^ a b "Geburt von Prolog" (PDF). November 1992.
- ^ a b Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 246. ISBN 0-201-71012-9.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 245. ISBN 0-201-71012-9.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 247. ISBN 0-201-71012-9.
- ^ a b Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 35. ISBN 0-201-71012-9.
Simula basierte auf Algol 60 mit einer sehr wichtigen Ergänzung - dem Klassenkonzept. ... Die Grundidee war, dass die Daten (oder Datenstruktur) und die darauf ausgeführten Vorgänge zusammen gehören [.]
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 39. ISBN 0-201-71012-9.
Ursprünglich wurde eine große Anzahl von experimentellen Sprachen entworfen, von denen viele kombinierte objektorientierte und funktionelle Programmierung.
- ^ Schach, Stephen R. (1990). Softwareentwicklung. Aksen Associates Incorporated Publishers. p. 284. ISBN 0-256-08515-3.
Während es wahr ist, dass OOD [(objektorientiertes Design)] als solche nicht von der Mehrheit der beliebten Sprachen unterstützt wird, kann eine große Untergruppe von OOD verwendet werden.
- ^ Weiss, Mark Allen (1994). Datenstrukturen und Algorithmusanalyse in C ++. Benjamin/Cummings Publishing Company, Inc. p. 57. ISBN 0-8053-5443-3.
- ^ Schach, Stephen R. (1990). Softwareentwicklung. Aksen Associates Incorporated Publishers. p. 285. ISBN 0-256-08515-3.
- ^ a b c Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 290. ISBN 0-201-71012-9.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 78. ISBN 0-201-71012-9.
Die Hauptkomponenten einer imperativen Sprache sind Erklärungen, Ausdrücke und Aussagen.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 294. ISBN 0-201-71012-9.
- ^ Rosen, Kenneth H. (1991). Diskrete Mathematik und ihre Anwendungen. McGraw-Hill, Inc. p.615. ISBN 978-0-07-053744-6.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 291. ISBN 0-201-71012-9.
- ^ Rosen, Kenneth H. (1991). Diskrete Mathematik und ihre Anwendungen. McGraw-Hill, Inc. p.616. ISBN 978-0-07-053744-6.
- ^ Rosen, Kenneth H. (1991). Diskrete Mathematik und ihre Anwendungen. McGraw-Hill, Inc. p.623. ISBN 978-0-07-053744-6.
- ^ Rosen, Kenneth H. (1991). Diskrete Mathematik und ihre Anwendungen. McGraw-Hill, Inc. p.624. ISBN 978-0-07-053744-6.
- ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 297. ISBN 0-201-71012-9.
- ^ Schach, Stephen R. (1990). Softwareentwicklung. Aksen Associates Incorporated Publishers. p. Vorwort. ISBN 0-256-08515-3.
- ^ a b c Treir, Ralph M. (2003). Prinzipien der Informationssysteme, Sechste Ausgabe. Thomson. p. 507. ISBN 0-619-06489-7.
- ^ a b Treir, Ralph M. (2003). Prinzipien der Informationssysteme, Sechste Ausgabe. Thomson. p. 513. ISBN 0-619-06489-7.
- ^ Treir, Ralph M. (2003). Prinzipien der Informationssysteme, Sechste Ausgabe. Thomson. p. 514. ISBN 0-619-06489-7.
- ^ Treir, Ralph M. (2003). Prinzipien der Informationssysteme, Sechste Ausgabe. Thomson. p. 516. ISBN 0-619-06489-7.
- ^ Schach, Stephen R. (1990). Softwareentwicklung. Aksen Associates Incorporated Publishers. p. 8. ISBN 0-256-08515-3.
- ^ Treir, Ralph M. (2003). Prinzipien der Informationssysteme, Sechste Ausgabe. Thomson. p. 517. ISBN 0-619-06489-7.
- ^ Schach, Stephen R. (1990). Softwareentwicklung. Aksen Associates Incorporated Publishers. p. 345. ISBN 0-256-08515-3.
- ^ a b c d Schach, Stephen R. (1990). Softwareentwicklung. Aksen Associates Incorporated Publishers. p. 319. ISBN 0-256-08515-3.
- ^ a b Schach, Stephen R. (1990). Softwareentwicklung. Aksen Associates Incorporated Publishers. p. 331. ISBN 0-256-08515-3.
- ^ Schach, Stephen R. (1990). Softwareentwicklung. Aksen Associates Incorporated Publishers. p. 216. ISBN 0-256-08515-3.
- ^ a b c Schach, Stephen R. (1990). Softwareentwicklung. Aksen Associates Incorporated Publishers. p. 219. ISBN 0-256-08515-3.
- ^ a b Schach, Stephen R. (1990). Softwareentwicklung. Aksen Associates Incorporated Publishers. p. 226. ISBN 0-256-08515-3.
- ^ a b Schach, Stephen R. (1990). Softwareentwicklung. Aksen Associates Incorporated Publishers. p. 220. ISBN 0-256-08515-3.
- ^ Schach, Stephen R. (1990). Softwareentwicklung. Aksen Associates Incorporated Publishers. p. 258. ISBN 0-256-08515-3.
- ^ Schach, Stephen R. (1990). Softwareentwicklung. Aksen Associates Incorporated Publishers. p. 259. ISBN 0-256-08515-3.
- ^ a b c Silberschatz, Abraham (1994). Betriebssystemkonzepte, vierte Ausgabe. Addison-Wesley. p. 1. ISBN 978-0-201-50480-4.
- ^ a b c Treir, Ralph M. (2003). Prinzipien der Informationssysteme, Sechste Ausgabe. Thomson. p. 147. ISBN 0-619-06489-7.
Der Schlüssel zur Erschließung des Potenzials eines Computersystems ist die Anwendungssoftware.
- ^ a b c d e Treir, Ralph M. (2003). Prinzipien der Informationssysteme, Sechste Ausgabe. Thomson. p. 148. ISBN 0-619-06489-7.
- ^ a b c d Treir, Ralph M. (2003). Prinzipien der Informationssysteme, Sechste Ausgabe. Thomson. p. 149. ISBN 0-619-06489-7.
- ^ Tanenbaum, Andrew S. (1990). Strukturierte Computerorganisation, dritte Ausgabe. Prentice Hall. p.11. ISBN 978-0-13-854662-5.
- ^ a b Kerrisk, Michael (2010). Die Linux -Programmierschnittstelle. Keine Stärkepresse. p. 21. ISBN 978-1-59327-220-3.
- ^ a b c d e Kerrisk, Michael (2010). Die Linux -Programmierschnittstelle. Keine Stärkepresse. p. 22. ISBN 978-1-59327-220-3.
- ^ a b c Bach, Maurice J. (1986). Das Design des UNIX -Betriebssystems. Prentice-Hall, Inc. p. 152. ISBN 0-13-201799-7.
- ^ Tanenbaum, Andrew S. (2013). Strukturierte Computerorganisation, sechste Ausgabe. Pearson. p. 443. ISBN 978-0-13-291652-3.
- ^ Lacamera, Daniele (2018). Embedded Systems Architecture. Packt. p. 8. ISBN 978-1-78883-250-2.
- ^ Kerrisk, Michael (2010). Die Linux -Programmierschnittstelle. Keine Stärkepresse. p. 23. ISBN 978-1-59327-220-3.
- ^ Kernighan, Brian W. (1984). Die UNIX -Programmierumgebung. Prentice Hall. p. 201. ISBN 0-13-937699-2.
- ^ Kerrisk, Michael (2010). Die Linux -Programmierschnittstelle. Keine Stärkepresse. p. 187. ISBN 978-1-59327-220-3.
- ^ Haviland, Keith (1987). UNIX -Systemprogrammierung. Addison-Wesley Publishing Company. p. 121. ISBN 0-201-12919-1.
- ^ a b c Treir, Ralph M. (2003). Prinzipien der Informationssysteme, Sechste Ausgabe. Thomson. p. 145. ISBN 0-619-06489-7.
- ^ a b c Treir, Ralph M. (2003). Prinzipien der Informationssysteme, Sechste Ausgabe. Thomson. p. 146. ISBN 0-619-06489-7.
- ^ a b Tanenbaum, Andrew S. (2013). Strukturierte Computerorganisation, sechste Ausgabe. Pearson. p. 6. ISBN 978-0-13-291652-3.
- ^ Tanenbaum, Andrew S. (2013). Strukturierte Computerorganisation, sechste Ausgabe. Pearson. p. 243. ISBN 978-0-13-291652-3.
- ^ Tanenbaum, Andrew S. (2013). Strukturierte Computerorganisation, sechste Ausgabe. Pearson. p. 147. ISBN 978-0-13-291652-3.
- ^ Tanenbaum, Andrew S. (2013). Strukturierte Computerorganisation, sechste Ausgabe. Pearson. p. 148. ISBN 978-0-13-291652-3.
- ^ Tanenbaum, Andrew S. (2013). Strukturierte Computerorganisation, sechste Ausgabe. Pearson. p. 253. ISBN 978-0-13-291652-3.
- ^ Tanenbaum, Andrew S. (2013). Strukturierte Computerorganisation, sechste Ausgabe. Pearson. p. 255. ISBN 978-0-13-291652-3.
- ^ Tanenbaum, Andrew S. (2013). Strukturierte Computerorganisation, sechste Ausgabe. Pearson. p. 161. ISBN 978-0-13-291652-3.
- ^ Tanenbaum, Andrew S. (2013). Strukturierte Computerorganisation, sechste Ausgabe. Pearson. p. 166. ISBN 978-0-13-291652-3.
- ^ Tanenbaum, Andrew S. (2013). Strukturierte Computerorganisation, sechste Ausgabe. Pearson. p. 249. ISBN 978-0-13-291652-3.
- ^ Tanenbaum, Andrew S. (2013). Strukturierte Computerorganisation, sechste Ausgabe. Pearson. p. 111. ISBN 978-0-13-291652-3.