Um Eigenschaften und Unterscheidungsmerkmale von
Programmiersprachen geht es in der einhundertzweiundachzigsten
Episode des IT-Berufe-Podcasts. TL;DR Ich gebe dir Kriterien an die
Hand, mit denen du die Programmiersprachen deines Abschlussprojekts
im Fachgespräch beschreiben und für eine Aufgabe auswählen kannst.
Dazu gehören das Programmierparadigma, die Art, wie Code ausgeführt
wird, und weitere Merkmale wie Syntax oder Speicherverwaltung. Bei
der Typisierung unterscheidest du zwei unabhängige Dimensionen:
statisch oder dynamisch sowie stark oder schwach. Auch die
Plattform und das Ökosystem gehören zum Wissen, das du beim
Entwickeln brauchst. Kapitelmarken [00:00:00] Einstieg und
Bedeutung für das Fachgespräch [00:02:56] Was ist eine
Programmiersprache? [00:04:38] Grundbausteine von Algorithmen
[00:06:37] Turing-Vollständigkeit und andere Spracharten [00:09:38]
Sprache, Plattform und Ökosystem [00:12:44] Klassenbibliotheken und
Laufzeitplattformen [00:15:12] Buildtools, Abhängigkeiten und
Frameworks [00:17:47] Einsatzzweck von Programmiersprachen
[00:19:24] Frontend und Backend [00:20:06] Skriptsprachen und
Websprachen [00:23:29] Programmierparadigmen und First Class
Citizens [00:25:15] Idiomatischer Code und Multiparadigmen-Sprachen
[00:28:29] Imperative und deklarative Programmierweise [00:34:52]
Unstrukturierte Programmierung mit goto [00:37:11] Strukturierte
Programmierung [00:37:44] Prozeduren und Funktionen [00:39:00]
Objektorientierung und Kapselung [00:41:20] Funktionale
Programmierung [00:43:47] Logische Programmierung mit Prolog
[00:47:00] Compiler und Interpreter [00:48:50] Bytecode und
Just-in-Time-Compiler [00:50:35] Typisierung als Prüfungsthema
[00:51:46] Die unabhängigen Dimensionen der Typisierung [00:52:58]
Statische und dynamische Typisierung [00:55:03] Typinferenz
[00:57:47] Starke und schwache Typisierung [01:00:00] Implizite
Typumwandlungen und Fehlerquellen [01:05:07] Beispiele für die vier
Typisierungskombinationen [01:06:49] Typfehler und Tests [01:08:09]
C-ähnliche Syntax und andere Schreibweisen [01:09:41] Grafische
Programmiersprachen [01:10:30] Sprachhöhe und Generationen von
Programmiersprachen [01:13:29] 4GL-Sprachen mit SQL, Natural und
ABAP [01:16:51] General Purpose und Domain-Specific Languages
[01:18:49] Interne und externe DSLs [01:19:46] Portabilität und
virtuelle Maschinen [01:21:07] Managed und unmanaged Speicher
[01:22:24] Garbage Collection und Echtzeitsysteme [01:25:52]
Performance und Speicherverbrauch [01:28:15] Beispiele für
Websprachen und TypeScript [01:30:15] Sprachen für Anwendungen in
Unternehmen [01:32:19] Appentwicklung und Hardware-nahe Sprachen
[01:33:30] Funktionale Sprachen und Elixir [01:35:02] Prolog und
andere Denkweisen beim Programmieren [01:35:59] Buchempfehlung
Seven Languages in Seven Weeks [01:37:06] Kriterien für eine
Antwort im Fachgespräch [01:39:20] Java anhand der Kriterien
beschreiben [01:40:47] Fragen, Shownotes und Newsletter Inhalt Was
ist eine Programmiersprache? Programmiersprache: "Eine
Programmiersprache ist eine formale Sprache zur Formulierung von
Datenstrukturen und Algorithmen, d.h. von Rechenvorschriften, die
von einem Computer ausgeführt werden können." [Herv. d. Verf.]
Bausteine von Algorithmen: Sequenz, Verzweigung (z.B. if, switch,
aber auch Pattern Matching), Wiederholung (GOTO, Schleifen,
Rekursion) Turing-complete: "[...] die Eigenschaft einer
Programmiersprache oder eines anderen logischen Systems, sämtliche
Funktionen berechnen zu können, die eine universelle Turingmaschine
berechnen kann." Demnach sind keine Programmiersprachen: HTML/XML
(Auszeichnungssprache), CSS (Stylesheet-Sprache), SQL
(Datenbankabfragesprache). Sprache vs. Plattform vs. Ökosystem
Programmiersprachen bringen meistens "eingebaute" ("native")
Funktionen mit, die direkt in der Syntax der Sprache formuliert
werden können: Ein-/Ausgabe-Befehle, um Daten verarbeiten zu können
Deklaration von Variablen zum Speichern von Informationen
mathematische Funktionen wie Addition, Multiplikation usw.
Steueranweisungen für Verzweigung und Wiederholung Möglichkeiten
zur Programmunterteilung (z.B. Funktionen, Subprogramme) Einbinden
von (externen) Bibliotheken zur Wiederverwendung Viele
Programmiersprachen bringen außerdem noch eine umfangreiche
Bibliothek an vorgefertigten Implementierungen (z.B. in Form von
Klassen in objektorientierten Sprachen) mit. Diese Bibliothek ist
bei der Einarbeitung in eine neue Sprache meist
schwieriger/langwieriger zu lernen als die Syntax. Oftmals teilen
sich mehrere Programmiersprachen die Bibliotheken einer gemeinsamen
Plattform, z.B. der JVM bei Java und Kotlin bzw. .NET bei C# und
Visual Basic. Darüber hinaus existiert meist auch noch ein ganzes
Ökosystem rund um die Sprache/Plattform: Build-Tools, z.B. Maven,
Gradle Dependency-Management, z.B. NPM, RubyGems Test-Frameworks,
z.B. JUnit weitere Frameworks und Libraries, z.B. Spring, Jakarta
EE, Rails, Blazor Klassifizierung/Einsatzzweck(e) Im Alltag sind
die Identifikation und Auswahl einer für das jeweilige
"Realweltproblem" passenden Sprache wichtig. Viele
Programmiersprachen haben Schwerpunkte bei ihrem Einsatz, weil sie
für bestimmte Einsatzzwecke optimiert wurden oder dafür viele
vorgefertigte Lösungen mitbringen. Einsatzzweck: Webanwendung (z.B.
PHP), App (z.B. Swift), Desktop-Anwendung (z.B. C#),
Server-Anwendung (z.B. Java) Frontend (browserseitig) vs. Backend
Scriptsprachen: geringer Programmieraufwand für schnell sichtbare
Ergebnisse, oft Interpretersprachen mit dynamischer Typisierung und
laxer Syntaxprüfung (z.B. Semikolons optional), Beispiele:
PowerShell, PHP Web-Programmiersprachen: bringen meist umfangreiche
Bibliotheken und Frameworks für Webanwendungen mit, oftmals auch
Scriptsprachen, Beispiele: PHP, Ruby, Python Programmierparadigma
Ein Programmierparadigma gibt die grundsätzliche Art und Weise vor,
wie mit einer Programmiersprache entwickelt wird. Es definiert
grundlegende Herangehensweisen und Prinzipien bei der
Softwareentwicklung, aber auch ganz konkrete syntaktische Vorgaben.
So legt es z.B. fest, mit welchen Konstrukten das Programm
hauptsächlich arbeitet (z.B. Objekte in der Objektorientierung bzw.
Funktionen in der funktionalen Programmierung als sogenannte "First
Class Citizens"), wie Programme modularisiert werden sollten und
auf welche Art und Weise Algorithmen vorzugsweise formuliert werden
sollten ("idiomatische Programmierung"). Viele Programmiersprachen
sind heutzutage sogenannte Multiparadigmensprachen, bieten also
Konzepte aus mehreren Paradigmen an, z.B. Objektorientierung und
funktionale Programmierung. Meist haben sie aber ein definierendes
Paradigma, z.B. Objektorientierung bei Java. Imperativ vs.
Deklarativ Grundsätzlich kann man die imperative und deklarative
Programmierung unterscheiden. Während bei der imperativen
Programmierung (von lat. "imperare" - befehlen) exakt vorgegeben
wird, in welcher Reihenfolge der Computer welche Befehle wie
ausführen muss, gibt man bei der deklarativen Programmierung (von
lat. "declarare" - erklären) lediglich vor, welches Ergebnis am
Ende erreicht sein soll, und lässt den Computer den Weg dorthin
selbst finden. Beispiel: // imperativ for (int i = 0; i <
list.getSize(); i++) { System.out.println(list.get(i)); } //
deklarativ list.forEach(System.out::println); Konkrete
Programmierparadigmen unstrukturiert: Einsatz von GOTO führte dazu,
dass konkrete Programmabläufe nicht mehr nachvollzogen werden
konnten strukturiert: Verzicht auf GOTO und Einsatz von
Kontrollstrukturen wie if und while prozedural: Programme werden in
kleine, wiederverwendbare Einheiten ("Prozeduren") aufgespalten
funktional: (mathematische) Funktionen bilden den Kern dieser
Vorgehensweise, Higher Order Functions, Immutability und Rekursion
als wichtige Merkmale objektorientiert: Objekte kapseln
Eigenschaften und Funktionen zu einer Einheit, Vererbung und
Polymorphie als wichtige Merkmale logisch: Programmierung auf Basis
der mathematischen Aussagenlogik Compiler vs. Interpreter Compiler:
Übersetzt Quellcode in Maschinen- oder Bytecode, bevor das Programm
ausgeführt wird. JIT-Compiler: Just-In-Time-Compiler übersetzen
z.B. Teile des Bytecodes zur Laufzeit in Maschinencode, um die
Performance zu erhöhen. Interpreter: Interpretiert den Quellcode
Zeile für Zeile und übersetzt ihn während der Ausführung in
Maschinencode. Typisierung statisch vs. dynamisch statisch:
Datentypen stehen schon zur Compile-Zeit fest. dynamisch:
Datentypen werden erst zur Laufzeit geprüft. stark vs. schwach:
eher ein Spektrum ("stärker/schwächer typisiert") als eine harte
Einteilung stark: keine Typumwandlung möglich oder nur explizit
("Cast", (int)3.5) schwach: implizite Typumwandlungen durch die
Sprache, z.B. if (1) { ... } Beispiele für alle Kombinationen
statisch/stark: Java > cat .\Main.java class Main { public
static void main(String[] args) { double d = 1.5; int i = d; } }
> javac .\Main.java .\Main.java:6: error: incompatible types:
possible lossy conversion from double to int int i = d; ^ 1 error
statisch/schwach: C > cat test.c #include int main() { int i =
1; if (i) { printf("Hallo\n"); } return 0; } > gcc test.c -o
test > ./test Hallo dynamisch/stark: Ruby > cat .\test.rb i =
1 s = "a" puts i + s > ruby .\test.rb ./test.rb:3:in `+': String
can't be coerced into Integer (TypeError) from ./test.rb:3:in `'
dynamisch/schwach: PHP > cat test.php $i = "asdf"; if ($i) {
echo "Hallo\n"; } > php test.php Hallo Syntax Syntaktisch gibt
es eigentlich nur die Unterscheidung zwischen Sprachen, die ähnlich
zu C sind (insb. Klammern, Schlüsselwörter, Datentypen) oder eben
nicht. Beispiel Java (C-ähnlich): void pruefePerson(int alter) { if
(alter >= 18) { System.out.println("volljährig"); } } Beispiel
Ruby: def pruefePerson(alter) puts "volljährig" if alter >= 18
end ...
Kommentare (0)
Melde dich an, um einen Kommentar zu schreiben.