Grundlagen - s46fa84e08dd04cbd.jimcontent.com · 1 GByte = 1073741824 Byte Um im folgenden binäre (duale) Zahlen von dezimalen unterscheiden zu können, werden binäre Zahlen immer

Informatik Grundlagen

Studiengang MM

Wintersemester 2016/2017

Hochschule Heilbronn Technik ● Wirtschaft ● Informatik Heilbronn University

Fakultät Mechanik und Elektronik Studiengang Mechatronik und Mikrosystemtechnik

Informatik, Grundlagen 2 D. Hägele, Stand 20.08.2016

Grundlagen

Inhalt

1. Historische Entwicklung ................................................................................................... 3 2. Rechner-Architektur ......................................................................................................... 8

2.1. von-Neumann-Architektur .......................................................................................... 8 2.2. Harvard-Architektur .................................................................................................... 9 2.3. Schichtenarchitektur ................................................................................................ 10

3. Das binäre Zahlensystem .............................................................................................. 11

3.1. Zahlen mit und ohne Vorzeichen, Zweier-Komplement ........................................... 13 3.2. Rechnen im binären Zahlensystem .......................................................................... 14 3.3. BCD-Zahlen ............................................................................................................. 16

3.4. Gleitkommazahlen (Floating point decimals) ........................................................... 17 4. Weitere Zahlensysteme ................................................................................................. 18

4.1. Oktal ........................................................................................................................ 18 4.2. Hexadezimal ............................................................................................................ 18

4.3. Übersicht Zahlensysteme ........................................................................................ 19 4.4. Technische Umsetzung ........................................................................................... 19

5. Boolesche Algebra / Binäre Logik .................................................................................. 20 5.1. Grundschaltungen .................................................................................................... 21

5.1.1. UND-Verknüpfung (Konjunktion) ........................................................................ 21

5.1.2. Negation ............................................................................................................ 22

5.1.3. ODER-Gatter (OR, Disjunktion) ......................................................................... 23

5.1.4. XOR/EXOR (Antivalenz) .................................................................................... 24 5.2. Zusammengesetzte Schaltungen ............................................................................. 25

5.2.1. NAND-Gatter...................................................................................................... 25 5.2.2. NOR-Gatter ........................................................................................................ 26

5.3. Rechenregeln........................................................................................................... 27 5.4. Karnaugh-Veitch-Diagramm .................................................................................... 28

6. Entwicklung, Darstellung und Dokumentation von Programmen ................................... 30 6.1. V-Modell ................................................................................................................... 31 6.2. Scrum-Methode ....................................................................................................... 32 6.3. ADAM & EVA ........................................................................................................... 35 6.4. Strukturen ................................................................................................................ 36

6.5. Programmablaufplan (Flussdiagramm) .................................................................... 37

6.6. Struktogramm nach Nassi-Shneidermann ............................................................... 39

7. ASCII-Code, ANSI-Code, Unicode ................................................................................ 41 7.1. ASCII-Zeichensatz (American Standard Code of Information Interchange) ............. 41 7.2. ANSI-Zeichensatz .................................................................................................... 42 7.3. Unicode .................................................................................................................... 44




1. Historische Entwicklung Seit Tausenden von Jahren ist das Zählen und Rechnen ein fester Bestandteil der menschlichen Kultur. Schon früh wurde versucht, das Rechnen allgemein zugänglich zu machen. Rechenmaschinen waren deshalb immer schon begehrte Geräte.

ca. 1100 v. Chr. China Abakus

1623 Wilhelm Schickard (1592 - 1635) Deutschland Erstes mechanisches Rechenwerk; wurde unter anderem von Johannes Kepler zur Berechnung von Planetenbahnen benutzt.

1642 Blaise Pascal (1623 -1662) Frankreich Entwicklung einer Rechenmaschine, der Pascaline; Herstellung und Verkauf wurde nach nur 50 Stück wieder eingestellt

1673 Gottfried Wilhelm Leibniz (1646 - 1716) Deutschland Einführen des dualen Zahlensystems, binäres Rechnen und Rechnen mit Bedingungen (Dissertatio de arte combinatoria), Entwicklung einer Rechenmaschine




1823 Charles Babbage (1791 - 1871) England Erste programmierbare Rechenmaschine (Difference Engine, Analytical Engine) mit Rechenwerk, Programmwerk, Speicherwerk, Steuerung mit Lochkarten; hat wegen mechanischer Probleme nie funktioniert

1890 Hermann Hollerith (1860 - 1929) USA Einführung der Lochkarte zur Auswertung der amerikanischen Volkszählung von 1890; aus seiner damals gegründeten Firma ging IBM hervor

1936 Alan Turing (1912 -1954) England Beschreibung der Funktion eines Computers ("On Computable Numbers"; Turing-Maschine); später weitere theoretische Arbeiten über Computer und deren mathematische Grundlagen; "Turing-Test" (1950) als Test für künstliche Intelligenz

1941 Konrad Zuse (1910 - 1995) Deutschland Entwicklung programmgesteuerter Rechenmaschinen; erste funktionsfähige Anlage Z3 1941 (2600 elektromechanische Schalter); Programm auf gelochtem Kinofilmstreifen, Verwendung bistabiler Schaltelement und dualer Zahlen sowie logischer Verknüpfungen, Gleitkommadarstellung der Zahlen; viele theoretische Arbeiten




1943 Howard Aiken (1900 - 1973) USA ASCC (Harvard MARK I), Relaisrechner, auf 23 Stellen genau, ca. 35 t schwer mit 800 km Kabel Addition: 6 s Division: 12 s Basierte vom Aufbau her auf den Arbeiten von Charles Babbage

1945 John von Neumann (1903 – 1957) USA er schuf die noch heute übliche Rechnerarchitektur; entwickelte mit anderen den ENIAC Röhrenrechner:

1947 Brattain, Shockley, Bardeen USA Entwicklung des Transistors

1976 Apple Der Apple I läutet das Zeitalter der Massencomputer ein

1981 IBM IBM setzt mit seinem Personal Computer 5150 mit Intel 8086-Prozessor und Microsoft DOS einen Industriestandard

1984 Apple Der Macintosh erscheint mit seinem revolutionären MacDOS auf Basis des Motorola 68000: - graphische Benutzeroberfläche - Maus - Fenstertechnik - Plug & Play




Geschichte der Halbleiter- und Prozessortechnologie 1955 Einsatz von Transistoren in Rechnern

1962 Erste ICs der TTL-Familie

1965 Erste Bauteile in MOS-Technik

1970 Erste Bauteile in CMOS-Technik

1970 Entwicklung des 4004-Prozessors durch Intel (4-bit)

2300 Transistoren, 46 Befehle, 10,8 µs Zykluszeit (90 kHz)

1972 8008-Prozessor (8-bit)


Urvater der Intel-Linie 80xxx und Pentium

64 KByte Adressraum, 2µs Zykluszeit (500 kHz)

1975 6800-Prozessor (8-bit) von Motorola

1978 8086-Prozessor (16-bit, 29000 Transistoren)

1979 68000-Prozessor

1982 80286-Prozessor (134000 Transistoren)


1989 80486-Prozessor (32-bit) mit integriertem math. Coprozessor und 8K-Byte Cache on Chip; 1,3 Mio. Transistoren

1992 Pentium-Prozessor (64-bit, 3,1 Mio. Transistoren)

1995 Pentium II-Prozessor (5,5 Mio. Transistoren)

1998 Pentium III-Prozessor (24 Mio. Transistoren)

2000 Pentium IV-Prozessor (42 Mio. Transistoren)

2001 Itanium

2006 Dual Core Itanium

2011 Xeon E7-8830 – Prozessor (2,3 Mrd. Transistoren)

Um die Rechenleistung zu erhöhen werden in einem Computer mehrere Prozessoren (Prozessorenkerne = Core) eingesetzt. So können mehrere Anweisungen gleichzeitig und parallel ausgeführt werden. Bei Supercomputern werden Massiv-Parallele-Strukturen verwendet. Hier werden mehrere Hundert bis Tausende Prozessoren miteinander vernetzt. Der Supercomputer Tianhe-2 in China verwendet z.B. 32 000 Intel Xeon-E5-Prozessoren und 48 000 Intel Xeon-Phi-Co-Prozessoren und erreicht damit eine Rechenleistung von 33 862 TeraFLOPS (FLOP = Floating Point Operation). Dazu muss er allerdings mit 17 808 kW an elektrischer Leistung versorgt werden.




Die Entwicklung der Leistungsfähigkeit von Mikroprozessoren (Moore’s Gesetz)

(Quelle: Wikipedia)

1965 von Gordon Moore (Intel-Mitbegründer) formuliertes Gesetz, nach dem sich ca. alle 18 Monate die Anzahl der Transistoren pro Chipfläche verdoppelt; d.h. Verdoppelung der Geschwindigkeit von Computerprozessoren bei gleichbleibendem Preis in diesem Zeitraum.




2. Rechner-Architektur

2.1. von-Neumann-Architektur Der noch heute übliche Aufbau von Computern geht auf John von Neumann zurück. Danach besteht ein Computer aus den folgenden 4 Grundeinheiten:

Das Rechenwerk (ALU = Arithmetic Logic Unit) ist der eigentliche Rechner im Computer. Er kann neue Daten nach einer Vorschrift (z.B. Addition, Subtraktion, logische Verknüpfungen) aus gegebenen Daten erzeugen. Diese neue Daten können dann auch Auswirkungen auf das Steuerwerk haben. Das Steuerwerk legt die Abfolge der von der CPU ausgeführten Befehle fest. Dabei sind auch bedingte Sprungbefehle möglich, die vom Ergebnis einer Berechnung der ALU abhängig sind. Ebenso können Ereignisse von außen den Programmablauf verändern (Interrupts). Das Steuerwerk setzt also die Struktur des programmierten Algorithmus um.

Schematische Darstellung der von-Neumann-Architektur

(Teil der CPU)

(Teil der CPU)




Der Adressbus gibt an, auf welche Adresse zugegriffen werden soll (lesen oder schreiben). Der Adressbus ist unidirektional, d. h. nur die CPU kann hier Änderungen vornehmen (beim Pentium III: 32-bit). Der Datenbus gibt die Daten von dieser angesprochenen Adresse zurück oder stellt sie zum Schreiben zur Verfügung. Der Datenbus ist bidirektional, d. h. die CPU kann sowohl senden als auch empfangen, ebenso die anderen Blöcke (beim Pentium III: 64-bit). Im System werden Adressen meist doppelt vergeben. Einmal kann eine Adresse eine Speicherzelle im RAM bezeichnen, gleichzeitig aber auch eine I/O-Port-Adresse sein. Der Steuerbus regelt über seine Leitungen, ob die verlangte Adresse im Speicher oder im I/O-Teil angesprochen werden soll. Außerdem gibt er an, ob von dieser Adresse gelesen oder geschrieben wird. Aus dem obigen Schaubild läßt sich auch sehr gut ein Grundpfeiler der C-Philosophie herleiten. Da der Datenbus allen Elementen gleichermaßen zugänglich ist, spricht man in C von Datenströmen (Streams). Diese können dann mit ähnlichen Mitteln behandelt werden. Dabei ist es unerheblich, ob die Daten aus dem RAM-Speicher, der Tastatur oder der Festplatte kommen.

2.2. Harvard-Architektur Die Harvard-Architektur bezeichnet in der Informatik ein Schaltungskonzept zur Realisierung besonders schneller CPUs und Signalprozessoren. Der Befehlsspeicher ist logisch und physisch vom Datenspeicher getrennt. Die logische Trennung ergibt sich aus verschiedenen Adressräumen und verschiedenen Maschinenbefehlen zum Zugriff auf Befehl- und Datenspeicher. Die physische Trennung ist mit zwei getrennten Speichern realisiert, auf die der Zugriff über je einen eigenen Bus erfolgt. Der Vorteil dieser Architektur besteht darin, dass Befehle und Daten gleichzeitig geladen, bzw. geschrieben werden können. Bei einer klassischen von-Neumann-Architektur sind hierzu mindestens zwei aufeinander folgende Buszyklen notwendig. Zudem sorgt die physikalische Trennung von Daten und Programm dafür, dass eine Zugriffsrechtetrennung und Speicherschutz einfach realisierbar sind. Um z.B. zu verhindern, dass bei Softwarefehlern Programmcode überschrieben werden kann, wird für den Programmcode ein im Betrieb nur lesbarer Speicher (z.B. ROM, Lochkarten) verwendet, für die Daten schreib- und lesbarer Speicher (z.B. RAM, Ringkernspeicher). Nachteilig ist allerdings, dass nicht benötigter Datenspeicher nicht als Programmspeicher genutzt werden kann, also eine erhöhte Speicherfragmentierung auftritt.




Befehls-

speicher

Daten-

speicher

CPU

Rechen-werk

Schematische Darstellung der HARVARD-Architektur

2.3. Schichtenarchitektur Die Verbindung zwischen Benutzer und den elektronischen Bauteilen lässt sich in verschiedene Stufen aufteilen:

Anwendungsprogramm und Betriebssystem sind hardwareunabhängig, d.h. sie müssen nicht individuell auf jeden Rechnertyp abgestimmt werden. Erst das BIOS ist hardwareabhängig und benötigt Informationen über die verwendeten Bauteile.




3. Das binäre Zahlensystem Es gibt 10 Arten von Menschen. Diejenigen, die das binäre System verstehen, und die, die es nicht verstehen. Im PC werden Daten grundsätzlich als Binärdaten verarbeitet. Die Bausteine, die die elektronische Hardware des Systems ausmachen, verarbeiten zwei Spannungspegel, um die jeweilige logische Funktion zu definieren. Dies entspricht der Funktion eines mechanischen Schalters, der ja auch in zwei Zuständen (Ein/Aus; High/Low; 1/0) sein kann. Die kleinste Informationseinheit ist damit 1 Bit (binary digit). Die Komplexität der Operationen eines Rechners wird dadurch möglich, dass viele Bits natürlich wesentlich mehr als nur die zwei Grundzustände definieren können. 8 Bit = 1 Byte Grundeinheit der Datenverarbeitung Bit-Nr.

7 6 5 4 3 2 1 0

Wert

128 64 32 16 8 4 2 1

Graphik

Bezeichnung

MSB

LSB

MSB: most significant bit LSB: least significant bit Ein Byte kann 256 verschiedene Zustände annehmen (0-255). Dies entspricht den Zahlen von 00000000B = 0D bis 11111111B = 255D. Die Umwandlung ist dabei wie folgt

10101101B = 1 0 1 0 1 1 0 1

1x27 + 0x26 + 1x25 + 0x24 + 1x23 + 1x22 + 0x21 + 1x20 1x128+ 0x64 + 1x32 + 0x16 + 1x8 + 1x4 + 0x2 + 1x1 = 173D Bei der Umwandlung von dezimal in binär wird die dezimale Zahl immer durch 2 geteilt und der verbleibende Rest von rechts nach links eingefügt (vgl. "Horner-Schema") 173D = 1 0 1 0 1 1 0 1 =10101101B 173 / 2 = 86 Rest 1 86 / 2 = 43 Rest 0 43 / 2 = 21 Rest 1 21 / 2 = 10 Rest 1 10 / 2 = 5 Rest 0 5 / 2 = 2 Rest 1 2 / 2 = 1 Rest 0 1 / 2 = 0 Rest 1




Vielfache der Grundeinheit Byte werden üblicherweise in 2er Potenzen angegeben. Damit ergibt sich: 1 KByte = 1024 Byte 1 MByte = 1048576 Byte 1 GByte = 1073741824 Byte Um im folgenden binäre (duale) Zahlen von dezimalen unterscheiden zu können, werden binäre Zahlen immer mit einem nachfolgenden „B“ gekennzeichnet. Dezimalzahlen erhalten optional ein „D“. Alternativ kann auch die Zahlenbasis als Index angehängt werden.

Anmerkung: Im Dezember 1999 wurde auf Anregung des IEEE (Institute of Electrical and Electronics Engineers) von der IEC (International Electrotechnical Commission) mit dem "Amendment 2 to IEC International Standard IEC 60027-2: Letter symbols to be used in electrical technology - Part 2: Telecommunications and electronics" eine international verbindliche Regelung geschaffen, um die "1024er Bytes" zu kennzeichnen. Seit November 2000 ist der ehemalige Zusatz fest in die IEC 60027-2 integriert worden. Um dies zu erreichen werden andere Vorsilben (Präfixe) benutzt: Kibi (Ki), Mebi (Mi), Gibi (Gi) etc. Diese Kürzel wurden aus "Kilo Binary", "Mega Binary", "Giga Binary" gebildet. Ein Kilobyte (kB) umfasst damit 1000 Byte, ein KibiByte (KiB) dagegen 1024 Byte. Interessanterweise hat außerhalb dieser Kommission scheinbar noch niemand von diesem Standard gehört. Deshalb wir sich diese Schreibweise nach meiner Einschätzung auch nicht durchsetzen. In diesem Skript wird also ein Kilobyte immer 1024 Byte haben.

Abgeleitete und weniger gebräuchliche Einheiten 1 Word: Größe entspricht der Datenbreite des verwendeten Systems, also 16 Bit bzw.

32 Bit bei älteren Windows-Systemen, 64 Bit bei modernen Anwendungen. 1 Nibble: 4 Bit oder ein halbes Byte; diese Einheit entspricht einer einzelnen

hexadezimalen Ziffer (s. Kapitel 4.2)




3.1. Zahlen mit und ohne Vorzeichen, Zweier-Komplement Wie oben gezeigt sind binäre Zahlen zunächst nur positiv und starten bei 0 (UNSIGNED). Dies ist in manchen Fällen nicht erwünscht. Deshalb muss ein Weg gefunden werden, auch negative Zahlen darzustellen (SIGNED). a) Vorzeichen-Betragsdarstellung

Das Vorzeichen wird in einem zusätzlichen Bit gespeichert 89D = 0 0101 1001B -89D = 1 0101 1001B Rechnungen müssen dann aber vorzeichenspezifisch ausgeführt werden

b) Komplement-Darstellung (Einer-Komplement) Das MSB definiert das Vorzeichen, bei negativen Zahlen werden die restlichen Bits invertiert (komplementiert). 89D = 0101 1001B -89D = 1010 0110B Aber: In diesem Zahlensystem gibt es zwei Nullen! (+0D = 0000 0000B / -0D = 1111 1111B)

c) Zweier-Komplement-Darstellung Nach dem Bilden des Komplements wird 1 addiert (Überlauf nicht berücksichtigen) 89D = 0101 1001B -89D = 1010 0111B

Die Zweier-Komplement-Darstellung ist in Rechnern üblich, da sie auch vorzeichenrichtiges Rechnen mit Dualzahlen erlaubt. Der Zahlenbereich für eine 8-bit-Zahl geht damit von -128D bis +127D.




3.2. Rechnen im binären Zahlensystem Beim Rechnen kann es vorkommen, dass eine zusätzliche Stelle benötigt wird. Kommt man mit einer Berechnung über die Grenzen des von den vorhandenen Stellen vorgegebenen Wertebereichs hinaus, so wird eine neue Stelle angefügt und der Überlauf darin berücksichtigt. Der Überlauf wird auch "Carry" genannt. Addition

Rechenregeln für Dualzahlen: 0B + 0B = 0B

1B + 0B = 1B

0B + 1B = 1B

1B + 1B = 10B

Ein Übertrag (Carry) erfolgt, wenn das Additionsergebnis einer Spalte größer oder gleich der jeweiligen Zahlenbasis (hier: 2) ist. Beispiel: Dezimal

Dual

173 1010 1101B + 95 + 101 1111B

268

1 0000 1100B Subtraktion Zur Vereinfachung des Rechenwerks wird die Subtraktion auf eine Addition einer Zahl mit umgekehrtem Vorzeichen zurückgeführt (im Zweier-Komplement). Beispiel: Dezimal

Dual

23 0001 0111B - 45 + 1101 0011B -0010 1101B = + 1101 0011B

-22

1110 1010B




Multiplikation

Rechenregeln für Dualzahlen: 0B * 0B = 0B

1B * 0B = 0B

0B * 1B = 0B

1B * 1B = 1B

Wegen der einfachen Regeln benötigt man zur Durchführung der Multiplikation nur Addier- und Schiebebefehle. Auch Zahlen im Zweierkomplement lassen sich problemlos vorzeichenrichtig multiplizieren. Beispiel: 0 7 * 1 3 0 1 1 1 * 1 1 0 1 B

2 1 0 1 1 1 0 7 0 0 0 0 0 1 1 1 0 1 1 1

9 1 1 0 1 1 0 1 1 B Eine Multiplikation um den Faktor 2 kann durch einfaches Schieben der Dualzahl um eine Bitposition nach links erreicht werden. Dabei werden von rechts Nullen nachgeschoben. Division Die Division kann im Dualsystem ähnlich dem bekannten Subtraktionsverfahren aus dem Dezimalsystem durchgeführt werden. Dies führt allerdings nur bei positiven Zahlen zum richtigen Ergebnis. Eine Division macht zudem bei ganzen Zahlen wenig Sinn, da das Ergebnis meist eine rationale Zahl oder Bruch ist, der sich nicht in dem seither verwendeten Schema für ganze Zahlen darstellen läßt. Beispiel: 2 1 0 : 6 = 3 5 1 1 0 1 0 0 1 0 : 1 1 0 = 1 0 0 0 1 1 B

- 1 8 - 1 1 0

3 0 0 1 - 3 0 1 0

0 1 0 0 1 0 0 1 - 1 1 0

1 1 0 - 1 1 0

0




Eine Division durch Potenzen von 2 kann durch Rechtsschieben der Zahl um eine entsprechende Stellenzahl erreicht werden. Dabei muss bei Zweier-Komplement-Zahlen von links her immer ein dem MSB entsprechendes Bit nachgeschoben werden, damit Vorzeichen erhalten bleibt. Natürlich können die rationalen Zahlen auch im Dualsystem dargestellt werden. Dabei steht die erste Dezimale für 1/2, die zweite für 1/4, die dritte für 1/8, etc. 100011,1101B = 35,8125D 11,1B = 3,5D

3.3. BCD-Zahlen

In vielen Fällen kann das Rechnen im Dualsystem aber ungünstig sein. Speziell bei Registrierkassen oder Taschenrechnern ist nur eine feste Anzahl von Dezimalstellen hinter dem Komma erwünscht. Zum Beispiel ist es sehr schwierig, eine dem Wert 35,81D entsprechende Dualzahl zu erzeugen. 00100011,11001111010111000010B = 35,80999947D Deshalb wird hier eine andere Form der Codierung verwendet, die sogenannten BCD-Zahlen (Binary Coded Digits). Dabei wird jeder Dezimalziffer ein Block von 4 Bit zugeordnet. 1 Byte enthält damit genau 2 Ziffern. Die Rückumsetzung von binär in dezimal ist damit sehr einfach und immer genau. 00110101,10000001BCD = 35,81D Auch für BCD-Zahlen gelten die Rechenregeln der Addition und Subtraktion wie oben beschrieben. ACHTUNG! Um bei rationalen Zahlen das Zweier-Komplement zu bilden wird nicht 1 addiert, sondern das LSB um 1 erhöht (hier: +0,01). Viele Mikroprozessoren können neben der binären Arithmetik auch in einem Modus für BCD-Arithmetik arbeiten. Damit lassen sich dann entsprechende Aufgabenstellungen einfach lösen.




3.4. Gleitkommazahlen (Floating point decimals) Für viele Arten von Berechnungen kommt man wegen der notwendigen Wertebereiche mit ganzen oder gebrochenen Zahlen nicht aus. Man verwendet dann eine andere Art der Notation, die Gleitkommazahlen, auch Fließkommazahlen oder Zahlen in wissenschaftlicher Schreibweise („scientific notation“). Der Begriff „Gleitkommazahl“ ist eigentlich falsch, da das Prinzip dieser Zahlen eben gerade der ist, dass der Dezimalpunkt an einer festen Stelle der Zahl steht. Der notwendige Skalierungsfaktor wird als getrennte Zahl (Exponent) angegeben. Gleitkommazahl = Mantisse * 2Exponent Vom IEEE (Institute of Electrical and Electronical Engineers) wurde Anfang der 80er-Jahre ein Normungsvorschlag für die Darstellung von und Rechnung mit Gleitkommazahlen erarbeitet, der von den modernen Prozessoren/Co-Prozessoren voll unterstützt wird. Als Zahlentypen sind definiert: single precision (einfache Genauigkeit) (32-Bit-Format)

31 30 22 0

8-Bit-Exponent 23-Bit-Mantisse

Vorzeichen Mantisse

double precision (doppelte Genauigkeit) (64-Bit-Format)

63 62 51 0

11-Bit-Exponent 52-Bit-Mantisse

Vorzeichen Mantisse

Die Mantissen sind dabei als positive Zahl und normiert (1.xxxxxx) definiert. Dabei wird die 1 vor dem Dezimalpunkt nicht mit abgespeichert. Die Exponenten werden als Charakteristik gespeichert und sind somit immer positiv. Der kleinste vorkommende Exponent ist 0. Die Rechnung mit Gleitkommazahlen ist deutlich aufwändiger als mit ganzen oder gebrochenen Zahlen. Es muss mit Mantisse und Exponent gerechnet werden, normalisiert und denormalisiert werden. Es sind darüber hinaus bestimmte Rundungsvorschriften einzuhalten. Durch die Verwendung fertiger Softwarepakete und Co-Prozessoren ist die Gleitkommarechnung aber für den Anwender weitgehend unkompliziert einsetzbar.




4. Weitere Zahlensysteme Die folgenden Zahlensysteme sind im Wesentlichen zur Vereinfachung und besseren Übersichtlichkeit der Dualzahlen gedacht.

4.1. Oktal Im oktalen Zahlensystem stehen alle Ziffern von 0 bis 7 zur Verfügung. Die Zahlenbasis ist somit 8 (daher oktal). Im Wesentlichen werden 3 Stellen des dualen Zahlensystems zu einer neuen Ziffer zusammengefasst. 1 = 18 2 = 28 3 = 38 4 = 48 5 = 58 6 = 68 7 = 78 8 = 108 9 = 118 10 = 128 = 1 x 81 + 2 x 80 = 1 x 8 + 2 x 1

4.2. Hexadezimal Das Hexadezimalsystem besitzt die Zahlenbasis 16. Leider stehen aus dem Dezimalsystem nur 10 Ziffern (0...9) zur Verfügung. Die restlichen Ziffern werden durch die Buchstaben A...F ersetzt. Als Zusatz für die Hexadezimalzahl wird der Buchstabe „H“ verwendet. In der Literatur wird auch sehr häufig die Schreibweise „&H...“ für Hexadezimalzahlen verwendet. In C werden diese Zahlen mit „0x“ am Anfang geschrieben (z. B. 0xC9 = C9H). 1D = 1H 2D = 2H 3D = 3H 4D = 4H 5D = 5H 6D = 6H 7D = 7H 8D = 8H 9D = 9H 10D = AH 11D = BH 12D = CH 13D = DH 14D = EH 15D = FH 16D = 10H 17D = 11H 18D = 12H = 1 x 161 + 2 x 160 = 1 x 16 + 2 x 1

Dieses Zahlensystem wird sehr häufig verwendet, da es 1 Byte mit genau 2 Zeichen darstellen kann (2 Ziffern zu je 4 Bit). 1 Byte kann damit 0H ... FFH annehmen.




4.3. Übersicht Zahlensysteme Die folgende Tabelle zeigt die Umrechnung der möglichen Dualzahlen eines Nibbles in den verschiedenen Zahlensystemen. Da bei BCD-Zahlen nur dezimale Ziffern umgesetzt werden, gibt es einen Bereich, in dem keine Werte verfügbar sind (nur mit einer zusätzlichen Stelle).

Dual BCD Oktal Dezimal Hexadezimal

0000 0000 0 0 0

0001 0001 1 1 1

0010 0010 2 2 2

0011 0011 3 3 3

0100 0100 4 4 4

0101 0101 5 5 5

0110 0110 6 6 6

0111 0111 7 7 7

1000 1000 10 8 8

1001 1001 11 9 9

1010 x 12 10 A

1011 x 13 11 B

1100 x 14 12 C

1101 x 15 13 D

1110 x 16 14 E

1111 x 17 15 F

4.4. Technische Umsetzung Binäre Zahlen lassen sich sehr leicht als Spannungszustände darstellen und verarbeiten. Dabei unterscheidet man zwischen "positiver Logik" und "negativer Logik". Die physikalische Umsetzung kann dabei sehr unterschiedlich sein. Es gibt zum Beispiel verschiedene Spannungswerte (s. u.) oder auch verschiedene Frequenzen (z. B. Frequency Shift Key). Die sogenannten Pegeldiagramme für TTL-Logikbausteine und für die Signale der seriellen Schnittstelle (RS-232-Pegel) werden in der anschließenden Abbildung dargestellt.

TTL-Pegeldiagramm (links; positive Logik) RS232-Schnittstellen-Pegel (rechts; negative Logik)




Es gibt jeweils definierte Spannungsbereiche, in denen ein Logikeingang sicher einen entsprechenden Logikzustand erkennt. Die Übergangsbereiche dazwischen müssen beim Umschalten schnell durchlaufen werden. Aufgrund der technischen Realisierung von Logikschaltungen zeigen beispielsweise die CMOS-Schaltkreise einen erhöhten Strom- und damit Leistungsbedarf, wenn die Eingangsspannung im undefinierten Zwischenbereich verweilt. Wegen ihres hohen Eingangswiderstands dürfen deshalb CMOS-Bauelemente nicht mit „offenen“ Eingängen eingesetzt werden, da sonst Leckströme die Eingangsspannung in den „verbotenen“ Bereich verschieben. Ein digitaler Computer kennt deshalb typischerweise nur zwei grundlegende Zustände (natürlich könnte man auch einen mit 10 bauen, aber er wäre störanfällig, teuer und überdimensional groß, das hat etwas mit der Physik der Schaltkreise zu tun). Die ganze Komplexität der Information wird ausschließlich über die Kombination großer Mengen von Bits dargestellt.

5. Boolesche Algebra / Binäre Logik Der Begriff der Booleschen Algebra geht auf den englischen Mathematiker George Boole (1815 - 1864) zurück. Sie geht davon aus, dass die Wahrheit nur zwei Zustände kennt, eine Aussage kann nur wahr oder nicht wahr (also falsch) sein. Wenn etwas falsch ist, kann es nicht wahr sein und umgekehrt. Nichts kann wahr und gleichzeitig falsch sein. „Es regnet“ und „es regnet nicht“ kann nicht gleichzeitig wahr sein. Deshalb gilt in dieser zweiwertigen Logik: Wenn etwas falsch ist, dann ist sein Gegenteil automatisch wahr. Das Gegenteil heißt übrigens „Negation“ (Verneinung) In der Logik kann man Aussagen verknüpfen und damit zu neuen Aussagen gelangen. Man nennt das „Schließen“ oder „Deduzieren“. Die einfachste logische Verknüpfung ist die sogenannte Implikation: „Wenn a wahr ist, ist auch b wahr“. Sie ist nicht zwingend umkehrbar: „Wenn ich ins Wasser falle, werde ich nass“ heißt nicht zwingend, dass ich zuvor ins Wasser gefallen war, wenn ich nass bin. Umkehrbar (aus a folgt b und aus b folgt a) ist die Äquivalenz, d.h. zwei Aussagen sind gleichwertig und sind zwingend entweder beide wahr oder beide falsch. Man kann auch zwei Aussagen miteinander verknüpfen. Mit der Behauptung „Die Aussage ‚C’ ist wahr, wenn die Aussage ‚A’ wahr ist und die Aussage ‚B’ wahr ist“, z.B. verknüpft man A und B derart, dass beide erfüllt sein müssen, damit auch C erfüllt ist.




5.1. Grundschaltungen

5.1.1. UND-Verknüpfung (Konjunktion) Eine grundlegende Verknüpfung (Operation) ist die UND (engl. AND)-Verknüpfung oder Konjunktion. Sie entspricht der Reihenschaltung zweier Schalter und besagt, dass der durch eine UND-Verknüpfung entstandene Ausdruck genau dann und nur dann wahr ist, wenn alle Teilausdrücke wahr sind. Notation: Y = X1 X2 alternativ: Y = X1 * X2 Hinweis: Beim Aufstellen einer Booleschen Gleichung sollte man jedoch darauf achten, dass konsequent nur eine Alternative verwendet wird.

Reihenschaltung von zwei Schaltern Funktionstabelle / Wahrheitstabelle

Schaltzeichen nach DIN 40900 / IEC Schaltzeichen nach ANSI / IEEE

Timing-Diagramm der UND-Verknüpfung Beispiel: Ein Aufzug fährt nur los (Y), wenn (X1) die Tür verriegelt ist und (X2) das Stockwerk gewählt ist. In einfacher festverdrahteter Technik kann man diese „UND“-Verknüpfung durch die Reihenschaltung von zwei Schaltern realisieren. Die Spalten X1 und X2 bezeichnen den Wahrheitsgehalt der Eingangsaussagen, ’1’ steht für wahr (eingeschaltet, oder HIGH), ’0’ für falsch (ausgeschaltet, oder LOW). Bei zwei Eingangsaussagen (Dualzahl mit zwei Stellen!) gibt es vier Eingangskombinationen. Die Spalte Y steht für den Ausgang der Verknüpfung. Bei der UND-Verknüpfung ist Y nur ’1’, wenn beide Eingänge ’1’ sind. Bei der schaltungstechnischen Realisierung einer logischen Verknüpfung spricht man von einem Gatter mit Eingängen und Ausgängen.

X1 X2 Y

5V 111

001

010

000

YX2X1

111

001

010

000

YX2X1

YX1

X2& Y

X2

X1Y

X1

X2& Y

X2

X1

X2

X1

Y

1

01

0

1

0

t




Der Ausgang ist nur eingeschaltet, wenn beide Eingänge eingeschaltet sind. So lassen sich auch sehr komplexe digitale Logikschaltungen grafisch darstellen. Die Schaltzeichen können übrigens alternativ genutzt werden, aber bitte einheitlich! Selbstverständlich gibt es auch UND-Verknüpfungen mit drei oder mehr Eingängen, das Schaltsymbol hat dann entsprechend mehr Eingangsleitungen, die Funktionstabelle mehr Spalten (und damit natürlich auch Zeilen). In der algebraischen Formulierung ist dies eine Sequenz von UND-Verknüpfungen (X1 * X2 * X3…). Ähnlich wie bei Addition oder Multiplikation gilt hier das Assoziativ-Gesetz.

5.1.2. Negation Eine weitere elementare Verknüpfung ist die Negation (engl. NOT), die grundsätzlich nur einen Operanden hat (Eingang). Der Ausgang nimmt den Wert falsch (’0’) an, wenn der Eingang den Wert wahr (’1’) hat und umgekehrt. Im Schalterbild entspricht dies einem Öffner. Notation:

Y = /X alternativ: 𝑌 = �̅�

Öffnerschaltung Funktionstabelle / Wahrheitstabelle


Timing-Diagramm Dies bedeutet also: Die Aussage Y ist genau dann wahr, wenn die Aussage X falsch ist und umgekehrt. Selbstverständlich heben sich doppelte Negationen auf: //a =a, //1 = 1 usw.

X Y

5V 0V 01

10

YX

01

10

YX

YX 1 YX

X

Y

1

0

1

0




Die Negation kann auch gekoppelt mit dem Schaltzeichen eines beliebigen Gatters verwendet werden, indem der Kreis (als Symbol der Negation) an einen Eingang oder Ausgang gesetzt wird. So entspricht die Hintereinanderschaltung von UND-Gatter und Negation einem NAND-Gatter (NOT-AND).

5.1.3. ODER-Gatter (OR, Disjunktion) Das ODER-Gatter (engl. OR) entspricht der Parallelschaltung zweier Schalter. Notation: Y = X1 v X2 alternativ: Y = X1 + X2

Parallelschaltung von zwei Schaltern Funktionstabelle / Wahrheitstabelle


Timing-Diagramm Ist einer der beiden Schalter betätigt, leuchtet die Lampe. Die Ausgangsvariable Y hat dann den logischen Wert 1, wenn mindestens eine Eingangsvariable Xi den logischen Wert 1 hat. Die Bezeichnung im Innern des durch DIN genormten Schaltzeichens leitet sich davon ab, dass mindestens ein Eingang eine logische 1 haben muss und damit die algebraische Summe der logischen Eingangswerte größer oder gleich 1 ist.

X1

X2 X2

X1Y

Y

1

0

1

0

1

05V 0V 111

101

110

000

YX2X1

111

101

110

000

YX2X1

X1

X2 X2

X1Y

Y

1

0

1

0

1

05V 0V

Y X1

X2

1 Y X2

X1




5.1.4. XOR/EXOR (Antivalenz) In unserem Sprachgebrauch unterscheidet man das alternative „Oder“, das durch das OR-Gatter realisiert wird und das exklusive „Oder“, das auch „entweder …oder…“ heißt. Schaltalgebraisch lautet die Definition: Die Ausgangsvariable Y hat dann den logischen Wert 1, wenn nur eine Eingangsvariable Xi den logischen Wert 1 hat. Beide Eingangssignale müssen dazu unterschiedlich sein: „Antivalenz“. Notation:

Y = X1 X2 alternativ: Y = X1 # X2

Schaltung Funktionstabelle / Wahrheitstabelle


Timing-Diagramm

X2

X1

Y

1

0

1

0

1

0

X1 X2

Y

5V 0V

X1 X2

011

101

110

000

YX2X1

011

101

110

000

YX2X1

YX1

X2=1 Y

X2

X1

X2

X1

Y

1

0

1

0

1

0

X1 X2

Y

5V 0V

X1 X2

Y X2

X1




5.2. Zusammengesetzte Schaltungen

5.2.1. NAND-Gatter Die Nacheinanderschaltung von AND und NOT ergibt das NAND-Gatter.

Notation:

____________

/( 1 2) 1 2Y X X Y X X ___________

/( 1 * 2) 1 * 2Y X X Y X X



Timing-Diagramm der UND-Verknüpfung

X2

X1Y

X2

X1

Y

1

0

1

0

1

0

X1

X2

Y

5V 0V 1

0

0

0

X1 * X2

011

101

110

100

/(X1 * X2)X2X1

1

0

0

0

X1 * X2

011

101

110

100

/(X1 * X2)X2X1

YX1

X2& Y

X2

X1Y

X1

X2& Y

X2

X1

X2

X1

Y

1

0

1

0

1

0

X1

X2

Y

5V 0V




5.2.2. NOR-Gatter Das NOR-Gatter entsteht aus einem ODER-Gatter mit Negation. Notation: Y = /(X1 v X2) Y = X1 v X2 Y = /(X1 + X2) Y = X1 + X2



Timing-Diagramm der UND-Verknüpfung

X2

X1

Y

1

0

1

0

1

0

X1 X2 Y

5V 0V 011

001

010

100

YX2X1

011

001

010

100

YX2X1

X2

X1

Y

1

0

1

0

1

0

X1 X2 Y

5V 0V

Y X1

X2

1 Y X2

X1




5.3. Rechenregeln

und sind eindeutige Verknüpfungen, die Elemente aus einer Menge

B={a, b,…,n} auf ein Element dieser Menge abbilden: , : B x B → B

Ist A eine Aussage der Booleschen Algebra, so auch A*, die man durch

Vertauschen von gegen und n gegen e erhält (Dualitätsprinzip)

Bezüglich der Grundoperationen und existiert je ein neutrales Element e

bzw. n, so dass gilt:

a e = a (e = 1) a n = a (n = 0)

Bezüglich der Grundoperationen und existiert je ein komplementäres

Element: __

a a n bzw. __

a a e

Ebenso gilt die Idempotenz: a a = a bzw. a a = a

Es gilt das Kommutativgesetz: (lat. commutare - vertauschen)

a b = b a bzw. a b = b a

1. Es gilt das Assoziativgesetz: (lat. associare - vereinigen, verbinden)

(a b) c = a (b c) bzw. (a b) c = a (b c)

2. Es gilt das Absorptionsgesetz: (lat. absorbere - saugen, absaugen, aufsaugen)

a (a b) = a bzw. a (a b) = a

3. Es gilt das Distributivgesetz: (lat. distribuere - verteilen)

a (b c) = (a b) (a c) bzw. a (b c) = (a b) (a c)

4. Die DeMorganschen Regeln erlauben das Vereinfachen von negierten Termen:

𝑎 ⋀ 𝑏̅̅ ̅̅ ̅̅ ̅ = �̅� ∨ �̅� bzw. 𝑎 ∨ 𝑏̅̅ ̅̅ ̅̅ ̅̅ = �̅� ⋀ �̅� Die DeMorganschen Regeln gelten auch für mehr als zwei logische Variable.

Daraus abgeleitet ergeben sich die folgenden Vereinfachungsregeln:

𝑎 ∧ 1 = 𝑎 𝑎 ∨ 1 = 1 𝑎 ⋅ 1 = 𝑎 𝑎 + 1 = 1

𝑎 ∧ 0 = 0 𝑎 ∨ 0 = 𝑎 𝑎 ⋅ 0 = 0 𝑎 + 0 = 𝑎

𝑎 ∨ (𝑎 ∧ 𝑏) = 𝑎 𝑎 + 𝑎𝑏 = 𝑎

𝑎 ∨ (�̅� ∧ 𝑏) = 𝑎 ∨ 𝑏 𝑎 + �̅�𝑏 = 𝑎 + 𝑏

(𝑎 ∧ 𝑏) ∨ (𝑎 ∧ �̅�) = 𝑎 𝑎𝑏 + 𝑎�̅� = 𝑎

𝑎 ∧ (𝑎 ∨ 𝑏) = 𝑎 𝑎(𝑎 + 𝑏) = 𝑎

𝑎 ∧ (�̅� ∨ 𝑏) = 𝑎𝑏 𝑎(�̅� + 𝑏) = 𝑎𝑏

(𝑎 ∨ 𝑏) ∧ (𝑎 ∨ �̅�) = 𝑎 (𝑎 + 𝑏)(𝑎 + 𝑏)̅̅ ̅̅ = 𝑎




5.4. Karnaugh-Veitch-Diagramm Das Karnaugh-Veitch-Diagramm, kurz KV-Diagramm, dient der übersichtlichen Darstellung und Vereinfachung Boolescher Funktionen in einen minimalen logischen Ausdruck. Es wurde 1952 von Edward W. Veitch entworfen und 1953 von Maurice Karnaugh zu seiner heutigen Form weiterentwickelt. Mittels eines KV-Diagramms lässt sich jede beliebige disjunktive Normalform (DNF) in einen minimalen disjunktiven logischen Ausdruck umwandeln. Der Vorteil gegenüber anderen Verfahren ist, dass der erzeugte Term (meist) minimal ist. Sollte der Term noch nicht minimal sein, ist eine weitere Vereinfachung durch Anwenden des Distributivgesetzes (Ausklammern) möglich. Das Umwandeln beginnt mit dem Erstellen einer Wahrheitstafel, aus der dann die DNF abgeleitet wird, die dann wiederum direkt in ein KV-Diagramm umgewandelt wird. Eine Formel der Aussagenlogik ist in disjunktiver Normalform, wenn sie eine Disjunktion von Konjunktionstermen ist. Ein Konjunktionsterm wird ausschließlich durch die konjunktive Verknüpfung von Literalen gebildet. Literale sind dabei nichtnegierte oder negierte Variablen.

Ein KV-Diagramm für n Eingangsvariablen hat 2n Felder. Das KV-Diagramm wird mit den Variablen an den Rändern beschriftet. Dabei kommt jede Variable in negierter und nicht-negierter Form vor. Die Zuordnung der Variablen zu den einzelnen Feldern kann dabei beliebig erfolgen, jedoch ist zu beachten, dass sich horizontal und vertikal benachbarte Felder nur in genau einer Variablen unterscheiden dürfen. Mit Hilfe der Wahrheitstabelle der zu optimierenden Funktion wird in die einzelnen Felder eine 1 eingetragen, wenn bei der entsprechenden Kombination in der Wahrheitstabelle eine 1 steht, andernfalls eine 0.

KV-Diagramm für 2

Variablen

KV-Diagramm für 3 Variablen

KV-Diagramm für 4 Variablen




Minterm-Methode Man versucht, möglichst viele horizontal und vertikal benachbarte Felder, die eine 1 enthalten (Minterme) zu rechteckigen zusammenhängenden Blöcken (Päckchen) zusammenzufassen. Als Blockgröße sind alle Potenzen von 2 erlaubt (1, 2, 4, 8, 16, ...). Dabei sind alle 1-Felder mit Blöcken zu erfassen.

Ein Block kann unter Umständen über den rechten bzw. unteren Rand des

Diagramms fortgesetzt werden. Die Felder ganz links und ganz rechts bzw. oben

und unten sind benachbart.

Von den ermittelten Blöcken sind so viele auszuwählen, dass alle 1-Felder

überdeckt werden. Bei vielen Schaltfunktionen sind das alle zusammengefassten

Blöcke, es kommt jedoch nicht selten vor, dass es Alternativen gibt. Dann besteht

bei gleich großen Blöcken die freie Auswahl, andernfalls sind die größeren Blöcke

zu wählen, da sie zu den kleineren (da stärker zusammengefassten) Termen

führen.

Die gebildeten und ausgewählten Blöcke/Päckchen wandelt man nun in

Konjunktionsterme um. Dabei werden Variablen innerhalb eines Blockes, die in

negierter und nicht negierter Form auftreten, weggelassen.

Diese UND-Verknüpfungen werden durch ODER-Verknüpfungen zusammengefasst

und ergeben eine disjunktive Minimalform.

Maxterm-Methode Die Maxterm-Methode unterscheidet sich von der Minterm-Methode lediglich in folgenden Punkten:

Statt Einsen werden Nullen zu Päckchen zusammengefasst.

Ein Päckchen bildet einen Disjunktionsterm (ODER-Verknüpfungen, statt eines

Konjunktionsterms).

Die Disjunktionsterme werden konjunktiv (mit UND) verknüpft.

Die Variablen werden zusätzlich einzeln negiert.




6. Entwicklung, Darstellung und Dokumentation von Programmen Ein gutes Programm lässt sich bereits an seiner Struktur erkennen:

Übersichtlichkeit: Einrückung bei Funktionsblöcken; linearer Ablauf des Programms; keine Programmteile, die über mehrere Seiten gehen

Änderungsfreundlichkeit: Blöcke mit gleicher Funktion werden zu einem Unterprogramm zusammengefasst; Kommentierung im Code

Erweiterbarkeit: Variablen und Übergabeparameter sind klar definiert und erklärt

Speichereffizienz: Nur Variablen definieren, die auch benötigt werden; Code optimieren

Um diese Punkte zu erreichen, empfiehlt es sich, Programme modular aufzubauen (Unterprogrammtechnik). Module sind:

einzeln testbar.

wiederverwendbar.

getrennt voneinander zu entwickeln.

Bei den Strukturen ist darauf zu achten, dass Blöcke (Unterprogramme) mit je einem Eingang und einem Ausgang entstehen. Meistens sind Programme heutzutage jedoch so komplex, dass es kaum möglich ist, sie umfassend vor der Auslieferung zu testen. Oft werden dann Beta-Tests verwendet oder Fehler bei Nachfolgeversionen bereinigt (Bug-Fixes, Service-Packs).




6.1. V-Modell Zur Beschreibung von Aktivitäten bei dem Entwurf und der Implementierung von Software-Applikationen sind verschiedene Modelle entwickelt worden (bspw. Wasserfall-Modell, Spiralmodell). Ein bekanntes Modell ist das sogenannte V-Modell, welches seinen Namen aus der Anordnung der verschiedenen Phasen hat:

Abbildung 0-1: V-Modell (Quelle: Wikipedia)

Als Ausgangspunkt wird der Analyse der Anforderungen an das zu entwickelnde (Software-) System gesehen. Hier wird zunächst gesammelt, welche Anforderungen – das können Funktionen als auch Eigenschaften (z.B. Reaktionsgeschwindigkeit, Lokalisierbarkeit etc.) sein – und welche Randbedingungen (bspw. Zielgruppe) vorhanden sind. Die Anforderungen werden dann priorisiert. Hier wird bspw. festgelegt, welche Anforderungen zu welcher Produktversion umgesetzt sein müssen und welche Anforderungen optional sind. Alternativ kann das V-Modell auch mit den folgenden Aktionen beschrieben werden:

Problemstellung (Pflichtenheft)

Grobstrukturierung (Lastenheft)

Feinstruktur

Module entwickeln und testen

Zusammenbinden der Module

Schnittstellen testen

Gesamtprogramm testen

Dokumentation




6.2. Scrum-Methode [Quelle: Wikipedia]

Die Erfahrung hat gezeigt, dass viele Entwicklungsprojekte zu komplex sind, um in einen vollumfänglichen Plan gefasst werden zu können. Ein wesentlicher Teil der Anforderungen und der Lösungsansätze ist zu Beginn unklar. Dadurch kann auch kein konkretes Lastenheft erstellt werden. Deshalb werden Zwischenergebnisse oder Inkremente definiert. Dadurch lassen sich die fehlenden Anforderungen und Lösungstechniken effizienter finden als durch eine abstrakte Klärungsphase. Scrum verkörpert die Werte der agilen Software-Entwicklung, die 2001 im agilen Manifest von Ken Schwaber, Jeff Sutherland und anderen formuliert wurden:

1. Menschen und Interaktionen sind wichtiger als Prozesse und Werkzeuge. 2. Funktionierende Software ist wichtiger als umfassende Dokumentation. 3. Zusammenarbeit mit dem Kunden ist wichtiger als die ursprünglich formulierten

Leistungsbeschreibungen. 4. Eingehen auf Veränderungen ist wichtiger als Festhalten an einem Plan.

Scrum besteht nur aus wenigen Regeln. Diese Regeln definieren fünf Aktivitäten, drei Artefakte und drei Rollen, die den Kern von Scrum ausmachen. Die Umsetzung der Aktivitäten, Artefakte und Rollen sind nicht konkretisiert, um eine individuelle Ausgestaltung zuzulassen. Der zentrale Entwicklungsschritt innerhalb der Scrum-Methode ist der Sprint. Ein Sprint ist ein Arbeitsabschnitt, in dem ein Inkrement eines Produktes erstellt wird. Er beginnt mit einem Sprint Planning und endet mit Sprint Review und Sprint-Retrospektive. Sprints folgen unmittelbar aufeinander. Während eines Sprints sind keine Änderungen erlaubt, die das Sprintziel beeinflussen.

Von Scrum_process.svg: Lakeworksderivative work: Sebastian Wallroth (talk) - Scrum_process.svg, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=10772971

Task




Aktivitäten 1 - Sprint Planning

Festlegung des Was (Product Owner und Entwicklungsteam gemeinsam):

Produkteigenschaften (Einträge im Product Backlog), die im nächsten Sprint entwickelt werden sollen, werden festgelegt

Kriterien werden definiert, die am Ende des Sprints entscheiden, ob eine Eigenschaft erfüllt ist (Definition of Done)

Festlegung des Wie (Entwicklungsteam)

Planung der Aufgaben (Tasks)

Erstellung des Sprint Backlog 2 - Daily Scrum

Der Daily Scrum ist ein kurzes, tägliches Meeting, das zum Informationsaustausch innerhalb des Entwicklungsteams dient. Scrum Master und Product Owner stehen für Fragen zur Verfügung. 3 - Sprint Review

Das Sprint Review steht am Ende des Sprints. Hier überprüft das Scrum Team das Inkrement. Das Entwicklungsteam präsentiert die Ergebnisse dem Product Owner und den Stakeholdern und es wird überprüft, ob das zu Beginn gesteckte Ziel erreicht wurde. Das Scrum Team und die Stakeholder besprechen die Ergebnisse und die weiteren Schritte. 4 - Sprint Retrospektive

Das Scrum Team diskutiert über seine Arbeitsweise während des vergangenen Sprints, um sie für die Zukunft zu verbessern. Hindernisse und gute Praktiken werden dokumentiert, Verbesserungsmaßnahmen für den nächsten Sprint eingeplant. 5 - Product Backlog Refinement

Das Product Backlog Refinement ist ein fortlaufender Prozess, bei dem der Product Owner und das Entwicklungsteam gemeinsam das Product Backlog weiterentwickeln. Hierzu gehören:

Ordnen der Einträge

Löschen von Einträgen, die nicht mehr wichtig sind

Hinzufügen von neuen Einträgen

Detaillieren von Einträgen

Zusammenfassen von Einträgen

Schätzen von Einträgen

Planung von Releases Für die Gestaltung des Produkts und des Product Backlogs können Stakeholder wertvolle Informationen liefern, indem sie dem Scrum Team erklären, wie sie sich eine Funktionalität im alltäglichen Gebrauch wünschen. Daher gibt es meistens auch Product-Backlog-Refinement-Treffen zusammen mit ausgewählten Stakeholdern.




Artefakte Ein Artefakt ist das Erzeugnis, das Zwischen- oder Endergebnis einer Handlung (lat. von artis factum "das von Hand Gemachte"). In der Scrum-Methode sind es die grundlegenden Dokumente. 1 - Product Backlog

Das Product Backlog ist eine geordnete Auflistung der Anforderungen an das Produkt. Das Product Backlog ist dynamisch und wird ständig weiterentwickelt. Alle Arbeit, die das Entwicklungsteam erledigt, muss ihren Ursprung im Product Backlog haben. Der Product Owner ist für die Pflege des Product Backlogs verantwortlich. Er verantwortet die Reihenfolge bzw. Priorisierung der Einträge. 2 - Sprint Backlog

Das Sprint Backlog ist der aktuelle Plan der für einen Sprint zu erledigenden Aufgaben. Es umfasst die Product Backlog-Einträge, die für den Sprint ausgewählt wurden, und die dafür nötigen Aufgaben (z.B. Entwicklung, Test, Dokumentation). Das Sprint Backlog wird laufend aktualisiert. Dies dient zur Übersicht des aktuellen Bearbeitungsstands. 3 - Product Increment

Das Inkrement ist die Summe aller Product-Backlog-Einträge, die während der bisherigen Sprints fertiggestellt wurden. Am Ende eines Sprints muss das neue Inkrement in einem nutzbaren Zustand sein und der Definition of Done entsprechen.

Rollen 1 - Product Owner

ist für den Erfolg des Produkts verantwortlich

definiert die Produkteigenschaften

erstellt Product Backlog und aktualisiert es im Product Backlog Refinement

priorisiert die Einträge im Product Backlog

stimmt die Entwicklungsergebnisse mit den Stakeholdern ab 2 - Entwicklungsteam

erstellt die geforderten Produktfunktionalitäten

setzt die Einträge aus dem Product Backlog in Tasks für einen Sprint um 3 - Scrum Master

überprüft deren Einhaltung

moderiert die Treffen von Product Owner und Entwicklungsteam

kümmert sich um die Behebung von Störungen und Hindernissen Stakeholder Die Stakeholder sind eigentlich außerhalb des Scrum-Prozesses. Hierzu gehören Kunden, Anwender und das Management.




6.3. ADAM & EVA Häufig ist für Beginner die Umsetzung des V-Modells oder der Scrum-Methode zu aufwendig oder zu kompliziert. Diese Modelle sind auch immer auf Entwicklungsteams und komplexere Projekte zugeschnitten. ADAM & EVA ist ein einfacher Ansatz, um kleine Einzelprojekte zu erstellen. Sie verdeutlicht die grundlegenden Schritte bei der Erstellung eines Programms.

ADAM

A Aufgabe analysieren Was ist die Aufgabenstellung? Was sind die Randbedingungen?

D Datenelemente definieren Welche Daten sind gegeben? Welche Daten als Ergebnisse sind gefordert? Welche Datentypen sollten verwendet werden? Welche Hilfsvariablen sind notwendig?

A Algorithmus erstellen Ablauf festlegen: Welche Strukturen (Schleifen, Verzweigungen) sollen verwendet werden? Welche Aufgaben werden als Unterprogramme (Funktionen) realisiert?

M Machen Erst nachdem Daten und Algorithmen klar sind, wird das Programm erstellt

Für das "Machen" wird dann EVA verwendet. Sie ist die Grundstruktur eines Programms oder einer Funktion.

EVA

E Eingabe Eingabe der Daten (über Tastatur, als übergebene Programmparameter oder fest definiert)

V Verarbeitung Der definierte Algorithmus wird verwendet, um das Ergebnis aus den gegebenen Daten zu berechnen.

A Ausgabe Die Daten werden als Ergebnis ausgegeben, gespeichert oder an andere Funktionen übergeben.

Die Abschnitte "Eingabe" und "Ausgabe" können in der Regel sehr schnell und einfach programmiert werden. Trotzdem kommt es immer wieder zu Fehlern, weil die Typen der Datenelemente nicht sauber umgesetzt werden. Die "Verarbeitung" kann nur gelingen, wenn der Algorithmus klar und korrekt ist. Im Idealfall kann der Code direkt aus dem Algorithmus abgeleitet werden. Auch hier ist wieder auf die Datentypen zu achten. Für jedes Programm ist ein Test unverzichtbar. Dabei ist darauf zu achten, dass möglichst viele der möglichen Programmpfade durchlaufen werden (Verzweigungen, Unterprogramme).




6.4. Strukturen

1966 verfassten Böhm und Jacopini das sogenannte Strukturtheorem mit dem Struktur einer Softwareapplikation leicht dargestellt werden kann: Um den Kontrollfluss eines Programms zu beschreiben reichen drei Arten von Strukturblöcken aus (Kontrollstrukturen eines Programms):

- Sequenz

- Fallunterscheidung ( Selektion )

- Schleife ( Iteration ) Zwei Jahre nach dem Strukturtheorem verfasste Dijkstra die Regeln der strukturierten Programmierung:

1. Ein Strukturblock hat genau einen Eingang und genau einen Ausgang

2. Aneinanderreihen und Ineinanderschachteln von Strukturblöcken ergibt wieder einen Strukturblock

3. Jeder Strukturblock muss mindestens einmal erreicht und verlassen werden

4. Elementare Strukturblöcke sind die Zuweisung (a := b) oder Unterprogrammaufrufe (Makroblöcke)

Die bekannteste Konsequenz dieses Prinzips ist die Vermeidung oder – abhängig von der Programmiersprache – der eingeschränkte und standardisierte Einsatz der Sprunganweisung, des GOTO. Das Ergebnis der häufigen Verwendung dieser Anweisungen wird häufig abfällig als Spaghetticode bezeichnet. Durch die konsequente Implementierung von Teilprogrammen und von Kontrollstrukturen vermeiden strukturierte Programme Codewiederholungen, was Vorteile bei der Suche von Programmfehlern mit sich bringt, die Programme kürzer und übersichtlicher macht und daher die Wartung von Software vereinfacht. Strukturierte Programmierung ist heute in fast allen Bereichen, in denen professionell Software entwickelt wird, eine Selbstverständlichkeit. Die neueren Programmierparadigmen wie generative Programmierung, aspektorientierte Programmierung oder objektorientierte Programmierung bauen auf der strukturierten Programmierung auf und erweitern oder ergänzen diese.




6.5. Programmablaufplan (Flussdiagramm) Der Programmablaufplan (PAP), auch als Flussdiagramm oder Programmstrukturplan bezeichnet, kann bei der Planung des Programmablaufs verwendet werden. Die verwendeten Symbole sind nach DIN 66001 genormt und werden in den folgenden Abschnitten kurz erläutert:

Symbol/Kontrollstruktur Erläuterung

Operation Bei einer Operation erfolgt eine Verarbeitung der Daten ganz allgemein. Eine Innenbeschriftung ordnet die Operation eindeutig zu.

Unterprogrammaufruf / Funktionsaufruf Der Programmierer sollte eine eindeutige Innenbeschriftung wählen. Der Programmablaufplan einer Funktion wird an anderer Stelle erstellt.

Ein-/Ausgabe von Daten

Verzweigung (Selektion) Hier wird eine Bedingung überprüft und je nach Ergebnis wird der Programmablauf entsprechend fortgesetzt.

Übergang oder Verbindungsstelle

Grenzstelle / Terminator Zum korrekten Starten oder Stoppen verwendet man dieses Symbol.

Ablauflinien Sie verbinden die verschiedenen anderen Symbole miteinander.

Anfangs-Schleifenbegrenzung für zählergesteuerte Wiederholungen.

Ende-Schleifenbegrenzung für zählergesteuerte Wiederholungen.




Weitere, wesentlich seltener verwendete Symbole des Programmablaufplans findet man unter der DIN 66001.

Abbildung 0-3 Zwei Beispiele eines Programmablaufplans (Zählschleife)

Als Vorteile eines Programmablaufplans kann man auf jeden Fall die Übersichtlichkeit, die Lesbarkeit sowie die Überprüfbarkeit und Korrektheit der Terminierung nennen. Außerdem kann man sehr leicht schrittweise Verbesserungen bzw. Verfeinerungen des Programmablaufs erreichen, da ja jede Kontrollstruktur eine Black Box ist. Allerdings hat das Verfahren des Programmablaufplans auch einige Nachteile: Schachtelstrukturen sind nicht gut zu erkennen und eine strukturierte Programmierung wird durch einen PAP nicht sichergestellt.




6.6. Struktogramm nach Nassi-Shneidermann I. Nassi und B. Shneidermann entwickelten in den Jahren 1972/73 einen Diagrammtyp, der den Entwurf eines strukturierten Programms sehr vereinfacht hat. Das Nassi-Shneidermann-Diagramm, auch Struktogramm genannt, ist nach DIN 66261 standardisiert und umfasst folgende Struktogramme:

Struktogramm Erläuterung

Linearer Ablauf (Sequenz) Jede Anweisung wird in einen rechteckigen Strukturblock geschrieben. Die Strukturblöcke werden nacheinander von oben nach unten durchlaufen. Leere Strukturblöcke sind nur in Verzweigungen zulässig

Zweifache Auswahl (alternative Verarbeitung) Nur wenn die Bedingung zutreffend (wahr) ist, wird der Anweisungsblock 1 durchlaufen. Ein Anweisungsblock kann aus einer oder mehreren Anweisungen bestehen. Trifft die Bedingung nicht zu (falsch), wird der Anweisungsblock 2 durchlaufen. Austritt unten nach Abarbeitung des jeweiligen Anweisungsblocks. Es ist auch möglich, dass Anweisungsblock 1 oder Anweisungsblock 2 leer ist.

Mehrfache Verzweigung (Fallauswahl) Besonders bei mehr als drei zu prüfenden Bedingungen geeignet. Der Wert von "Variable" kann bedingt auf Gleichheit wie auch auf Bereiche (größer/kleiner bei Zahlen) geprüft werden und der entsprechend zutreffende "Fall" mit dem zugehörigen Anweisungsblock wird durchlaufen. Eine Fallauswahl kann manchmal in eine Mehrfachauswahl umgewandelt werden. Eine Fallauswahl kann immer in mehrere Mehrfachauswahlen aufgeteilt werden. Häufig wird ein Anweisungsblock für den Default-Fall gewählt.

Wiederholung mit vorausgehender Bedingungsprüfung Block wird solange wiederholt, wie Bedingungsprüfung wahr ergibt. Erste Bedingungsprüfung vor erster Blockbearbeitung. Null Block-Bearbeitungen möglich.




Wiederholung mit nachfolgender Bedingungsprüfung Block wird solange wiederholt, wie Bedingungsprüfung wahr ergibt. Erste Bedingungsprüfung nach erster Blockbearbeitung, d.h. mindestens eine Block-Bearbeitungen.

Wiederholung ohne Bedingungsprüfung Schleife wird nie verlassen. Kann nur verlassen werden mit Hilfe einer Abbruchanweisung.

Abbruchanweisung Der Aussprung (break) stellt die Beendigung eines Programmteils dar und sollte nicht als das verstanden werden, was Nassi und Shneiderman mit den Struktogrammen eigentlich vermeiden wollten: Die Sprunganweisung.

Verweis auf Unterverarbeitung Symbolik zum Aufruf eines Unterprogramms bzw. Funktion. Nach Durchlauf dieser wird genau zu der aufrufenden Stelle zurückgesprungen und der nächstfolgende Strukturblock durchlaufen. Kein DIN 66261-Symbol.

Eine Ineinanderschachtelung der unterschiedlichen Struktogramme kann in Nassi-Shneidermann-Diagrammen erfolgen. Alle Elemente eines Nassi-Shneidermann-Diagramms sind rechteckig, d. h. das gesamte Nassi-Shneidermann-Diagramm ist genau so breit wie sein breitestes Element.




7. ASCII-Code, ANSI-Code, Unicode

7.1. ASCII-Zeichensatz (American Standard Code of Information Interchange)

Neben Zahlen können mit diesem Zeichensatz auch Buchstaben und Sonderzeichen verarbeitet werden. Allerdings fehlen Umlaute und andere länderspezifische Buchstaben.

Der ASCII-Code umfasst nur 7 Bit, also 128 Zeichen.

0 NUL 32 [space] 64 @ 96 ` 1 SOH 33 ! 65 A 97 a 2 STX 34 " 66 B 98 b 3 ETX 35 # 67 C 99 c 4 EOT 36 $ 68 D 100 d 5 ENQ 37 % 69 E 101 e 6 ACK 38 & 70 F 102 f 7 BEL 39 ' 71 G 103 g 8 BS 40 ( 72 H 104 h 9 HT 41 ) 73 I 105 i

10 LF 42 * 74 J 106 j 11 VT 43 + 75 K 107 k 12 FF 44 , 76 L 108 l 13 CR 45 - 77 M 109 m 14 SO 46 . 78 N 110 n 15 SI 47 / 79 O 111 o 16 DLE 48 0 80 P 112 p 17 DC1 49 1 81 Q 113 q 18 DC2 50 2 82 R 114 r 19 DC3 51 3 83 S 115 s 20 DC4 52 4 84 T 116 t 21 NAK 53 5 85 U 117 u 22 SYN 54 6 86 V 118 v 23 ETB 55 7 87 W 119 w 24 CAN 56 8 88 X 120 x 25 EM 57 9 89 Y 121 y 26 SUB 58 : 90 Z 122 z 27 ESC 59 ; 91 [ 123 { 28 FS 60 < 92 \ 124 | 29 GS 61 = 93 ] 125 } 30 RS 62 > 94 ^ 126 ~ 31 US 63 ? 95 _ 127 DEL

NUL Null DLE data link escape SOH start of heading DC1 device control 1 STX start of text DC2 device control 2 ETX end of text DC3 device control 3 EOT end of transmission DC4 device control 4 ENQ Enquiry NAK negative acknowledgement ACK positive acknowledgement SYN synchronous idle BEL bell (hörbar) ETB end of transmission block BS Backspace CAN cancel HT horizontal tabulation EM end of medium LF line feed SUB substitute VT vertical tabulation ESC escape FF form feed FS file separator CR carriage return GS group separator SO shift out RS record separator SI shift in US unit separator DEL delete




7.2. ANSI-Zeichensatz Der erste Teil des ANSI-Zeichensatzes entspricht bis auf die Sonderzeichen dem ASCII-Zeichensatz.

0 * 32 [space] 64 @ 96 ` 1 * 33 ! 65 A 97 a 2 * 34 " 66 B 98 b 3 * 35 # 67 C 99 c 4 * 36 $ 68 D 100 d 5 * 37 % 69 E 101 e 6 * 38 & 70 F 102 f 7 * 39 ' 71 G 103 g 8 * * 40 ( 72 H 104 h 9 * * 41 ) 73 I 105 i

10 * * 42 * 74 J 106 j 11 * 43 + 75 K 107 k 12 * 44 , 76 L 108 l 13 * * 45 - 77 M 109 m 14 * 46 . 78 N 110 n 15 * 47 / 79 O 111 o 16 * 48 0 80 P 112 p 17 * 49 1 81 Q 113 q 18 * 50 2 82 R 114 r 19 * 51 3 83 S 115 s 20 * 52 4 84 T 116 t 21 * 53 5 85 U 117 u 22 * 54 6 86 V 118 v 23 * 55 7 87 W 119 w 24 * 56 8 88 X 120 x 25 * 57 9 89 Y 121 y 26 * 58 : 90 Z 122 z 27 * 59 ; 91 [ 123 { 28 * 60 < 92 \ 124 | 29 * 61 = 93 ] 125 } 30 * 62 > 94 ^ 126 ~ 31 * 63 ? 95 _ 127 *




Ab Code 128 wird für Zeichen unter WINDOWS und dem traditionellen DOS eine unter-schiedliche Zeichensatztabelle verwendet. In der Regel haben sogar Drucker wieder eine andere Belegung. Dies hängt hauptsächlich mit den länderspezifischen Zeichensätzen zusammen. Üblicherweise wird in Deutschland die Codepage 1252 (Latin 1) verwendet. Dieser Zeichensatz wurde auch für die unten stehende Tabelle verwendet. Im Einzelfall ist deshalb zu prüfen, welche Sonderzeichen tatsächlich auch angezeigt/gedruckt werden.

Win DOS Win DOS Win DOS Win DOS 128 * Ç 160 [space] á 192 À + 224 à Ó 129 * ü 161 ¡ í 193 Á - 225 á ß 130 * é 162 ¢ ó 194 Â - 226 â Ô 131 * â 163 £ ú 195 Ã + 227 ã Ò 132 * ä 164 ¤ ñ 196 Ä - 228 ä õ 133 * à 165 ¥ Ñ 197 Å + 229 å Õ 134 * å 166 ¦ ª 198 Æ ã 230 æ µ 135 * ç 167 § º 199 Ç Ã 231 ç þ 136 * ê 168 ¨ ¿ 200 È + 232 è Þ 137 * ë 169 © ® 201 É + 233 é Ú 138 * è 170 ª ¬ 202 Ê - 234 ê Û 139 * ï 171 « ½ 203 Ë - 235 ë Ù 140 * î 172 ¼ 204 Ì ¦ 236 ì ý 141 * ì 173 ¡ 205 Í - 237 í Ý 142 * Ä 174 ® « 206 Î + 238 î ¯ 143 * Å 175 ¯ » 207 Ï ¤ 239 ï ´ 144 * É 176 ° ¦ 208 Ð ð 240 ð 145 * æ 177 ± ¦ 209 Ñ Ð 241 ñ ± 146 * Æ 178 ² ¦ 210 Ò Ê 242 ò = 147 * ô 179 ³ ¦ 211 Ó Ë 243 ó ¾ 148 * ö 180 ´ ¦ 212 Ô È 244 ô ¶ 149 * ò 181 µ Á 213 Õ i 245 õ § 150 * û 182 Â 214 Ö Í 246 ö ÷ 151 * ù 183 · À 215 × Î 247 ÷ ¸ 152 * ÿ 184 ¸ © 216 Ø Ï 248 ø ° 153 * Ö 185 ¹ ¦ 217 Ù + 249 ù ¨ 154 * Ü 186 º ¦ 218 Ú + 250 ú · 155 * ø 187 » + 219 Û ¦ 251 û ¹ 156 * £ 188 ¼ + 220 Ü _ 252 ü ³ 157 * Ø 189 ½ ¢ 221 Ý ¦ 253 ý ² 158 * × 190 ¾ ¥ 222 Þ Ì 254 þ ¦ 159 * ƒ 191 ¿ + 223 ß ¯ 255 ÿ

* Diese Zeichen werden von Microsoft Windows nicht unterstützt. ** Die Werte 8, 9, 10 und 13 werden für backspace, tab, linefeed, und carriage return

genutzt. Sie haben keine graphische Entsprechung, können aber die Formatierung der Ausgabe beeinflussen.




7.3. Unicode Unicode ist ein Zeichenverschlüsselungsschema, das 2 Byte für jedes Zeichen verwendet. Die International Standards Organization (ISO) ordnet fast jedem Zeichen und jedem Symbol in jeder Sprache (und zusätzlich einigen zur späteren Verwendung reservierten Leerzeichen) eine Zahl von 0 bis 65.535 (216 - 1) zu. Unter allen 32-Bit-Versionen von Windows wird Unicode vom Component Object Model (COM), der Basis für OLE- und ActiveX-Techniken, verwendet. Unicode wird von Windows NT vollständig unterstützt. Obwohl Unicode wie DBCS aus Doppel-Byte-Zeichen besteht, sind ihre Verschlüsselungsschemata völlig verschieden. Beispiele für Zeichen-Codes: Die folgende Abbildung zeigt ein Beispiel für den Zeichen-Code in jedem Zeichensatz. Beachten Sie die unterschiedlichen Codes in jedem Byte der Doppel-Byte-Zeichen.

Documents

Grundlagen - s46fa84e08dd04cbd.jimcontent.com · 1 GByte = 1073741824 Byte Um im folgenden binäre (duale) Zahlen von dezimalen unterscheiden zu können, werden binäre Zahlen immer