Skip to content

Latest commit

 

History

History
executable file
·
595 lines (434 loc) · 17.7 KB

00_Einfuehrung.md

File metadata and controls

executable file
·
595 lines (434 loc) · 17.7 KB

LiaScript

Einführung

Parameter Kursinformationen
Veranstaltung: @config.lecture
Semester @config.semester
Hochschule: Technische Universität Freiberg
Inhalte: Vorstellung des Arbeitsprozesses
**Link auf Repository: ** https://github.com/TUBAF-IfI-LiaScript/VL_EAVD/blob/master/00_Einfuehrung.md
Autoren @author


Fragen an die heutige Veranstaltung ...

  • Welche Aufgabe erfüllt eine Programmiersprache?
  • Erklären Sie die Begriffe Compiler, Editor, Programm, Hochsprache!
  • Was passiert beim Kompilieren eines Programmes?
  • Warum sind Kommentare von zentraler Bedeutung?
  • Worin unterscheiden sich ein konventionelles C++ Programm und eine Anwendung, die mit dem Arduino-Framework geschrieben wurde?

Umfrage

Hat Sie die letztwöchige Vorstellung der Ziele der Lehrveranstaltung überzeugt?

  • [(ja)] Ja, ich gehe davon aus, viel nützliches zu erfahren.
  • [(schau'n wir mal)] Ich bin noch nicht sicher. Fragen Sie in einigen Wochen noch mal.
  • [(nein)] Nein, ich bin nur hier, weil ich muss.

Wie arbeitet ein Rechner eigentlich?

{{0-1}} Programme sind Anweisungslisten, die vom Menschen erdacht, auf einem Rechner zur Ausführung kommen. Eine zentrale Hürde ist dabei die Kluft zwischen menschlicher Vorstellungskraft und Logik, die implizite Annahmen und Erfahrungen einschließt und der "stupiden" Abarbeitung von Befehlsfolgen in einem Rechner.

{{0-1}} Programmiersprachen bemühen sich diese Lücke zu schließen und werden dabei von einer Vielzahl von Tools begleitet, diesen Transformationsprozess unterstützen sollen.

{{0-1}} Um das Verständnis für diesen Vorgang zu entwickeln werden zunächst die Vorgänge in einem Rechner bei der Abarbeitung von Programmen beleuchtet, um dann die Realisierung eines Programmes mit C++ zu adressieren.

{{0-1}} instruction-set

{{1-2}} Beispiel: Intel 4004-Architektur (1971)

{{1-2}} intel

{{2}} Jeder Rechner hat einen spezifischen Satz von Befehlen, die durch "0" und "1" ausgedrückt werden, die er überhaupt abarbeiten kann.

{{2}} Speicherauszug den Intel 4004:

{{2}}

Adresse Speicherinhalt OpCode Mnemonik
0010 1101 0101 1101 DDDD LD $5
0012 1111 0010 1111 0010 IAC

{{3}} Unterstützung für die Interpretation aus dem Nutzerhandbuch, dass das Instruction Set beschreibt:

{{3}} instruction-set

{{3}} Quelle: Intel 4004 Assembler

Programmierung

Möchte man so Programme schreiben?

Vorteil:

  • ggf. sehr effizienter Code (Größe, Ausführungsdauer), der gut auf die Hardware abgestimmt ist

Nachteile:

  • systemspezifische Realisierung
  • geringer Abstraktionsgrad, bereits einfache Konstrukte benötigen viele Codezeilen
  • weitgehende semantische Analysen möglich

{{1}}

Eine höhere Programmiersprache ist eine Programmiersprache zur Abfassung eines Computerprogramms, die in Abstraktion und Komplexität von der Ebene der Maschinensprachen deutlich entfernt ist. Die Befehle müssen durch Interpreter oder Compiler in Maschinensprache übersetzt werden.

{{2}}

Ein Compiler (auch Kompiler; von englisch für zusammentragen bzw. lateinisch compilare ‚aufhäufen‘) ist ein Computerprogramm, das Quellcodes einer bestimmten Programmiersprache in eine Form übersetzt, die von einem Computer (direkter) ausgeführt werden kann.

{{2}} Stufen des Compile-Vorganges:

{{2}} instruction-set

Einordnung von C und C++

  • Adressiert Hochsprachenaspekte und Hardwarenähe -> Hohe Geschwindigkeit bei geringer Programmgröße

  • Imperative Programmiersprache

                               {{1}}
    

    imperative (befehlsorientierte) Programmiersprachen: Ein Programm besteht aus einer Folge von Befehlen an den Computer. Das Programm beschreibt den Lösungsweg für ein Problem (C, Python, Java, LabView, Matlab, ...).

    deklarative Programiersprachen: Ein Programm beschreibt die allgemeinen Eigenschaften von Objekten und ihre Beziehungen untereinander. Das Programm beschreibt zunächst nur das Wissen zur Lösung des Problems (Prolog, Haskal, SQL, ...).

  • Wenige Schlüsselwörter als Sprachumfang

                                {{2}}
    

    Schlüsselwort Reserviertes Wort, das der Compiler verwendet, um ein Programm zu parsen (z.B. if, def oder while). Schlüsselwörter dürfen nicht als Name für eine Variable gewählt werden

  • Große Mächtigkeit

                                {{3}}
    

    Je "höher" und komfortabler die Sprache, desto mehr ist der Programmierer daran gebunden, die in ihr vorgesehenen Wege zu beschreiten.

Erstes C++ Programm

"Hello World"

// That's my first C program
// Karl Klammer, Oct. 2022

#include <iostream>

int main() {
    std::cout << "Hello World!";
    return 0;
}

@LIA.eval(["main.cpp"], g++ main.cpp -o a.out, ./a.out)

Zeile Bedeutung
1 - 2 Kommentar (wird vom Präprozessor entfernt)
4 Voraussetzung für das Einbinden von Befehlen der Standardbibliothek hier std:cout()
6 Einsprungstelle für den Beginn des Programmes
6 - 9 Ausführungsblock der main-Funktion
7 Anwendung eines Operators << hier zur Ausgabe auf dem Bildschirm
8 Definition eines Rückgabewertes für das Betriebssystem
             {{1-2}}

Halt! Unsere C++ Arduino Programme sahen doch ganz anders aus?

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
}

@AVR8js.sketch


             {{2-3}}

Noch mal Halt! Das klappt ja offenbar alles im Browserfenster, aber wenn ich ein Programm auf meinem Rechner kompilieren möchte, was ist dann zu tuen?


Ein Wort zu den Formalien

// Karl Klammer
// Print Hello World drei mal

#include <iostream>

int main() {
  int zahl;
  for (zahl=0; zahl<3;  zahl++){
	    std::cout << "Hello World! ";
  }
	return 0;
}

@LIA.eval(["main.cpp"], g++ main.cpp -o a.out, ./a.out)

#include <iostream>
int main() {int zahl; for (zahl=0; zahl<3;  zahl++){ std::cout << "Hello World! ";} return 0;}

@LIA.eval(["main.cpp"], g++ main.cpp -o a.out, ./a.out)

                              {{1}}
  • Das systematische Einrücken verbessert die Lesbarkeit und senkt damit die Fehleranfälligkeit Ihres Codes!
  • Wählen sie selbsterklärende Variablen- und Funktionsnamen!
  • Nutzen Sie ein Versionsmanagmentsystem, wenn Sie ihren Code entwickeln!
  • Kommentieren Sie Ihr Vorgehen trotz "Good code is self-documenting"

Gute Kommentare

1. Kommentare als Pseudocode

/* loop backwards through all elements returned by the server
(they should be processed chronologically)*/
for (i = (numElementsReturned - 1); i >= 0; i--){
    /* process each element's data */
    updatePattern(i, returnedElements[i]);
}

2. Kommentare zur Datei

// This is the mars rover control application
//
// Karl Klammer, Oct. 2018
// Version 109.1.12

int main(){...}

3. Beschreibung eines Algorithmus

/* Function:  approx_pi
 * --------------------
 * computes an approximation of pi using:
 *    pi/6 = 1/2 + (1/2 x 3/4) 1/5 (1/2)^3  + (1/2 x 3/4 x 5/6) 1/7 (1/2)^5 +
 *
 *  n: number of terms in the series to sum
 *
 *  returns: the approximate value of pi obtained by suming the first n terms
 *           in the above series
 *           returns zero on error (if n is non-positive)
 */

 double approx_pi(int n);

In realen Projekten werden Sie für diese Aufgaben Dokumentationstools verwenden, die die Generierung von Webseite, Handbüchern auf der Basis eigener Schlüsselworte in den Kommentaren unterstützen -> doxygen.

4. Debugging

int main(){
  ...
  preProcessedData = filter1(rawData);
  // printf('Filter1 finished ... \n');
  // printf('Output %d \n', preProcessedData);
  result=complexCalculation(preProcessedData);
  ...
}

Schlechte Kommentare

1. Überkommentierung von Code

x = x + 1;  /* increment the value of x */
std::cout << "Hello World! "; // displays Hello world

... over-commenting your code can be as bad as under-commenting it!

Quelle: C Code Style Guidelines

2. "Merkwürdige Kommentare"

//When I wrote this, only God and I understood what I was doing
//Now, God only knows
// sometimes I believe compiler ignores all my comments
// Magic. Do not touch.
// I am not responsible of this code.

try {

} catch(e) {

} finally { // should never happen }

Sammlung von Kommentaren

Was tun, wenn es schief geht?

// Karl Klammer
// Print Hello World drei mal

#include <iostream>

int main() {
  for (zahl=0; zahl<3;  zahl++){
	    std::cout << "Hello World! "
  }
	return 0;

@LIA.eval(["main.cpp"], g++ main.cpp -Wall -o a.out, ./a.out)

Methodisches Vorgehen:

  • ** RUHE BEWAHREN **
  • Lesen der Fehlermeldung
  • Verstehen der Fehlermeldung / Aufstellen von Hypothesen
  • Systematische Evaluation der Thesen
  • Seien Sie im Austausch mit anderen (Kommilitonen, Forenbesucher, usw.) konkret

Compilerfehlermeldungen

Beispiel 1

#include <iostream>

int mani() {
    std::cout << "Hello World!";
    return 0;
}

@LIA.evalWithDebug(["main.cpp"], g++ main.cpp -o a.out, ./a.out)

Beispiel 2

#include <iostream>

int main()
    std::cout << "Hello World!";
    return 0;
}

@LIA.evalWithDebug(["main.cpp"], g++ main.cpp -o a.out, ./a.out)

Manchmal muss man sehr genau hinschauen, um zu verstehen, warum ein Programm nicht funktioniert. Versuchen Sie es!

#include <iostream>

imt main() {
	std::cout << "Hello World!'';
	std::cout << "Wo liegt der Fehler?";
	return 0;
}

@LIA.evalWithDebug(["main.cpp"], g++ main.cpp -o a.out, ./a.out)

Und wenn das Kompilieren gut geht?

... dann bedeutet es noch immer nicht, dass Ihr Programm wie erwartet funktioniert.

#include <iostream>

int main() {
  char zahl;
  for (zahl=250; zahl<256; zahl++){
	    std::cout << "Hello World!";
  }
	return 0;
}

@LIA.eval(["main.cpp"], g++ main.cpp -o a.out, ./a.out)

Hinweis: Die Datentypen werden wir in der nächsten Woche besprechen.

Warum dann C++?

Zwei Varianten der Umsetzung ... C++ vs. Python

#include <iostream>

int main() {
  char zahl;
  for (int zahl=0; zahl<3; zahl++){
	    std::cout << "Hello World! " << zahl << "\n";
  }
	return 0;
}

@LIA.eval(["main.cpp"], g++ main.cpp -o a.out, ./a.out)

for i in range(3):
  print("Hallo World ", i)

@LIA.eval(["main.py"], python3 -m compileall ., python3 main.py)

Beispiele der Woche

                  {{0-1}}

Gültiger C++ Code

#include <iostream>

imt main() {
  int i = 5;
  int j = 4;
  i = i + j + 2;
	std::cout << "Hello World ";
  std::cout << i << "!";
	return 0;
}

Umfrage: Welche Ausgabe erwarten Sie für folgendes Code-Schnippselchen?

  • [(Hello World5)] Hello World7
  • [(Hello World11)] Hello World11
  • [(Hello World 11!)] Hello World 11!
  • [(Hello World 11 !)] Hello World 11 !
  • [(Hello World 5 !)] Hello World 5 !

                  {{1-2}}

Algorithmisches Denken

Aufgabe: Ändern Sie den Code so ab, dass das die LED zwei mal mit 1 Hz blinkt und dann ausgeschaltet bleibt.

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
}

@AVR8js.sketch


Quiz

Einbinden von Bibliotheken

Wie müssen Bibliotheken in C++ eingebunden werden?

  • [( )] using iostream
  • [( )] import iostream
  • [(X)] #include <iostream>

Kommentare

Sind diese Kommentare angebracht?

#include <iostream>                 // I always forget this xD

int main() {                        // main-function
  char zahl;                        // I have homework due tomorrow :(
  for (zahl=250; zahl<256; zahl++){ // I really have no idea what this even does but whatever... LOL
	    std::cout << "Hello World!";  // Prints "Hello World!" in console
  }
	return 0;
}
  • [( )] Ja
  • [(X)] Nein

Konventionen und Formalien

Wählen Sie alle Programme aus, die den üblichen Formalien entsprechen.

#include <iostream>
int main() {int a = 0; std::cout << "Hello World!" << a; return 0;}
#include <iostream>

int main() {
  int a = 0;
	std::cout << "Hello World!" << a;
	return 0;
}
#include  	                 <iostream>

int main()     {
  int               a      =            0;
	std::cout    <<                  "Hello World!"     <<  a    ;
	return            0           ;
                                                                              }
  • [[ ]] 1.cpp
  • [[X]] 2.cpp
  • [[ ]] 3.cpp