EMZETT.Glossar
736 Begriffe aus IT, Netzwerk, Sicherheit und Programmierung: erst kurz erklärt, dann ausführlicher. Suche nach einem Wort oder wähle einen Buchstaben.
24 Treffer
Compiler Ein Compiler übersetzt den gesamten Quelltext einer Programmiersprache in eine andere Form – meist in Maschinencode oder Bytecode –, bevor das Programm läuft.
Dabei prüft er Syntax und (bei statisch typisierten Sprachen) Typen und meldet Fehler schon vor dem Start. Das Ergebnis läuft anschließend ohne weitere Übersetzung. Compiler-Sprachen sind unter anderem C, C++, Rust, Go, Pascal und Fortran; Java und C# kompilieren zu Bytecode (Bytecode), den eine virtuelle Maschine ausführt.
Verwandt: Bytecode · Interpreter · JIT-Compiler (Just-in-Time) · Quellcode · Baum (Datenstruktur) · Makro (Metaprogrammierung)
Ganzer Artikel im Wiki →JIT-Compiler (Just-in-Time) Ein JIT-Compiler übersetzt Bytecode oder Quelltext erst während der Ausführung in Maschinencode – und zwar bevorzugt die Programmstellen, die besonders oft laufen („Hot Spots“).
So verbinden virtuelle Maschinen die Portabilität von Bytecode mit der Geschwindigkeit nativen Codes. Das Programm startet interpretiert, die VM misst, welche Funktionen oft aufgerufen werden, und kompiliert diese in optimierten Maschinencode. Das Gegenstück ist die AOT-Kompilierung (*ahead of time*), die vor dem Start übersetzt.
Verwandt: Bytecode · Compiler · Interpreter · Garbage Collector
Ganzer Artikel im Wiki →Annotations Metadaten, die mit @Name vor eine Klasse, Methode oder Variable geschrieben werden — beeinflussen nicht direkt die Programmlogik, sondern liefern Zusatzinformation für Compiler, Tools oder Frameworks.
Bekannte eingebaute Annotationen: @Override (lässt den Compiler prüfen, dass wirklich eine geerbte Methode überschrieben wird — Tippfehler im Methodennamen fallen so sofort auf) und @Deprecated (markiert veraltete Elemente mit Compiler-Warnung bei Nutzung). Frameworks wie Spring nutzen eigene Annotationen extensiv, um Konfiguration statt in separaten Dateien direkt im Code zu hinterlegen.
Verwandt: Code · Dateien · Classes · Lambda · Methods
Ganzer Artikel im Wiki →Annotations (Annotationen) Metadaten, die direkt im Code an eine Klasse, Methode oder Variable angehängt werden, ohne deren eigentliches Verhalten zu verändern — eine Art strukturierter Kommentar, den auch Werkzeuge und die Laufzeitumgebung auslesen können.
Annotationen werden z. B. genutzt, um eine überschriebene Methode zu markieren (damit der Compiler bei einem Tippfehler im Methodennamen warnt), Testmethoden zu kennzeichnen, oder um Frameworks mitzuteilen, wie eine Klasse automatisch verarbeitet werden soll (z. B. beim Umwandeln in JSON). Anders als normale Kommentare können Annotationen von Compiler, Frameworks und Tools aktiv ausgewertet werden.
Verwandt: Code · JSON · Decorator-Muster (Dekorierer) · Classes (Klassen) · Makro (Metaprogrammierung) · Methods (Methoden)
Ganzer Artikel im Wiki →Bytecode Bytecode ist ein kompakter, plattformunabhängiger Zwischencode, den ein Compiler erzeugt und eine virtuelle Maschine ausführt. Er liegt zwischen Quelltext und Maschinencode.
Java-Programme werden zu .class-Dateien (JVM-Bytecode), C# zu IL für die CLR, Python zu .pyc-Dateien. Dank Bytecode läuft dasselbe Programm auf jedem System, auf dem die virtuelle Maschine installiert ist („write once, run anywhere“). Die VM führt den Code entweder interpretiert oder über JIT-Compilation aus.
Verwandt: Compiler · Interpreter · JIT-Compiler (Just-in-Time) · Assembly
Ganzer Artikel im Wiki →Code Allgemeiner Begriff für Anweisungen, die ein Computer ausführen kann oder die in eine ausführbare Form gebracht werden.
Umfasst je nach Kontext unterschiedliche Stufen: Quellcode (von Menschen lesbarer Programmtext), Maschinencode (direkt vom Prozessor ausführbare Bytes) oder Bytecode (Zwischenform, z. B. bei Java). Wird durch einen Compiler oder Interpreter von einer Stufe in die nächste überführt.
Verwandt: Quellcode · Drizzle ORM · Neon Auto-Suspend · next-intl · Cron Job (Vercel) · JSONL (JSON Lines)
Ganzer Artikel im Wiki →Constants (final) Eine Variable, deren Wert nach der Zuweisung nicht mehr geändert werden kann — in Java per final-Schlüsselwort markiert.
Konstanten machen Code sicherer und lesbarer: der Compiler verhindert versehentliches Überschreiben, und ein aussagekräftiger Name (z. B. MAX_RETRIES) ersetzt "magische Zahlen" im Code. Konvention in vielen Sprachen: Konstanten komplett in Großbuchstaben mit Unterstrichen schreiben (SCREAMING_SNAKE_CASE).
Verwandt: Declaring Variables (Variablendeklaration) · Code · Identifiers (Bezeichner) · Java · Enum · Modifiers
Ganzer Artikel im Wiki →Enum Ein eigener Typ für eine feste, begrenzte Menge benannter Konstanten — z. B. Wochentage oder Status-Werte, bei denen nur bestimmte Werte gültig sein dürfen.
Ein enum ist technisch eine spezielle Klasse, kann also auch eigene Felder, Konstruktoren und Methoden haben. Der große Vorteil gegenüber einfachen String- oder int-Konstanten: der Compiler verhindert ungültige Werte, ein switch über ein Enum kann vom Compiler sogar auf Vollständigkeit geprüft werden.
Verwandt: Constants (final) · Classes · Polymorphism · Switch-Statement
Ganzer Artikel im Wiki →Enum (Aufzählungstyp) Ein Datentyp, der aus einer festen, vorher definierten Menge benannter Konstanten besteht — z. B. die Wochentage oder die Himmelsrichtungen, bei denen es nur genau diese begrenzten, bekannten Werte geben kann.
Statt beliebige Zahlen oder Zeichenketten zu verwenden, um einen begrenzten Zustand darzustellen (z. B. 1 für Montag), macht ein Enum die gültigen Werte explizit und für den Compiler prüfbar — ein ungültiger Wert wie 8 für einen Wochentag ist so gar nicht erst möglich. Das macht Code lesbarer und weniger fehleranfällig als lose Zahlen- oder String-Konstanten.
Verwandt: Code · Pattern Matching (Mustervergleich) · Non-primitive Types (Referenztypen) · Switch-Statement
Ganzer Artikel im Wiki →Errors (Fehler) Ein Oberbegriff für alles, was beim Schreiben oder Ausführen eines Programms schiefgehen kann — von Syntaxfehlern, die der Compiler direkt ablehnt, bis zu Laufzeitfehlern, die erst während der Ausführung auftreten.
Man unterscheidet grob zwischen Syntaxfehlern (Code verstößt gegen die Grammatik der Sprache, kompiliert gar nicht erst), Logikfehlern (Code läuft, macht aber nicht das Gewollte) und Laufzeitfehlern bzw. Exceptions (ein konkretes Problem während der Ausführung, z. B. Division durch Null). Debugging ist der Prozess, solche Fehler systematisch zu finden und zu beheben.
Verwandt: Debugging · Exceptions · Error Codes (Fehlercodes) · Code
Ganzer Artikel im Wiki →Exceptions Laufzeitfehler, die mit try/catch gezielt abgefangen und behandelt werden können, statt das ganze Programm abstürzen zu lassen.
Java unterscheidet geprüfte Exceptions (checked, z. B. IOException — der Compiler zwingt zum Abfangen oder Weiterreichen) und ungeprüfte (unchecked, z. B. NullPointerException — Compiler prüft nichts, meist Programmierfehler statt erwartbarer Zustand). Ein finally-Block läuft immer, egal ob eine Exception geworfen wurde oder nicht — typisch für Aufräumarbeiten.
Verwandt: Errors · Multiple Exceptions · try-with-resources · Crash · Crash-Handler · Go
Ganzer Artikel im Wiki →Generics Typparameter in spitzen Klammern (<T>), mit denen eine Klasse oder Methode für beliebige Typen wiederverwendbar wird, ohne die Typsicherheit aufzugeben.
Ohne Generics müsste eine Collection mit dem allgemeinen Typ Object arbeiten und Werte beim Herausholen manuell zurückcasten — fehleranfällig, da Typfehler erst zur Laufzeit auffallen. Mit List<String> erzwingt der Compiler dagegen schon beim Kompilieren, dass nur String-Objekte hineinkommen.
Verwandt: Collections · Wrapper Classes · Advanced Sorting · ArrayList · List
Ganzer Artikel im Wiki →JDK Java Development Kit — das komplette Werkzeugpaket, um Java-Programme zu schreiben, zu kompilieren und auszuführen.
Enthält unter anderem den Compiler (javac), die Laufzeitumgebung (JRE mit der JVM) und Debugging-Werkzeuge. Wer nur fertige Java-Programme ausführen will, braucht lediglich das JRE; zum Entwickeln ist das vollständige JDK nötig.
Ganzer Artikel im Wiki →long Ein primitiver Ganzzahltyp mit 64 Bit — für Werte, die den Wertebereich von int (ca. ±2,1 Milliarden) sprengen.
Long-Literale brauchen ein L-Suffix, sonst interpretiert Java die Zahl zuerst als int und der Compiler meldet einen Fehler, wenn sie zu groß ist: long grosseZahl = 10000000000L;. Häufig genutzt für Zeitstempel (Millisekunden seit 1970) oder IDs in Datenbanken mit sehr vielen Einträgen.
Verwandt: byte · short · Bits · Java · Collections · double
Ganzer Artikel im Wiki →long Ein ganzzahliger Datentyp mit größerem Wertebereich als der Standard-Integer (meist 64 statt 32 Bit) — nötig, wenn Werte den normalen Integer-Bereich sprengen können.
Typische Anwendungsfälle sind Zeitstempel (Millisekunden seit einem festen Referenzpunkt), sehr große Zähler oder eindeutige IDs, die im Laufe der Zeit über den normalen 32-Bit-Bereich hinauswachsen. In vielen Sprachen muss ein long-Literal explizit gekennzeichnet werden (z. B. mit einem angehängten L), sonst interpretiert der Compiler die Zahl standardmäßig als kleineren Integer-Typ.
Verwandt: byte · short · Arithmetic Operators (Arithmetische Operatoren)
Ganzer Artikel im Wiki →Multiple Exceptions Mehrere catch-Blöcke (oder ein kombinierter Block mit |) hinter einem try, um unterschiedliche Fehlerarten unterschiedlich zu behandeln.
Die Reihenfolge zählt: spezifischere Exception-Typen müssen vor allgemeineren Typen stehen, sonst fängt ein früherer, breiterer catch-Block (z. B. Exception) alles ab und der speziellere danach wird nie erreicht — das meldet der Compiler als Fehler. Mit catch (IOException | SQLException e) lassen sich mehrere gleich behandelte Typen in einem Block zusammenfassen.
Verwandt: Exceptions · Error Codes
Ganzer Artikel im Wiki →Overloading (Methodenüberladung) Mehrere Methoden mit demselben Namen, aber unterschiedlicher Parameterliste (Anzahl oder Typ der Parameter) innerhalb derselben Klasse.
Welche der überladenen Varianten beim Aufruf tatsächlich ausgeführt wird, entscheidet der Compiler anhand der übergebenen Argumente — z. B. eine add(int, int)- und eine add(double, double)-Methode nebeneinander. Nicht zu verwechseln mit Overriding (Methodenüberschreibung), bei dem eine Unterklasse eine geerbte Methode mit identischer Signatur neu implementiert (siehe Vererbung).
Verwandt: Methods (Methoden) · Parameters (Parameter) · Signatur · Constructors (Konstruktoren) · Polymorphism (Polymorphie) · Inheritance (Vererbung)
Ganzer Artikel im Wiki →Pure Function (reine Funktion) Eine reine Funktion liefert bei gleichen Argumenten immer dasselbe Ergebnis und hat keine Nebenwirkungen: Sie ändert weder globale Variablen noch Eingaben, schreibt nichts in Dateien und gibt nichts aus.
Reine Funktionen sind leicht zu verstehen, zu testen und zu parallelisieren, weil ihr Ergebnis nur von den Argumenten abhängt. Ergebnisse lassen sich zwischenspeichern (Memoization), und der Compiler darf sie umsortieren oder wegoptimieren. Sie sind das Rückgrat der funktionalen Programmierung.
Verwandt: Higher-Order-Funktion (Funktion höherer Ordnung) · Unveränderlichkeit (Immutability) · Memoization · Lazy Evaluation (verzögerte Auswertung) · Unit-Test (Modultest)
Ganzer Artikel im Wiki →Quellcode Der von Menschen lesbare, in einer Programmiersprache geschriebene Text eines Programms.
Wird von einem Compiler in Maschinencode übersetzt oder von einem Interpreter direkt ausgeführt. "Open Source" bedeutet, dass dieser Quellcode öffentlich einsehbar (und meist auch veränderbar) ist — im Gegensatz zu proprietärer Software, bei der nur die fertige, kompilierte Anwendung ausgeliefert wird.
Verwandt: Code · Git · Pseudocode · .env-Dateien · Anwendungsentwicklung · Go
Ganzer Artikel im Wiki →SDK Software Development Kit — ein Bündel aus Werkzeugen, Bibliotheken und Dokumentation, um Software für eine bestimmte Plattform oder ein bestimmtes System zu entwickeln.
Anders als das JDK (spezifisch für Java) ist "SDK" ein allgemeiner Oberbegriff — es gibt z. B. Android-SDKs, iOS-SDKs oder SDKs für einzelne Cloud-Dienste. Enthält typischerweise APIs, Compiler/Build-Tools, Beispielcode und oft einen Emulator zum Testen.
Verwandt: API · JDK · Stripe · Java
Ganzer Artikel im Wiki →TypeScript Eine von Microsoft entwickelte Obermenge von JavaScript, die statische Typisierung hinzufügt.
Wird zu normalem JavaScript kompiliert ("transpiliert"), läuft also überall dort, wo JS läuft. Der Compiler prüft vor der Ausführung, ob Typen zusammenpassen (z. B. ob eine Funktion mit den richtigen Parametertypen aufgerufen wird), was viele Fehler schon während der Entwicklung statt erst zur Laufzeit auffängt.
Verwandt: JS · Angular · Java · JSON · Node.js · React
Ganzer Artikel im Wiki →Typinferenz (Typableitung) Bei der Typinferenz ermittelt der Compiler die Datentypen selbst aus dem Zusammenhang, sodass man sie nicht überall hinschreiben muss – ohne die Sicherheit der statischen Typprüfung aufzugeben.
Aus let x = 5 folgt int, aus x + 1.5 folgt float. Der Compiler prüft weiterhin alle Typen vor dem Start. Die Technik ist in Haskell, OCaml und F# am weitesten entwickelt (Hindley-Milner-Verfahren) und steckt in var/auto (Java, C#, C++), val (Kotlin, Scala), let (Rust, Swift), := (Go) und TypeScript.
Verwandt: var-Keyword · Duck Typing · Generics · Null (kein Wert) · Type Casting
Ganzer Artikel im Wiki →var-Keyword Ein Schlüsselwort zur Variablendeklaration, bei dem der Datentyp nicht explizit angegeben, sondern vom Compiler aus dem zugewiesenen Wert automatisch erschlossen wird ("Type Inference").
var spart Schreibarbeit bei offensichtlichen Typen (var zahl = 5; statt int zahl = 5;), ändert aber nichts an der Typsicherheit — der Typ steht nach der Zuweisung genauso fest wie bei expliziter Angabe, er wird nur automatisch bestimmt statt vom Entwickler geschrieben. In Java gibt es var seit Version 10, in JavaScript hat var eine andere, ältere Bedeutung (grob durch let/const abgelöst).
Verwandt: Declaring Variables (Variablendeklaration) · Java · Typinferenz (Typableitung)
Ganzer Artikel im Wiki →Wrapper Classes Klassen, die einen primitiven Datentyp als Objekt "verpacken" — z. B. Integer für int, Double für double, Boolean für boolean.
Collections wie List können nur Objekte speichern, keine primitiven Typen direkt — List<int> ist deshalb ungültig, List<Integer> dagegen funktioniert. Die automatische Umwandlung zwischen primitivem Typ und Wrapper (Autoboxing/Unboxing) übernimmt der Compiler meist unsichtbar, kann bei sehr vielen Umwandlungen aber Performance kosten.
Verwandt: Generics · Non-primitive Types · Collections · long · Strings
Ganzer Artikel im Wiki →