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:
Für jedes Betriebssystem gibt es passende integrierte Entwicklungsumgebung (IDE):
-
macOS, iOS: Hochsprache Swift - IDE: Xcode/
-
Windows: Hochsprache C# - IDE: Microsoft Visual Studio
-
Android: Hochsprache Java - IDE: Android Studio
-
Linux: Hochsprache C++ - IDE: CLion
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)
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.