Glossar

• A
• B
• C
• D
• E
• F
• G
• H
• I
• J
• K
• L
• M
• N
• O
• P
• Q
• R
• S
• T
• U
• V
• W
• X
• Y
• Z

A

• Abstrakte Fabrik (E: abstract factory): Klassisches Entwurfsmuster. Link.

• Abstrakte Klase (E: abstract class): Klasse, die keine Objekte instanziieren kann. Die Klasse dient also in erster Linie als Speicher von Methoden und Attributen, die dann entweder statisch sind oder über Vererbung in instanziierbaren Tochterklassen landen.

• Abstraktion (E: Abstraction): Ziel beim Programmieren. Zumindest auf dem obersten Level sollte sich Code eher lesen wie eine normale Sprache, zum Beispiel: if(user.isRegistered) placeOrder(). Natürlich müssen irgendwann (z.B. in isRegistered all die technischen Details kommen), aber auf der ersten Ebene ist dieser Code gut lesbar.

• Adapter (~): Klassisches Entwurfsmuster. Liegt im Prinzip dann vor, wenn eine Klasse zur Übersetzung zwischen zwei Interfaces gesetzt wird. Mehr Details hier.

• Aggregation (~): Man unterscheidet in der OOP zwischen Assoziation, Aggregation und Komposition bei den Beziehungen zwischen Objekten.

• Algorithmus (E: algorithm): Folge von einfachen Anweisungen, die zusammen ein komplexeres Problem lösen.

• Alpha Test (~): Testing in einem frühen Stadium der Softwareentwicklung. Bugs sind ständig zu erwarten.

• AND (D: UND): Boolesche / Logische Operation. Eine AND-Operation ergibt true, wenn beide Operanden true sind. Folglich: 1 AND 1 = 1. 1 AND 0 = 0, 0 AND 1 = 0, 0 AND 0 = 0.

• Android (~): Betriebssystem von Google, insbesondere für Mobilgeräte.

• Assembler (~): Programm, dass in Assembly-Sprachen geschriebenen Code plattformspezifisch in Maschinensprache umwandelt.

• Assembly (~): Sehr maschinennahe Sprachen, jeweils plattformspezifisch, in denen direkt die Befehle, welche die CPU unterstützt, verwendet werden. Das hat mit den von uns genutzten Sprachen wenig zu tun. Es geht um das direkte Schreiben in Speicherzellen etc, zum Beispiel um einzeln die Pixel anzuknipsen, die dann zusammen einen Buchstaben auf dem Bildschirm ergeben. Alles, was Anwendungsentwickler tun, erreicht irgendwann dieses Level, aber dazwischen liegen etliche Ebenen an Compilern und Co.

• Assoziation (~): Man unterscheidet in der OOP zwischen Assoziation, Aggregation und Komposition bei den Beziehungen zwischen Objekten.

• Attribute (~): Eigenschaften / Variablen eines Objekts, definiert in einer Klasse.

B

• Beta-Test (~): Phase zwischen Alpha Test und Release beim Testing. Bugs können auftreten, sollten aber kein ständiger Begleiter mehr sein.

• Betriebssystem (~): Basis, auf der Anwendungen laufen. Verdrahtet im Wesentlichen die Hardware und stellt die Basis an Funktionalitäten bereit, damit man sich darum nicht kümmern muss. Beispiele: Windows, Android, macOs, iOs, Linux, ...

• Binärcode (binary code): Anderes Wort für Maschinensprache.

• Binärsystem (binary system): Zahlensystem, basierend auf der Zahl 2, so wie unser Dezimalsystem basiert auf der Zahl 10.

• Bit (~): Die kleinste Informationseinheit. Kennt nur die Zustände 1 (oder true oder an) und 0 (oder false oder aus). Siehe Binärsystem. Moderne Computer sind 64-Bit-Rechner, die also mit 64 Bits gleichzeitig arbeiten (zum Beispiel bei Rechenoperationen).

• Black Box Test (~): Form des Testing, bei dem bewusst nicht auf den Code der zu testenden Komponente geschaut wird. Anforderungen werden aus Anwendersicht formuliert und es wird geprüft, ob diese Anforderungen erfüllt werden.

• Black Hat Hacking (~): Prototyp des Hacking, bei dem die Motive finster (kriminell) sind und keine Erlabnis zum Hacking vorliegt.

• Boolean (D: Boolescher Wert): Variablentyp in den meisten Programmiersprachen. Entspricht einem Bit. Kann nur die Werte true oder false (1 oder 0) speichern.

• Boolean Operation (D: Boolesche Operation): Logische Operationen, die Boolesche Ausdrücke (true / false) miteinander verknüpfen. Die wichtigsten sind: AND, OR, EXOR, NOT. In der Programmierung finden logische Operationen vor allem in Bedingungen statt.

• Boolesche Variable (D: Boolean variable): Variable vom Typ Boolean.

• Bridge (D: Brücke): Entwurfsmuster, das zur Trennung von Abstraktion und Implementation dient. Ausführlicher hier.

• Bug (~): Fehler in einem Programm. Oft wird unterschieden zwischen Syntaxfehlern und Logikfehlern.

• Byte (~): 8 Bit. 256 potenzielle Werte von 00000000 (=0) bis 11111111 (=255). Siehe Binärsystem.

• Bytecode (~): In der Programmiersprache Java wird der in dieser Sprache geschriebene Code nicht direkt kompiliert in Maschinensprache, sondern in eine Art Zwischencode namens Bytecode. Dieser ist schon maschinennäher als der Rohcode, aber noch nicht maschinenspezifisch. In diesem Zustand kann er von der Java Runtime Engine, die es für jede Plattform gibt, dann ausgeführt werden. Ergebnis ist eine Leistungsfähigkeit, die deutlich größer ist als bei Interpretersprachen, aber zugleich langsamer als echte Compiler-Sprachen.

C

• C ( ~): Verbreitete, sehr Hardware-nahe, Feature-arme Programmiersprache. Basis moderner Programmiersprachen. Compiler-Sprache. Prozedural, funktional orientiert.

• C++ ( ~): Wie C, zusätzlich mit mehr Elementen der objektorientierten Programmierung. Inzwischen verbreiteter als C. Insbesondere im grafikintensiven, rechenintensiven und hardwarenahen Bereich der Standard wegen hoher Geschwindigkeit. Zum Beispiel bei Spielen (Beispiel Unreal-Engine).

• C# ( ~): Sehr verbreitete Programmiersprache. Sehr objektorientiert. Bedeutung heutzutage vor allem durch Microsoft (Visual Studio). Cross-platform mit Xamarin.

• Closed Test ( ~): Testing mit einer geschlossenen / begrenzten Nutzergruppe, insbesondere einer Gruppe möglicher zukünftiger Nutzer.

• Closed Test (D: Geschlossene Klasse): Testing mit einer geschlossenen / begrenzten Nutzergruppe, insbesondere einer Gruppe möglicher zukünftiger Nutzer.

• Code (~): Die Zeilen eines Computerprogramms. Alternativverwendung im Sinne eines "Zugriffs-Codes".

• Code Review (~): Überprüfen des Codes von Person A durch Person B, die in der Regel nicht mitarbeitete an dem spezifischen Task von A. Dieses Vieraugenprinzip soll die Fehlerhäufigkeit reduzieren.

• Cohesion (D: Kohäsion): In der objektorientierten Programmierung beschreibt die Kohäsion (ohne Wert, nur qualifizierte Aussage), wie gut ein Programmteil (i.d.R. eine Klasse) dem Single Responsibility Principle entspricht, also wie gut es eine Verantwortlichkeit abdeckt und sich auch nur auf diese eine Verantwortlichkeit beschränkt. Tut die Klasse zu viel oder wird eine Verwantwortlichkeit auf mehrere Klassen verteilt, handelt es sich um "low cohesion", ist sie konsistent und vollständig, dann handelt es sich um "high cohesion".

• Commit (~): Allgemein verwendeter, aus Git stammender Begriff, der das zwischenzeitliche Sichern des eigenen Codes meint. Es wird sozusagen unterschieden zwischen: Speichern der Datei, in der man arbeitet (quasi alle 10 Sekunden). Dem Committen, also Abgeben, einer Arbeit am Code (auch in Zwischenständen, in der Regel mit Push synonym verwendet). Die Abgabe als fertiges Arbeitsergebnis, was dann ggf. Code Review und Pull request beinhaltet.

• Compiler ( ~): Programm, dass den Code einer Hochsprache umwandelt in Maschinencode.

• Compiler-Sprache (E: compiler language): Kategorisierung von Programmiersprachen, im Gegensatz zu Interpreter-Sprache. In die Kategorie fallen alle die Sprachen, deren Code umgewandelt wird in maschinenausfahrbaren Code (also keine Interpretation zur Laufzeit).

• Compiling (D: Kompilierung): Prozess des Kompilieren durch einen Compiler.

• Constructor (D: Konstruktor): Diejenige Methode in einer Klasse, die ein Objekt initialisiert. Wann immer eine Klasse instanziiert wird, wird implizit der zugehörige Constructor aufgerufen. Durch Overloading oder Named Constructors können verschiedene Konstruktoren, je nach Programmiersprache, für spezielle Zwecke eingerichtet werden.

• Coprozessor (E: Co-processor): Zusätzlicher Mikroprozessor im Rechner, der den Hauptprozessor bei seiner Arbeit unterstützt. Koprozessoren können bspw. mathematische sowie Gleitkomma-Operationen, Grafikoperationen, Signalverarbeitung, I/O-Verarbeitung oder Kryptographie ausführen.

• Coupling (D: Kopplung): Grad der Abhängigkeit von Programmteilen (z.B. Klassen) zu anderen Programmteilen oder von dem eigenen Programmcode zu externen Bestandteilen (z.B. Bibliotheken). Kein genauer Wert, sondern eher eine qualifizierte Bezeichnung. Wenn Programmteile einfach herausgelöst und in anderen Zusammenhängen verwendet bzw. leicht durch neue Implementationen der Funktionalität abgelöst werden, dann handelt es sich um "low coupling". Wenn ein Programmteil viele andere Programmteile benutzt oder bspw. jede Veränderung einer Bibliothek zu einem zwingenden Anpassen des eigenen Codes führen, dann spricht man von "high coupling". Das Ziel ist immer "low coupling, high cohesion".

• CPU (D: ZPU): Central Processing Unit: Zentraler Rechenkern des Computers. Bestimmt maßgeblich, wie schnell alle Operationen ausgeführt werden (zusammen mit der Geschwindigkeit, mit der er per Datenbus mit Daten gefüttert wird).

• Cross platform (D: plattformübergreifend): (Angestrebte) Eigenschaft mehrerer Programmiersprachen und Tools, um plattformunabhägig programmieren zu können.

D

• Dart (~): Von Google entwickelte allgemeine Programmiersprache. Im Einsatz seit 2015. Ähnlichkeiten zu Java, JavaScript. Bekam massiven Schub durch Flutter. Weiterer Schub erwartet durch Fuchsia, das auf Dart basieren soll.

• DDR-RAM: Eigentlich DDR-SDRAM. Seit 1999 gebräuchlicher Standard für RAM-Module. Die Bezeichnung "Double Data Rate Synchronous Dynamic Random Access Memory" bezieht sich darauf, dass damals (1999) die neue Bauart von RAM-Modulen technisch eine Verdopplung der Geschwindigkeit ermöglichte. Seitdem wurden stetig neue DDR-Standards rausgebracht. Aktuell stehen wir bei DDR5. Und wie bei jeder technischen Entwicklung: Mehr ist besser.

• Debugger (~): Komponente einer Entwicklungsumgebung (z.B. IDE), die beim Suchen von Bugs behilflich ist, in der Regel dadurch, dass man den Code schrittweise nachvollziehen/ beobachten kann.

• Decompiler (~): Programm, mit dem aus einem kompilierten Programm in Maschinensprache versucht wird, den Sourcecode wieder abzuleiten. Das geht nicht verlustfrei, auch weil vieles im Code den Computer im Binärcode nicht interessiert, z.B. Klassen- und Variablenbezeichnungen, Kommentare.

• Deklarative Programmierung (E: declarative programming): Programmierparadigma. Statt der Abfolge von Schritten zur Lösung eines Problems geht es eher um die Beschreibung des Problems und der Ausgangsbedingungen und der Computer soll den Weg dann selbständig finden. In der Praxis nicht allzu relevant, eher im akademischen Bereich zuhause.

• Dependency Inversion (~): Technik, mit der die Modularität von Software erhöht wird. Üblicherweise basiert in einer Highl-Level-Klasse (Die zugrundeliegende Businesslogik des Programms) auf Funktionalität in Low-Level-Klassen (z.B. einer Klasse, die Details zur Umsatzsteuerberechnung enthält). Dieses führt zu einer nicht gewollten Abhängigkeit zwischen den beiden Klassen. Die Dependency Inversion dreht die Abhängigkeit um. Der High-Level-Code basiert nur noch auf einem Interface, das zum Beispiel das Vorhandensein einer Methode getUmsatzsteuer vorschreibt. Welche Low-Level-Klasse dann diese Methode implementiert, ist nicht wichtig und wird dem High-Level-Objekt zum Beispiel bei seiner Initialisierung übergeben.

• Dependency Inversion Principle (~): Teil der SOLID-Prinzipien. Das Prinzip verlangt, dass High-Level-Code nie Low-Level-Code importieren (und somit auf diesem basieren) sollte. Der High-Level-Code sollte lediglich auf einem Interface basieren. Abstraktionen sollten nie auf Details basieren. Details sollten immer auf Abstraktionen basieren. In der Praxis bedeutet das, dass man sehr viele Interfaces einsetzt.

• Dot (D: Punkt): Ähnlich wie Pixel, nur weniger eingeschränkt auf Computerbildschirme. Wird zum Beispiel auch bei Druckern benutzt (Auflösung 300 dpi - Dots per inch).

• DRY-Principle (D: DRY-Prinzip): Die Abkürzung DRY steht einfach für "Don't Repeat Yourself". Das heißt, dass man die gleichen Schritte, den gleichen Algorithmus möglichst nur einmal in einem Projekt schreiben sollte. Je nach Programmierparadigma kann das zu Auslagerung in Funktionen oder Klassen führen.

E

• Entwicklungsumgebung (E: Development engine): Sammlung von Werkzeugen / Programmen, die beim Programmieren nützlich sind, was vieles umfassen mag, aber wohl zumindest Texteditor, Compiler bzw. Interpreter, Debugger. Sind diese und andere Tools in einem Programm vereint, spricht man von einer integrierten Entwicklungsumgebung (IDE).

• Entwurfsmuster (E: Design pattern): Eine bestimmte Konstellation von Klassen und ihren Verknüpfungen, die jeweils entwickelt wurde, um ein bestimmtes, wiederkehrendes Problem bei der Softwareentwicklung effizient zu lösen.

• Enum (D: Enumeration): Datentyp in mehreren Programmsprachen. Enumeration bedeutet Aufzählung. Mit anderen Worten: Es gibt einen bestimmbare Anzahl von Werten. Diese sind aber nicht zwingend Zahlen. Beispiel: Ein Urlaubstag kann "Jahresurlaub", "Sonderurlaub" oder "Überstundenausgleich" sein. Man legt die möglichen Werte einmal im Code fest und kann dann mit diesen Begriffen arbeiten. Gegenüber einer Codierung in Zahlen macht es den Code für uns Menschen einfacher lesbar.

• Executable (D: Ausführbare Datei): Datei, die vom Computer direkt ausgeführt werden kann, in der Regel in Maschinensprache.

• EXOR: Boolesche / Logische Operation. Eine EXOR-Operation (manchamel auch XOR) ergibt true, wenn genau einer der Operanden true ist. Folglich: 1 XOR 1 = 0. 1 XOR 0 = 1, 0 XOR 1 = 1, 0 XOR 0 = 0.

F

• Factory-Methode (E:factory method): Methode in einer Klasse, der dazu führt, dass die produzierten Objekte nicht wie üblich Instanzen der Klasse sind, sondern zumeist Instanzen einer Tochterklasse. Da ein Objekt der Unterklasse immer auch automatisch ein Objekt der Oberklasse ist, ist das dem aufrufenden Code egal.

• Fix (~): Behebung eines Bugs.

• Flutter: Framework zur Architektur von Apps und insbesondere zur plattformunabhängigen Beschreibung von GUI-Elementen. Von Google entwickelt. Mit Flutter (und der damit automatischen Programmiersprache Dart) entwickelte Programme können kompiliert werden in Java / Kotlin (für Android), Objective-C / Swift (für iOS)

• Fuchsia (~): Unveröffentlichtes, geplantes eigenes PC-Betriebssystem von Google.

• Funktion (: Function): Routine in einem Programm. Kann ein Ergebnis zurückgeben an die aufrufende Stelle oder auch nicht. Dient sowohl der Abstraktion als auch der Vermeidung von Wiederholungen.

• Funktionale Programmierung (E: Functional programming): Programmierparadigma, teiweise in Opposition zur Objektorientierten Programmierung. Wesentliche Ziele: Vermeidung von State (also einem festgeschriebenen Zustand des Systems, der Daten), stattdessen lieber Berechnung von Ergebnissen. Vermeidung von Nebeneffekten (Side effects) durch nicht-ändernden State. Beispiel: Anstatt meinen Kontostand als einen Zustand anzusehen, wird er lieber immer wieder anhand aller Transaktionen neu berechnet. Nachteil: Rechenaufwand, teilweise auch Code-Komplexität. Vorteil: Parallele Prozesse haben niedrigeres Risiko, sich gegenseitig zu beeinflussen.

G

• Gibibyte (~): 1.024 Mibibyte = 1 Gibibyte = GiB. Unterschied Gigabyte-Gibibyte ergibt sich aus der Erklärung zu Kilobyte.

• Gigabyte (~): 1.000 Megabyte = 1 Gigabyte = 1 GB. Unterschied Gigabyte-Gibibyte ergibt sich aus der Erklärung zu Kilobyte.

• GIT (~): Software-Versionierungs- und Sicherungs-System. Legt eine lokales "Repository" an, in dem alle Zwischenstände gespeichert sind. Remote-Repositories sind ebenfalls möglich, also die Sicherung auf Servern. Erleichtert insbesondere die Zusammenarbeit an Software im Team durch Tools wie Rebasing.

• Google (~): Omnipräsenter Internetkonzern.

• Grafikkarte (Graphics card): Komponente eines PC zur Berechnung der Grafikausgabe, insbesondere von 3D-Grafiken. Hauptelemente sind ein Grafikprozessor (GPU) und eigenes, dezidiertes (nur für die Grafikkarte verwendetes) RAM.

• Grafikprozessor (Graphics processing unit):: Siehe GPU.

• GPU (~): Graphics Processing Unit. Grafikprozessor. Hauptelement einer Grafikkarte. Hochspezialisierte Prozessoren, optimiert für die Berechnung aufwändiger 3D-Grafik. Aufgrund der Spezialisierung oftmals erheblich schneller als CPUs.

• GUI (D: Grafische Benutzeroberfläche): Graphical User Interface, also die (grafisch dargestellte) Benutzeroberfläche.

H

• Hacking (~): Eindringen in Computersysteme, zumeist durch das Ausnutzen von Sicherheitslücken.

• Hochsprache (E: Higher programming language): Programmiersprachen mit einer gewissen Distanz (und somit höherer Lesbarkeit) zum Maschinencode. Hierunter fallen fast alle modernen Programmiersprachen außerhalb der Assembly-Sprachen. Bei C++ kann man drüber streiten.

I

• IDE: Integrated Development Environment: Um etliche Funktionen erweiteter Texteditor, der sich aufgrund dieser Erweiterungen besonders gut dazu eignet, Software zu entwickeln. Beispiel ist Visual Studio Code.

• Imperative Programmierung: Programmierparadigma. Grundgedanke: "Mach das, dann das, dann das". Klassischer Einstieg in die Programmierung. Jede Zeile dreht sich um die Frage "wie löse ich das Problem und was mache ich dann?". Wurde nach und nach erweitert in Richtung strukturierte Programmierung und prozedurale Programmierung. Wirkliche Unterschiede gibt es zur objektorientierten Programmierung und zur deklarativen Programmierung.

• Inch (D: Zoll: Amerikanische Längeneinheit. Ein Zoll ~ 2,54 Zentimeter.

• Integration Test(~): Systematisches Testing des Zusammenspiels von mehreren Komponenten, insbesondere Klassen.

• Interface (~): Ein Interface ist in der objektorientierten Programmierung eine Art Vertrag. Er enthält Definitionen der Methoden und Attribute, die Klassen haben sollen, ohne diese zu implementieren. Eine andere Klasse kann sich dann dazu verpflichten, dieses Interface zu implementieren und muss dann konkrete Implementierungen dieser vorgeschriebenen Methoden und Attribute haben. Auf diese Weise kann erreicht werden, dass man Code in einer Verwenderklasse schreibt. Dieser basiert darauf, dass man eine andere Klasse verwendet, von der man nur weiß, welchem Interface sie genügt. Welche konkrete Klasse den Code dann ausführt, entscheidet sich zur Laufzeit. Das Ganze dient der Verringerung des Coupling zwischen Klassen.

• Interface Seggregation Princile (~): Teil der SOLID-Prinzipien. Sagt aus, dass eine Klasse nicht gezwungen sein sollte, auf Methoden zu basieren, die es nicht nutzt. Klassen nutzen andere Klassen nicht direkt, sondern via einem Interface. Und statt ein großes Interface zu implementieren, dass unzählige Methoden enthält, sollten lieber kleine Interfaces implementiert werden, die nur die Methoden enthalten, die benötigt werden. Die Klasse, welche die Methoden dann implementiert, implementiert dann in der Regel nicht ein großes, sondern viele kleine Interfaces.

• Interpreter (~): Programm, das einen Code in einer Interpretersprache in Handlungen des Computers übersetzt. Das geschieht zur Laufzeit des Programmes und das sorgt für eine niedrigere Performance als bei den sog. Compiler-Sprachen.

• Interpretersprache (~ interpreter language): Sprache, die nicht kompiliert, sondern zur Laufzeit übersetzt wird vom Computer. Bekanntestes Beispiel: Javascript, ansonsten noch relevant Visual Basic zum Beispiel.

• iOS (~): Betriebssystem von Apple, insbesondere für Mobilgeräte. Letztlich eine etwas abgespeckte Variante von macOS.

J

• Java (~): Weit verbreitete objektorientierte Programmiersprache. Compiliert zu Bytecode, nutzt dann ein plattformspezifisches Runtime Environment, womit der Bytecode plattformunabhängig ist. Bekam massiven Schub durch Android, da Apps für Android in Java programmiert werden mussten. Verliert zurzeit Bedeutung durch Kotlin, JavaScript, Dart / Flutter.

• JavaScript (~): Weit verbreitete, freie Programmiersprache. Eigentlich objektiv schlechtere Sprache als viele andere, aber von Anfang an die Programmiersprache des WWW. Dadurch in jedem Browser, dadurch auf jedem Gerät. Bekam weitere Schübe durch ReactJS, Node.JS. Deutlich verbessert durch TypeScript.

K

• Kibibyte: 1.024 Byte = 1 Kibibyte = 1 KiB. Der Unterschied zu Kilobyte wird dort erklärt.

• Kilobyte: 1.000 Byte = 1 Kilobyte = 1 KB. Ursprünglich zählt man 1.024 Bytes als ein Kilobyte, weil 1024 "2 hoch 10" ist und Zweierpotenzen und das Binärsystem eine Grundlage der Informatik sind. Allerdings werden die Zahl dann schnell unübersichtlich und unintuitiv (1.024 1.024 1.024 ist schon eine Abweichung von 7% zu der überschlägigen Rechnung mit dem Faktor 1.000). Also entschloss man sich, es genauso zu handhaben wie bei anderen Angaben (Kilogramm, Kilometer, etc) und eben mit dem Faktor 1.000 zu rechnen. Neue Einheiten wie Kibibyte, Mibibyte, Gibiybyte wurden eingeführt. Die Abkürzungen KB, MB, GB, TB (etc) verweisen nun auf den Faktor 1.000. KiB, MiB, GiB, TiB verweisen auf den Faktor 1.024.

• Kind-Klasse (E: child class): Klasse, die ihr Verhalten und ihre Datenstruktur teilweise oder insgesamt von ihrer Mutterklasse erbt.

• Klasse (E: Class): Sammlung von Methoden und Attributen, die zusammen den Bauplan für ein Objekt ausmachen. Basierend auf dieser Klassendefntion können dann beiebig viele Objeke dieses Typs konstruiert werden.

• kompilieren (E. compile): Prozess des Umwandeln des Codes einer Hochsprache in Maschinensprache. Man nutzt einen Compiler zum Kompilieren.

• kompiliert (E: compiled): Zustand eines Programms nach dem Kompilieren.

• Komposition (E: Composition): Man unterscheidet in der OOP zwischen Assoziation, Aggregation und Komposition bei den Beziehungen zwischen Objekten.

• Kotlin (~): Moderne Programmiersprache, lose basierend auf Java. Inzwischen offizielle Programmiersprache für Android, hat Java diesbezüglich abgelöst.

L

• Laufzeit (Runtime): Zeit, während der das Programm läuft, also tatsächlich aktiv ist. Oft verwendet in Abgrenzung zur Zeit, während der kompiliert wird (Compile-Time). Dabei geht es dann z.B. darum, ob bestimmte Informationen erst zur Runtime oder schon zur Compiletime feststehen.

• Linter (~): Komponente einer IDE, die dafür sorgt, dass nicht nur Fehler angezeigt werden, sondern auch Hinweise zur optimierten Programmierung.

• Liskov substitution principle (~): Teil der SOLID-Prinzipien. Das Prinzip verlangt, dass ein Objekt einer Klasse M durch Objekte seiner Tochterklasse T ersetzt werden kann, ohne dass sich irgendetwas an der korrekten Funktionsweise des Programms ändert.

• Logikfehler (E: Logics bug): Bug, der durch einen falschen Algorithmus bzw. falsche Überlegungen beim Programmieren verursacht ist, also nicht durch Fehler in der Syntax. Folglich in der Regel keine Fehlermeldungen, sondern eher unerwartete Ergebnisse. Schwerer zu lokalisieren und zu fixen als Syntaxfehler

• Low-Code (D: ~): Zusammenfassende Bezeichnungen von Techniken / Plattformen, welche Entwicklern ermöglichen, Funktionalität in erster Linie über das Bedienen von grafischen Benutzeroberflächen (GUIs) zu erzeugen, statt über das direkte Interagieren mit Code. Manche Programme (z.B. MS Access) zählen hierzu, inzwischen gibt es aber auch viele weitere (und mächtigere Werkzeuge), die stellenweise auch recht viele Freiheiten gewähren. Im Endeffekt ist Low-Code aber immer beschränkter als normaler Code. Andererseits werden oftmals viele Routinearbeiten abgenommen und daher ist der Weg zu einem vermarktungsfähigen Produkt oftmals kürzer in Low-Code-Plattformen.

M

• MacOS (~): Betriebssystem von Apple für den Einsatz in deren Desktopsystemen.

• Maschinensprache (E: Machine language): Direkt ausführbarer, plattformspezifischer Code auf Computer. Deckungsgleich mit Binärcode.

• Megabit (~): 1.000.000 Bit. Typische Angabe im Bereich der Telekommunikation, denn die Zahl ist höher, als wenn man Megabyte angeben würde.

• Megabyte (~): 1.000 Kilobyte = 1 Megabyte = 1 MB. Unterschied Megabyte-Mibibyte ergibt sich aus der Erklärung zu Kilobyte.

• Mibibyte (~): 1.024 Kibibyte = 1 Mibibyte = 1 MiB. Unterschied Megabyte-Mibibyte ergibt sich aus der Erklärung zu Kilobyte.

• Methode (E: Method}: Funktion, die von/auf einem Objekt ausgeführt wird.

• Mutterklasse (E: parent class): Siehe Eltern-Klasse.

N

• Netzteil (E: Power adator): Komponente des Computers, das den aus Wechselstrom aus der Steckdose in den vom Computer benötigten Gleichstrom umwandelt.

• new (~): Keyword, mit dem in vielen Programmiersprachen ein Objekt aus einer Klassendefinition erstellt wird.

• Node.js (~): Plattform, mit der browserunabhängige Javascript-Programme geschrieben werden können. So konnte Javascript, was üblicherweise nur im Browser ausgeführt wurde, zum Beispiel auch für Server-Backends verwendet werden. Durch Limitationen von Sprachen wie PHP inspiriert, insbesondere was asynchrone Operationen angeht. Javascript ist auch dann noch eine Interpretersprache, aber das ist PHP auch.

• NOT (D: NICHT): Boolesche / Logische Operation. Eine NOT-Operation kehrt den Wert eines Booleschen Wert um. FOLGLICH NOT 1 = 0. NOT 0 = 1.

O

• Objective-C (~): Programmiersprache. Erweiterung von C, insbesondere hinsichtlich der objektorientierten Programmierung. Bedeutung insbesondere dadurch, dass es eine der beiden nativen Programmiersprachen für iOS ist.

• Objekt (E: Object): Instanz einer Klasse. Siehe Objektorientierte Programmierung.

• Objektorientierte Programmierung (Object oriented Programming / Design): In der Objektorientierten Programmierung wird ein Programm im Wesentlichen als die Interaktion von Objekten aufgefasst. Objekte rufen die Methoden anderer Objekte auf (was man auch oft als den Austausch von Botschaften / Messages) beschreibt und tun dann jeweils ihren Part ebenfalls und alles zusammen ergibt den Programmablauf. Objekte können realweltlichen Objekten entsprechen, sind aber mit zunehmendem Refactoring auch zunehmend artifiziell.

• OOP (~): Kurz für objektorientierte Programmierung.

• Open Closed Principle (~): Teil der SOLID-Prinzipien. Das Prinzip beschreibt, dass eine Klasse "open for extension, but closed for modification" sein sollte. Sprich: Wenn eine Klasse zur Benutzung freigegeben ist, dann sollte sich ihre Funktionalität in den bereitgestellten Methoden (eigentlich) nicht mehr ändern. Es können nur neue Funktionalitäten hinzugefügt werden. Bei dem Prinzip handelt es sich um ein Ideal, das sicherlich nicht immer erreicht wird - ein Prinzip eben.

• Open Test (~): Siehe Public Test.

• OR (D: ODER): Boolesche / Logische Operation. Eine OR-Operation ergibt true, wenn mindestens einer der Operanden true ist. Folglich: 1 OR 1 = 1. 1 OR 0 = 1, 0 OR 1 = 1, 0 OR 0 = 0.

P

• Pixel (D: Punkt): Einzelner Punkt, insbesondere auf Bildschirmen. Ein typischer HD-Screen besteht aus 1920 x 1080, also rund 2.000.000 Pixeln. Jeder Pixel wiederum besteht aus mindestens 3 Subpixeln in den Grundfarben Rot, Grün und Blau (RGB), welche wiederum unterschiedlich hell rot, grün und blau leuchten können, was dann in der Mischung alle Farben ergibt. Alle Subpixel leuchten in voller Stärke ergibt weiß. Alle Subpixel leuchten gar nicht ergibt schwarz.

• Pointer (D: Zeiger): Verweis auf einen Speicherbereich. Manche, besonders maschinennahe Sprachen, lassen die direkte Manipulation von Speicherbereichen zu. Allgemeiner gesprochen kann Pointer auch als synonym mit Referenz verwendet werden.

• Programmierparadimen: x

• Prozedur (E: Procedure): Im Wesentlichen deckungsgleich mit Funktion. Mitunter wird unterschieden

• Prozedurale Programmierung: Programmierparadigma: Aufspaltung von Aufgaben in kleinere Teilaufgaben. Schreiben von Funktionen, welche diese Teilaufgabe lösen. Zusammenführung der Ergebnisse. Im Kern das, was wohl der klassische Einstieg in Programmierung heutzutage ist.

• Public Test (D: Öffentlicher Test): Testing mit / durch eine prinzipiell nicht begrenzte Nutzergruppe, die in der Regel den zukünftigen Nutzern entspricht.

• Pull Request (~): Git-Begriff, aber in der Intention ähnich auch in anderen Versionsverwaltungen. Sozusagen ein Antrag, den eigenen Code in einen Branch zu übernehmen. Diverse Bedingungen können an Pull Requests gestellt werden, zum Beispiel positive Code-Reviews von anderen oder die Zustimmung des Codeowners, etc. Im Endeffekt ist es die Meldung "Ich bin fertig, hier ist mein Ergebnis, übernehmt es bitte".

Q

R

• RAM (~): Random Access Memory. Flüchtiger Hauptspeicher des Computers. Strom aus = RAM leer.

• React JS (~): Javascript-Framework, das sich insbesondere auf dynamische Webseiten spezialisiert. Sachen, die in Javascript prinzipiell sowieso gehen, werden hier optimiert.

• React Native (~): Javascript-Framework, welches das Entwickeln von Mobile Apps auf Javascript-Basis ermöglicht bzw. vereinfacht. Grundsätzlich wird eine Art Browser-App geschrieben, die auf dem Mobilgerät dann auch technisch in einem Browser läuft (das bekommt der User nicht mit). Allerdings werden auch die nativen Funktionalitäten der Plattformen (vom Lokk & Feel der GUI bis hin zum Zugriff auf Kamera, GPS, etc) so exponiert, dass man aus Javascript damit umgehen kann.

• Rebase (~): Git-Begriff, den es in anderen Versionsverwaltungen aber auch gibt. Im Prinzip bezieht er sich auf folgende Situation. Irgendwann zweigt ein Programmierer von der allgemeinen Codebase ab, um an einem neuen Feature zu arbeiten. Das dauert eine Weile. Nun will er seinen neuen/veränderten Code in die Codebase wieder einbringen. Wenn sich die Codebase aber in der Zeit weiterentwickelt hat, dann passen die Änderungen unter Umständen nicht mehr, weil sie sich auf einen Stand beziehen, der heute nicht mehr aktuell ist - und stellenweise Dateien verändert wurden, die sich inzwischen ebenfalls verändert haben. Ein Rebase heißt nun, dass der Programmierer zuerst seinen neuen Code an die neue Codebasis anpassen muss, bevor er ihn abgeben kann. Er zieht also den neuen Stand der Codebasis und arbeitet diesen bei sich ein, anstatt seinen Code in die Codebasis zu bringen. Erst wenn die Codebasis bei beiden gleich ist, dann kann er eine Pull-Request stellen.

• Refactoring (~): Umgestalten von vorhandenem Code, um ihn lesbarer, leichter pflegbar und leichter verständlich zu machen. "Improving the design of existing code" lautet der Untertitel des grundlegenden Werkes "Refactoring" von Martin Fowler. Das Buch enthält viele standardisierte Methoden wie "Extract Method" oder "Inline Function" (und oftmals auch deren direkte Umkehrungen, da es nicht um den einen Weg zum Ziel geht, sondern einfach um mögliche Techniken auf dem Weg zu besserem Code), die teilweise heutzutage auch in IDEs technisch unterstützt werden (assistiertes Refactoring).

• Referenz (E: Reference): Verweis auf eine Variable, nicht auf ihren Inhalt. Manche Sprachen unterscheiden zwischen zwei Arten davon, eine Variable als Argument an eine Funktion zu übergeben, nämlich der Übergabe als Wert (byVal zum Beispiel in Visual Basic) und als Referenz (byRef). Beispielsweise in PHP wird diesbezüglich per Prefix klar gemacht, wenn eine Übergabe per Referenz geschehen soll. Das hat zur Folge, dass die aufgerufene Funktion direkten Zugriff auf den Speicherbereich der Variable bekommt. Ändert sie also den Wert der Variable, dann ist dieser Wert auch für die aufrufende Funktion danach verändert. Bei einer Übergabe des Wertes hingegen, wird eigentlich eine Kopie der Variable übergeben. Ändert sich der Wert dieser Variable in der aufgerufenen Funktion, hat das keine Wirkung auf die aufrufende Funktion. Die aufrufende Funktion erhält von der aufgerufenen Funktion gegebenenfalls einen Rückgabewert, aber sonst keine Auswirkungen.

• Release (D: Erscheinungstermin): Veröffentlichungstag oder veröffentlichte Version einer Software. Am Release-Tag wird die Release-Fassung releast.

• rendern (E: render): Optische Darstellung von Bildern oder GUI-Elementen.

• RGB (~): Farbsystem, basierend auf den Grundfarben rot, grün und blau. Aus diesen Farben (in jeweils unterschiedlicher Helligkeit) können alle Farben gemischt werden. Findet Verwendung immer dort, wo Farbhelligkeiten addiert werden (Bildschirme). Wird nicht verwendet im Druck, denn dort bedeutet "mehr Farbe" "weniger weißes Papier" (dort ist das CMYK-Farbsystem Standard).

• Runtime (E: Laufzeit): Zeit, in der ein Programm ausgeführt wird. Meistens in Abgrenzung zur Compile-Zeit, in der ein Program kompiliert wird. Beispielsweise mag es Sachen geben, die im Code hart verdrahtet sind, oder eben erst zur Laufzeit sich ergeben. Beispiel: Wenn ein Objekt bestimmte Informationen von einem anderen Objekt bezieht und die Referenz zu diesem anderen Objekt in einer Klassenvariablen abgespeichert hat, dann kann sich die Referenz natürlich auch später noch ändern. Plötzlich kommen die Informationen von einem anderen Objekt. Beispiel: Plugin-Architekturen. Das Programm (zB VSCode) weiß nicht, ob der Nutzer bestimmte Plugins hat. Die erweiterte Funktionalität ergibt sich erst zur Laufzeit durch das Vorhandensein der Plugins.

• Rückgabewert (E: Return value): Funktionen haben zumeist ein Ergebnis ihrer Operation. Dieser Wert kann dann dort, wo die Funktion aufgerufen werden, weiter verwendet werden. Ein besonderer Rückgabewert ist void, was in den meisten Sprachen darauf hinweist, dass es keinen Rückgabewert gibt. Die Funktion läuft aus Sicht der aufrufenden Funktion ab, tut dabei irgendwas - wirkt aber sonst nicht zurück in die aufrufende Funktion.

S

• Single Responsibility Principle (~): Jede Klasse sollte nur eine einzige Aufgabe erfüllen bzw. Verantwortlichkeit im Rahmen eines Programms haben und diese Aufgabe auch an einem Ort bündeln (also die Aufgabe dann auch vollständig abbilden). Teil der SOLID Principles.

• SOLID Principles (~): Eine Liste von Prinzipien, nach denen gemäß Robert Martin (in "Design Principles and Design Patterns") eine Software-Entwicklung geregelt sein sollte. Die Prinzipien sind "Single Responsibility Principle", "Open/Closed Principle", "Liskov Substitution Principle", "Interface Segregation Principle" und "Dependency Inversion Principle". Das Akronym ist dann eben SOLID.

• Statische Methode / Variable (E: static method / variable): Methode bzw. Variable / Attribut einer Klasse, das nicht für eine Instanz der Klasse jeweils gilt, sondern für die gesamte Klasse, auch wenn gar kein Objekt kreiert wurde.

• Strukturierte Programmierung (E: Structural programming): Programmierparadigma. Eher historisch interessant. Anweisungen wie "if then" und "while do" lösten die Möglichkeit ab, zum Beispiel per "goto" einfach irgendwohin im Code zu springen. Code wurde so übersichtlicher.

• Swift: Programmiersprache. Open Source, aber vor allem entwickelt von Apple. Bedeutung insbesondere dadurch, dass es eine der beiden nativen Programmiersprachen für iOS ist.

• Syntax (~): Grammatik und Vokabular einer Programmiersprache, also alle Regeln, die man beachten muss, damit der Code prinzipiell vom Computer verstanden wird.

• Syntaxfehler (E: Syntax error): Bug, der im Wesentlichen daher kommt, dass der Programmierer sich vertippte oder andere Regeln der Programmiersprache nicht beachtete. Einfacher zu fixen als Logikfehler.

T

• Terrabyte (~): 1.000 Gigabyte. Unterschied Gigabyte-Gibibyte ergibt sich aus der Erklärung zu Kilobyte.

• Tibibyte (~): 1.024 Gibibyte. Unterschied Gigabyte-Gibibyte ergibt sich aus der Erklärung zu Kilobyte.

• testing (testen): Systematisches Testen einer Software und ihrer Komponenten, siehe Unit Test, Integration Test, Closed Test, Open / Public Test, Alpha Test, Beta Test, Black Box Test, White Box Test.

• Tochterklasse (E: child class): Klasse, die eine andere Klasse (ihre Mutter-Klasse) erweitert (extends). Sie erbt somit deren Methoden und Attribute.

• Typescript: Javascipt-Erweiterung, die im Wesentlichen die Freiheiten, die man in Javascript hat, wie zum Beispiel die Variablen ohne Typfestlegung beschneidet. Man programmiert in Typescript dann recht ähnlich zu den meisten objektorientierten Compilersprachen. Daraus wird dann Javascript kompiliert. Das Besondere an Typescript ist, dass jede gültige JS-Zeile auch eine gültige TS-Zeile ist. Es git Warnungen, wenn man z.B. Variablen nicht richtig deklariert vor der Verwendung, aber wenn man die Warnungen ignoriert, dann kann man alles zu Javascript kompilieren. Das ist vorteilhaft, wenn man ein existierendes Javascript-Projekt in TS überführen will. Man kann erstmal alles übernehmen und dann nach und nach durch valides Typescript ersetzen.

U

• Unit Test (~): Systematisches Testing einer einzelnen Klasse, Methode oder Funktion.

• Unity Engine: Spiele-Engine, also spezialisierte Software, mit der man vergleichsweise(!) einfach Spiele entwickeln kann. Konkurrent zu Unreal Engine, tendenziell etwas günstiger, insbesondere für Independent-Entwickler.

• Unreal Engine: Spiele-Engine, also spezialisierte Software, mit der man vergleichsweise(!) einfach Spiele entwickeln kann. Konkurrent zu Unity Engine, tendenziell etwas teurer, featurereicher und modernder. Wird von den meisten professionellen Entwicklern bevorzugt.

V

• Visual Studio (~): IDE von Microsoft, vor allem spezialisiert auf C#.

• Visual Studio Code (~): "Kleiner" Bruder von Visual Studio. Weniger Umfang, weniger spezialisiert. Erweiterbar durch Plugins.

W

• White Box Test (~): Form des Testing, bei dem bewusst anhand / entlang bzw. Unter Kenntnis des Codes getestet wird. Extremform: Testing mit einem Debugger.

• White Hat Hacking (~): Form des Hacking, bei dem die Motive weniger finster / kriminell sind als beim Black Hat Hacking. So können Firmen beispielsweise im Auftrag von anderen Firmen Schwachstellen in Systemen aufdecken.

X

• x64 (~): 64-Bit-Prozessor von Intel bzw. zu Intel kompatible 64-Bit-Prozessoren. Siehe x86.

• x86 (~): Bezeichnung des Befehlssets in CPUs, auf der basierend vor allem Intel und AMD ihre CPUs entwickeln. Bezeichnung hat historische Ursprünge. Die ersten Prozessoren dieser Bauart hießen 80186, 80286. Irgendwann ließ man die ersten Zahlen halt weg. Später fielen die Bezeichnungen weg, der 80586 wurde einfach als "Pentium" vermarktet und dann kam der "Pentium II" und so weiter. Das Befehlsset aber blieb. Wenn ein Programm kompiliert wird, dann wird es umgesetzt in Befehle, die der Prozessor versteht. Daher ist ein Programm, das für x86-Prozessoren kompiliert wurde, eben nur auf x86-Prozesoren lauffähig. Als dann irgendwann 64-Bit-Prozessoren von Intel heraus kamen, bürgerte sich für diese in Anlehnung an x86 die Bezeichnung x64 ein (oder auch x86-64).

• Xamarin (~): Framework zur Erstellung von cross-platform Software. Basis ist C#, Visual Studio.

• XOR (~): Siehe EXOR.

Y

Z

• Zwischencode (intermediary code): Zwischenstufe zwischen dem Hochsprachen-Code und dem Binärcode, zum Beispiel Bytecode von Java.