10.1.2 Hochsprachen


Programme, die auf Endgeräten laufen sollen, werden von Menschen in einer Hochsprache programmiert. Für jedes Betriebssystem gibt es heute meist eine bevorzugte Hochsprache:

hochsprachen

Für jedes Betriebssystem gibt es passende integrierte Entwicklungsumgebung (IDE):


Das Internet bietet Webseiten auf die wir mit Web-Browsern zugreifen. Für die Programmierung von Webseiten unterscheidet man:

  • Programme, die beim Besucher der Webseite laufen (Frontend)
  • Programme, die auf dem Webserver laufen (Backend)

Programmieren im Web

Entwicklungsumgebung für Web-Programmierung: Visual Studio Code


Beispiele für Programm-Code in einer Hochsprache

Hochsprachen unterscheiden sich. Vor dem Start mit dem Programmieren stehen ein paar Entscheidungen:

  • für welche Plattform will ich programmieren?
  • welche Hochsprache will ich verwenden?
  • welche Entwicklungsumgebung will ich verwenden?

In den folgenden Beispielen wird jeweils ein Programm zur Erzeugung der Fibonacci-Folge 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ... in verschiedenen Hochsprachen und Assembler vorgestellt.

Anmerkung: Der Code wurde von der Github-Copilot-KI in einer Github-Codespace-Umgebung generiert.

Swift:
func fibonacci(bis n: Int) -> [Int] {
    guard n > 0 else { return [] }
    var folge = [0, 1]
    while folge.count < n {
        let naechsterWert = folge[folge.count - 1] + folge[folge.count - 2]
        folge.append(naechsterWert)
    }
    return folge
}
let ergebnis = fibonacci(bis: 10)
print(ergebnis)

Java:
public class Fibonacci {
    public static void main(String[] args) {
        int n = 10;
        int[] folge = new int[n];
        folge[0] = 0;
        folge[1] = 1;
        for (int i = 2; i < n; i++) {
            folge[i] = folge[i - 1] + folge[i - 2];
        }
        for (int i = 0; i < n; i++) {
            System.out.print(folge[i] + " ");
        }
    }
}

C#:
using System;
class Fibonacci {
    static void Main(string[] args) {
        int n = 10;
        int[] folge = new int[n];
        folge[0] = 0;
        folge[1] = 1;
        for (int i = 2; i < n; i++) {
            folge[i] = folge[i - 1] + folge[i - 2];
        }
        for (int i = 0; i < n; i++) {
            Console.Write(folge[i] + " ");
        }
    }
}

C++:
#include <iostream>
using namespace std;

int main() {
    int n = 10;
    int folge[n];
    folge[0] = 0;
    folge[1] = 1;
    for (int i = 2; i < n; i++) {
        folge[i] = folge[i - 1] + folge[i - 2];
    }
    for (int i = 0; i < n; i++) {
        cout << folge[i] << " ";
    }
    return 0;
}

Php:
<?php
$n = 10;
$folge = [0, 1];
for ($i = 2; $i < $n; $i++) {
    $folge[$i] = $folge[$i - 1] + $folge[$i - 2];
}
foreach ($folge as $wert) {
    echo $wert . " ";
}
?>

Rust:
fn main() {
    let n = 10;
    let mut folge = vec![0, 1];
    for i in 2..n {
        folge.push(folge[i - 1] + folge[i - 2]);
    }
    for wert in folge {
        print!("{} ", wert);
    }
}

Python:
n = 10
folge = [0, 1]
for i in range(2, n):
    folge.append(folge[i-1] + folge[i-2])
for wert in folge:
    print(wert, end=" ")

JavaScript:
let neueZahl = 1;
let v1 = 0;
let v2 = 1;
for (let i = 2; i <= 15; i = i + 1) {
  neueZahl = v1 + v2;
  v1 = v2;
  v2 = neueZahl;
  console.log(neueZahl);
}

Assembler:
section .data
    fibSeries db 0, 1 ;     Die ersten zwei Zahlen der Fibonacci-Folge

section .bss
    count resb 1

section .text
    global _start

_start:
    mov [count], 10 ;       Anzahl der zu berechnenden Fibonacci-Zahlen
    mov ecx, [count] ;      ECX wird als Zähler verwendet
    mov eax, 0 ;            Erstes Element der Fibonacci-Folge
    mov ebx, 1 ;            Zweites Element der Fibonacci-Folge

fib_loop:
    push eax ;              Speichere den aktuellen Wert von EAX auf dem Stack
    add eax, ebx ;          Addiere EAX und EBX (nächste Fibonacci-Zahl)
    mov edx, eax ;          Verschiebe das Ergebnis in EDX für die Ausgabe
    pop ebx ;               Stelle den vorherigen Wert von EAX in EBX wieder her
    dec ecx ;               Dekrementiere den Zähler
    jnz fib_loop ;          Springe zurück, wenn noch nicht alle Zahlen berechnet wurden

;                           Beenden des Programms (Linux-Syscall)
    mov eax, 1 ;            Syscall-Nummer für exit
    xor ebx, ebx ;          Status 0
    int 0x80 ;              Führe den Syscall aus

Bevor ein solches Programm von einem Computer ausgeführt werden kann, muss es in Maschinen-Code umgewandelt werden, der nur aus einer Bitfolge besteht.