Monthly Archives: September 2012

Linkliste 00000010

Zeit für eine neue Linkliste. Dann kann ich mich darum drücken, mit den Lektürenotizen für dieses Buch anzufangen.

Birte hat freundlicherweise eine umfangreiche Liste aufgestellt mit Links zu verschiedenen Lern-Tools und sie kommentiert.
(Danke @birtona!)

Ich habe einen wunderschönen neuen Laptop, ein Thinkpad E135. Kam ohne Betriebssystem, dafür mit UEFI statt Bios. Die Installation von Debian war gelinde ausgedrückt problematisch. Aber zufällig war gerade Erlehmann in der Nähe, sprich auf meinem Sofa, und konnte mir bei der Installation behilflich sein. Das kostete uns auch nur alle Nerven und ca. zwei Tage. Unter Anderem, weil noch keine Lösung dafür aufzufinden war. Die gibt es jetzt aber unter oben stehendem Link.
(Danke Erlehmann!)

Eines dieser wirklich wirklich wichtigen Begriffe, die seit Langem immer wieder auftauchen, die ich aber erst im Zuge meiner FLP-Genese verstehen lernte. Und seitdem ist mir die Brisanz des Themas auch endlich klar. Die technischen Grundlagen wurden in dem Buch, das ich gerade gelesen hatte, sehr schön verständlich erläutert. Ich glaube, so langsam sollten wir uns auch darum kümmern, dass die Netzneutralität nicht als geflügelter Begriff in der Blogger-Hacker-Buffet-Szene verbleibt, sondern mindestens von jedem Telekom-Kunden einzuordnen ist.
Worum geht es? “Netzneutralität bezeichnet die wertneutrale Datenübertragung im Internet” sagt Wikipedia. Dabei geht es eigentlich um nichts weniger als die Zukunft des Internets wie wir es kennen und gerne beibehalten würden. Die Netzneutralität als Eigenschaft ist allerdings durch bestimmte Entwicklungen und von ökonomischen Interessen bedroht.
Der Wikipedia-Artikel bietet wie immer ein gutes Basis-Wissen, sollte aber vor allem als Grundlage dienen, um die garantiert noch anstehenden Diskussionen darüber einordnen, verstehen und weiterentwickeln zu können. Also Augen und Ohren auf!

Schöner, zugänglicher Talk über die Kommunikationspraxen auf github und was wir daraus lernen können.
(Danke Marc!)

Hey, wie cool! Ich wurde dort eingeladen und hab festgestellt, dass sie dort ein Learn ‘n Tell eingerichtet haben, beruhend auf dem Konzept vom großartigen Hack ‘n Tell. Man kann also einen kleinen Vortrag halten darüber, was man gerade gelernt hat, womit man Probleme hat, kann Fragen stellen…super Idee! Ich bin gespannt. Ich würd mich das ja nicht trauen. Oder doch. Mal schauen.

Onkel bringt Nichte Programmieren bei. Er beschreibt, wie er dabei vorgeht und welche Fortschritte sie macht.

“People tend to complain about how there are not enough women in software. Its true, there are not enough of them. That is why I’m doing my part to add one more to the ranks. Teach the kids in your family to program.”

Pretty awesome.

Eine Open Source Plattform für Spielereien mit digitalen und analogen Ausgängen. Das Programm wird auf einer Arduino-Entwicklungs-Umgebung geschrieben und auf den Arduino Mikrocontroller (da, rechts das Bild) gespielt. Ich durfte schon ein bisschen damit rumprobieren mit LED Lämpchen und Lautsprecher.  Ich habe aber noch Großes vor! Was dann auch eine erste praktische Anwendung meiner C-Kenntnisse sein dürfte. I’ll keep you updated.
Mehr Infos auf Wikipedia.
( Danke Linus! )

 

Weitere interessante Links gerne in die Kommentare.

Fun as in Function

Mein Vater sagte zu mir immer: “Funktionier doch mal!”

Das hat mir im Leben nie weitergeholfen, aber ich verstehe jetzt, dass er darauf hinweisen wollte, dass in C viele Funktionen bereits in der Bibliothek vorliegen, aber es gleichzeitig auch die Möglichkeit gibt, selber Funktionen zu schreiben.
Das hatten wir damals auch bei Assembler schon angewandt. Mit “call” konnte eine Funktion, die irgendwo im Code stand, aufgerufen werden.

Wenn eine Funktion geschrieben wird, ist sie genauso aufgebaut wie die “main”-Funktion. Also: Name, Klammern mit Platz für die Parameter, Anweisungsblock in geschweiften Klammern inkl. Deklaration der Variablen. Ein Beispiel:

 #include <stdio.h>

raeum_dein_zimmer_auf () 
{
       int deadline;
       for (deadline=1; deadline<=13; deadline=deadline+1)
              printf("\nIch hab dir jetzt tausendmal gesagt, du sollst
                        dein Zimmer aufräumen!\n");
}

main () 
{ 
....

Und so weiter, und so fort.
Die Variable “deadline” kann ich auch in den anderen Funktionen verwenden, was ich nicht tun würde. Aber für solche häufig verwendeten Variablen wie “x” oder “y” ist das durchaus hilfreich. Der Name der Funktion darf aus Buchstaben, Zahlen und Unterstrichen bestehen und maximal 31 Zeichen lang sein. Der Lesbarkeit und Einheitlichkeit halber sollten Wörter durch Unterstrich getrennt sein, nicht mit einem Unterstrich beginnen und möglichst keine Großbuchstaben beinhalten.

Die Funktion oben ist womöglich gut geeignet, wenn ein gestörtes Kommunikationsverhältnis vorliegt und wenn die Prämisse gilt, dass das Zimmer bis 13 Uhr aufgeräumt sein soll. Aber eigentlich sollten Funktionen flexibler gestaltet werden für andere Anwendungen. Dafür gibt es die Funktionsparameter. Ein Beispiel:

linie(int zeichen, int laenge)
{
        int i;
        for(i=1; i<laenge; i++)                           /*(1)/
                printf("%c", zeichen);
}

main ()
{
        int zeichen, wieoft;
        printf("\nIch schreibe jetzt 10 Fragezeichen.\n");
        linie('?', 10);
        printf("\nWelches Zeichen: ");
        zeichen=getchar();                                
        printf("Wie oft schreiben: ");
        scanf("%i", &wieoft);                             /*(2)/
        printf("\n");
        linie(zeichen, wieoft);                           /*(3)/
        printf("\n");
}

Neu ist zunächst der Ausdruck i++ in der for-Schleife (1). Der bedeutet aber dasselbe wie i+1. Das haben wir bisher verwendet, um dem Programm zu sagen, dass es die Variable um 1 inkrementieren, also erhöhen soll. Sieht anscheinend geiler as in professioneller aus und spart mehr oder weniger wertvolle Lebenszeit.

/*Nachtrag: Falsch, i++ ist nicht dasselbe wie i+1, sondern wie i=i+1,
danke erlehmann! Geht übrigens auch mit i– (dekrementieren)/

Die Parameter in der ersten Zeile sind als int definiert. Die Werte für die Variablen werden in der main-Funktion durch die Eingabe der User bestimmt (2). Bei (3) werden sie als int-Werte an die Funktion übergeben (obwohl eine Zeichenkonstante (char) eingelesen wurde, diese kann aber von C auch als Code des zugehörigen Zeichens interpretiert werden, also für “?” eine “63″).

Ein drittes Beispiel soll die eigentlich wichtigste Funktionen-Funktion darstellen: Die Rückgabe von Werten. Wäre ja schade drum, wenn das Programm für mich 1+1 ausrechnet, ich aber nicht an das Ergebnis komme.

#include <stdio.h>

int max(int a, int b)
{
        if (a > b)
                return a;                     /*(1)/
        else 
                return b;
}

main ()
{
        int zahl1, zahl2, ja1, ja2;
        printf("\nBitte geben Sie eine Zahl ein: ");
        scanf("%i", &zahl1);
         printf("\nBitte geben Sie eine Zahl ein: ");
        scanf("%i", &zahl2);
        printf("\nTrommelwirbel!\n");
        printf("\nBitte irgendeine irrelevante Zahl eingeben: ");
        scanf("%i", &ja1);
        printf("\nWarte... warte... schon aufgeregt?\n");
        printf("\nBitte noch irgendeine Zahl eingeben: ");
        scanf("%i", &ja2);
        printf("\nDie Zahl %i ist groesser!\n",          
                max(zahl1,zahl2));                         /*(2)/
}

Die max-Funktion gibt den größeren von zwei int-Werten aus. Das tut sie aufgrund der return-Anweisung (1). Diese beendet zum Einen die Schleife, zum Anderen sorgt sie dafür, dass der Wert, der ausgegeben wurde an die aufrufende Stelle (2) geliefert wird.
Das passiert in der letzten Zeile dieses Programms, das sich mit schlecht.s um den vorletzten Platz auf dem Sinnvolle-Programme-Ranking streitet. Dem Platzhalter %i wird also der Wert zugewiesen, den return von max aus bekommen hat.

Bleibt zu bemerken, dass man aufpassen sollte, dass die Rückgabetypen der Funktionen rechtzeitig definiert werden. Standardgemäß geht der Compiler davon aus, dass der Rückgabewert vom Typ int ist. Blöd, wenn er nicht int ist, sondern bspw. double. Wenn die Funktion also aufgerufen wird und erst später die nicht-int-Typen definiert werden, ist das Programm im Arsch.  Am Leichtesten lässt sich das natürlich bewerkstelligen, indem die Funktion auf jeden Fall vor dem ersten Aufrufen definiert wird. Das geht ganz einfach, indem man bspw. am Anfang des Programms, noch vor der main-Funktion schreibt:

double func (double, double);

Was irgendwie nach einem generischen Gabba-Song-Titel aussieht, ist ein Funktionsprototyp. In den Klammern müssen keine Variablen-Bezeichnungen stehen, sondern nur die Typen. Außerdem wird die Klammer mit einem Semikolon beendet. Semikolonsemikolonsemikolon. Nicht vergessen!

Hier, nochmal, zum Üben: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

In meinem Chat, den ich hier aus Gründen nochmal ausschreibe:

##fionalerntprogrammieren auf freenode
(join!)

gab es dann heute morgen auch nochmal eine schöne Diskussion darüber, wie sinnvoll die Längenbregrenzung für Funktionsnamen ist.
Eingangs wusste ich einfach nicht, woher die Begrenzung auf 31 Zeichen kommt. Scheint mir “historische Gründe” zu haben. Darauf wurde aber nicht wirklich geantwortet, stattdessen wurde sich darüber gestritten, dass unsinnige Bezeichnungen auch mit weniger als 31 Zeichen möglich sind, Beispiele: ffhvfdhfddchfdvzffbfdf() oder penis2() .
Einige waren der Meinung, dass eindeutige Bezeichnungen auch mal so richtig schön lang sein können und sollten, andere, darunter ich, finden es einfach nur hässlich und unhandlich, wenn Funktionsnamen zu lang sind.

Aber vielleicht hat die Eine oder der Andere noch etwas weltbewegendes dazu zu sagen, dann können wir den Streit in den Kommentaren fortsetzen. Und wer darauf besteht, dass penis(2) eine sinnvolle Bezeichnung ist, wird gelöscht.

Zum Mitschreiben

Ich durfte gestern auf dem Kindergeburtstag der Mädchenmannschaft spontan einen kleinen Workshop geben, danke dafür! Der Workshop hieß “Programming alright, cool, but where to start?” und es ging um die ersten konkreten Schritte für Menschen, die sich dazu entschlossen haben, Programmieren zu lernen. Und der Workshop war auf Englisch, weil meine Notizen auf Englisch waren.
Es war ein Riesen Spaß! Und überhaupt war es eine lustige, intime und dankbare Veranstaltung und Lotterleben saß auch als Einzige mit einem Bier im Publikum. Die Mischung aus ProgrammiererInnen und Nicht-ProgrammiererInnen ist immer recht fruchtbar für die anschließenden Diskussionen und Fragestellungen.
Ich freu mich auch sehr darauf, am 02. Oktober bei der OpenTechSchool in Berlin im co-up sprechen zu dürfen, für das Beginner’s Meet-Up. Wäre natürlich geil, wenn Lotterleben wieder mit Bier im Publikum sitzt und ich darüber hinaus ein paar von euch kennenlernen darf.

Aber zum eigentlichen Sinn des Posts. Weil ich so eine krasse H4ckerin bin, habe ich es nicht hinbekommen, meinen Laptop an den Beamer anzuschließen, daher hatte ich den ZuhörerInnen versprochen, nochmal alle Links plus kleine Zusammenfassung hier zu sammeln.  Die Links und Tips, die während des Vortrages gesammelt wurden, kann ich auch noch gleich einbauen. Merci beaucoup!

“Programming alright, but where to start?”

  • Who am I anyways?

-  Fiona, @fotografiona, student of European Ethnology in Berlin
-  started to learn programming in January, with Assembler, moved over to C and will proceed to Python soon

  • Why programming?

- convenience – indivualize your interaction with technology e.g. by programming your own tools or websites that suit your needs
- curiosity
- emancipation from production preconfigurations ( imagine: you can adapt your technical devices independently from the capitalistic interests of the producers)

  • Where to start

Find out with which programming language you want to start. There are low-level and high-level languages that differ due to their level of abstraction from the actual processes in your machine.
Low-level languages like Assembler offer a basic knowledge for understanding the computer, but yield few short-term successes, you’ll rather understand than produce code
High-level languages like Python might be more accessible and will grant you small results in a short while
In the end you’ll have to decide for yourself and people will tell you that your decision sucks anyways, others will become a fan of yours

  • How to start

Online Courses
Code Academy – Program that started in January with a JavaScript course, that sends you little lessons once a week. Quite convenient but not many people I know stuck to it. Apparently they have improved a lot though, so check out the Python course!
Khan Academy – simple, big variety, seems like fun, colorful

Books
C – Programmieren von Anfang – small steps, I’m a huge fan and having fun with it
The Cookbook Series - Not sure whether suitable for beginners, but very much     focused on practical challenges
- Try to find E-books, there are gazillions of free E-Books for almost every programming language, I prefer books on paper, though for the “disadvantage” of having to type every program

Programming Project
e.g. programming a Wiki, a Website, a diary applications, whatsoever
That is definitely a jump in at the deep end but the necessity of your desired tool might keep up your motivation to continue until the end. The main challenge is to find answers for your numerous questions on the Internet. I strongly recommend you though to find one or two programming friends that accompany your project.

Groups
Get together in groups! Bildet Lernbanden!
- different expertises benefit all members of the group, even the experienced might deepen or expand their knowledge
- set common goals
- check out the Rails Girls , they organize workshops on Ruby on Rails in different cities throughout the world. Might be a good starter for networking or finding others you can get together in groups with

Somebody asked a question on the Internet!
Keep in my mind that there is plenty of support either on Forums or in IRC Channels.
Feel free to join ##fionalerntprogrammieren on freenode as well for staying in contact or ask your questions on my blog. At least 50% of the readers are nostalgic experts and might be able to help answering the questions of the beginners.

What do you need?
Technically speaking – an editor. Otherwise some stamina for the frustrating phases that are guaranteed to come. Some friends that you can call at night, when your program just won’t compile can come in handy as well. But above all some fascination for the magic beneath your interface. An entire new universe, filled with answers and questions both is about to open up for you! Good luck with that and stay in

contact.

@fotografiona
##fionalerntprogrammieren (freenode)
> This blog <

Ich kann jetzt alleine Schleifen programmieren…

aber keine Schleifen binden. Mittlerweile haben schon so viele gute und hilfsbereite Freunde völlig entsetzt darauf reagiert. Und dann haben sie mir gezeigt, wie man “natürlich” Schleifen bindet. Allerdings zeigten sie mir alle eine andere Schleifen-Technik. Und ich habe alle schon wieder vergessen. Ich bin also weiterhin abhängig von lieben Menschen, die mir unterwegs die Schuhe zubinden, damit ich nicht in meiner Fahrradkette hängenbleibe. Ich bin seit Jahren kein Single gewesen. Das hat aber nichts miteinander zu tun.

In Kapitel 5 geht es jedenfalls um Schleifen. Schleifen! Selbst in meinem Lieblingschat ##fionalerntprogrammieren (ja, nur echt und untergeordnet mit zwei Rauten!) wurde positiv darauf reagiert, ohne dass ein einziges Mal das Wort “Dum” fiel. Schleifen scheinen The Big Shit zu sein im Programmierbusiness. Eigentlich sind ja auch Schleifen die Steilvorlage für das, was Computer uns bieten können: Unheimlich blöde Aufgaben übernehmen, das aber rasend schnell. Mit einer Schleife kann ich einen Teil des Programms immer wieder ausführen lassen. Menschen könnten das zwar auch, aber langsamer und wir werden depressiv bei solchen Dingen. Und da Maschinen zum Glück über keine Rechte verfügen, kann ich sie dazu verpflichten, immer wieder neu zu berechnen, wo sich gerade mein Mauszeiger befindet. Nicht auszudenken, wie scheiße das für einen Menschen wäre.

(Was rede ich hier eigentlich für einen Quatsch? Es ist 2:55, zurück zum Thema.)

Ich lernte drei verschiedene Schleifentypen kennen: Die For-, die Do- und die While-Schleife. For arbeitet mit einer Zählvariablen, die hochzählt, wie oft der Programmteil wiederholt werden soll. Bei der While-Schleife gibt es dagegen eine Bedingung, die entscheidet, wie oft der Teil durchlaufen wird. Bei der Do-Schleife befindet sich diese Bedingung am Ende des zu wiederholenden Programmteils.

Ein Beispiel für eine for-Schleife bietet das folgende GANZ ALLEINE geschriebene Programm:

#include <stdio.h>
main ()
{
        int x, n, gesamt=0;
        printf("\n\tADD THE ODDS\n");
        printf("\nDieses Programm rechnet alle ungeraden Zahlen bis n zusammen\n");
        printf("\nBitte Wert für n eingeben: \n");
        scanf("%i", &n);
        for (x=0; x<=n; x=x+1)
        {
                if ((x%2))
                gesamt = gesamt + x;
                else 
                        continue;
        }
        printf("\nDie Summe der ungeraden Zahlen bis n beträgt %i\n", gesamt);
}

Das Programm berechnet die Summe aller ungeraden Zahlen bis zur Zahl n, die ich selber bestimmen kann. Per scanf wird n eingelesen, bspw.. eine 5. Nein, ich bin faul, lieber eine 3.
Dann kommt die for-Anweisung.

for (x=0; x<=n; x=x+1)

In der Klammer steht als erstes eine Zuweisung. x soll zu Beginn auf Null gesetzt sein. Danach folgt die Bedingung. Wenn x kleiner/gleich n ist, wird die Schleife durchlaufen. Als letztes wird bestimmt, dass x nach jedem Schleifendurchlauf mit 1 addiert wird. Das muss nicht 1 sein, manchmal ergibt es auch Sinn, um 2 zu erhöhen. Dann folgt die geschweifte Klammer, nach welcher der Programmteil steht, der jetzt wiederholt wird.

Die if-Konstruktion

 if ((x%2))

prüft, ob als Divisionsrest 1 oder 0 vorliegt (x%2). Wenn x durch 2 teilbar ist, handelt es sich um eine gerade Zahl und es steht eine 0 in der Klammer. 0 ist logisch ein “Falsch”. Also ist die Bedingung logisch nicht erfüllt und zur Variablen “gesamt” wird die keine Zahl hinzugezählt. Stattdessen wird zur if else gesprungen und durch “continue” springt das Programm zurück zum Anfang der Schleife. Eins ist der zweite Wert der für x eingesetzt wird, weil x um Eins erhöhrt wurde, wie es im dritten Teil der For-Bedingung bestimmt wurde. Bei x=1 würde in der Klammer eine 1stehen, eine logisch “wahre” Aussage. Die darunter stehende Anweisung wird also ausgeführt, und es wird x (also 1) zur Variablen “gesamt” hinzuaddiert.
Machen wir mit x=2 weiter. x wurde wieder um eins erhöht. Wenn x nun gleich 2 ist, steht in der Klammer wieder eine Null, es wird also nichts zur Variablen “gesamt” hinzugefügt. Ist x=3, ist die Aussage (x%3) wiederum wahr und 3 wird zu gesamt hinzugerechnet.
Jetzt wird x wieder um eins erhöht und ist bei 4. Das widerspricht allerdings der Bedingung, dass x<=3 sein soll. Also wird die Schleife nicht nochmal ausgeführt und es wird hinter der geschweiften, schließenden Klammer weitergemacht.
Jetzt erfolgt ein noch eine Print-Anweisung, welche den Wert von “gesamt” ausgibt und das Programm ist beendet.

Die While-Schleife kann mit einem ganz einfachen Programm erklärt werden:

#include <stdio.h>
main ()
{
        int zahl;
        printf("Dieses Programm berechnet das Quadrat von n\n");
        printf("\nBitte Zahl eingeben ('0' fuer Lassdas!): ");
        scanf("%i", &zahl);
        while(zahl != 0)        
        {
                printf("%3i hoch 2 = %4i\n", zahl, zahl*zahl);
                printf("\nBitte Zahl eingeben ('0' fuer Ende): ");
                scanf("%i", &zahl);
        }
}

Das Programm berechnet das Quadrat von n, bzw. vom Wert, der “zahl” zugeordnet wurde. Für “zahl” kann immer wieder ein neuer Wert eingesetzt werden, bis eine Null eingegeben wird. Dann wird die Schleife nicht mehr ausgeführt. Denn die Bedingung, die nach while in der Klammer steht, lautet: Solange “zahl” ungleich Null ist, wird der Teil in den geschweiften Klammern wiederholt.Wenn nicht, dann nicht!

So weit, so gut wie möglich erklärt. Aber ich glaube, ich werde die Schleifen noch ein paar Mal nachprogrammieren und selber anwenden müssen, um sie wirklich verstanden zu haben und geschickt einsetzen zu können.

In der Hoffnung, dass der Post nicht allzu verwirrend war wünsche ich eine gute Nacht und bitte um Nachsicht. Es ist das Ergebnis von viel Kaffee, einem Bier, einem Bernd, der in meinem Zimmer lauert (er will mir seinen Namen nicht verraten) und zwei Tütensuppen, für die ich mich sehr schäme.

With Endlosschleifen-Love:

FLP

Und jetzt, Fiona…LOGIK

Kleiner Zwischenstand meines Vorhabens, mir in der verbliebenen Zeit so viel C wie möglich reinzuprügeln: Ich komm grad vom See.

Was soll ich sagen, es war angeblich der letzte Tag des Jahres an dem es noch mal so richtig warm war. Trotzdem hab ich übers Wochenende ein paar Fortschritte gemacht. Nicht etwa weil ich krank und somit eh an mein Zuhause gefesselt war, sondern weil ich eine eiserne Disziplin an den Tag legte um Kapitel 4 – “Entscheidungen treffen” abzuschließen. Jawohl.

In Abschnitt 4.4 lernte ich Bedingungen logisch miteinander zu verknüpfen. Mit dem heteronormativen Ansatz “Wenn es Sonntag regnet und wenn meine Freundin kommt…” brachte mir Erlenkötter bei, was eine UND-Verknüpfung ist. (Oder hat er damit etwa subtil versucht, auch bi- oder homosexuelle Leser und Leserinnen anzusprechen, dieser Fuchs…?)
Jedenfalls – das Resultat ist nur dann wahr, wenn beide Aussagen wahr sind. Und das Zeichen für eine UND-Verknüpfung ist &&.
Also: if (Regen && Freundin kommt), dann…
Auflösung: if (wahr && wahr), dann …. ja, was dann. Keine Ahnung, hängen wir rum und gucken Tatort oder so.

Die ODER-Verknüpfung ist da sozusagen etwas gnädiger. Als Beispiel: “Wenn der Tatort wieder im Filmförderungsstil ist oder wenn der Regisseur mal wieder glaubt, mit hässlichen Farbstichen ganz besondern kreativ zu sein, dann”. Es reicht, wenn eine der beiden Teilaussagen wahr ist, um die Aussage insgesamt wahr zu machen. Das Zeichen dafür ist ||.
Also: if (Filmförderung || Farbstich), dann…
Auflösung: if [Filmförderung || Farbstich), dann...
Auflösung: if (Filmförderung || kein Farbstich), dann...
Auflösung: if (kein Filmförderung || Farbstich), dann...schalte ich die Scheiße aus und programmiere stattdessen was.
Alle drei Varianten machen die Aussage wahr.

So weit, so simpel ausgedrückt. Es gibt allerdings noch ein paar weitere Verknüpfungen, z.B. das logische NICHT, das NAND, das NOR, das XNOR(haha, ich mag das Wort XNOR) und die Implikation. Es scheint mir, als würden vorerst UND und ODER reichen, ich habe die anderen Verknüpfungen aber durchaus gelernt und verstanden. Solltet ihr auch tun.

Wie wird das nun angewandt? Ganz einfach, wenn ich einen Teil des Codes nur dann ausführen möchte, wenn eine oder beide Teilaussagen wahr sind. Das habe ich bspw. in der folgenden Übung umgesetzt: "Schreiben Sie ein Programm, das eine Temperatur abfragt und danach abzeigt, ob Wasser verdampft, flüssig bleibt oder gefriert."
Das Programm muss also einen Wert einlesen, um dann auszugeben, welchen Zustand Wasser bei dieser Temperatur hat. Bei der ersten if-Bedingung ist ein ODER untergebracht. Nämlich für die Spezialisten, die dann irgendeinen trolligen Wert eingeben, der entweder unter dem totalen Nullpunkt liegt oder einfach ein bisschen hoch ist. Wobei das meiner totalen Willkür unterlag. Für diese Konstruktion sage ich also

if (Wert viel zu tief ODER Wert viel zu hoch), dann sag dem User, dass er spinnt.
if (temp < -272 || temp >= 1000)
Wenn nun einer der beiden Fälle eintritt, wird der dazugehörige Befehl printf ausgeführt. Wenn allerdings keiner der beiden Fälle eintritt und die User brav einen vernünftigen Wert eingeben, wird mit der nächsten else-if-Konstruktion weitergemacht. An diese ist wiederum eine Bedingung geknüpft, die wahr sein muss, damit der dazugehörige printf-Befehl ausgeführt wird. Ist das wieder nicht der Fall, wird im Programm zur nächsten if-else Konstruktion gesprungen. Usw. Hier Le Code:

#include <stdio.h>
main ()
{
        double temp;
        printf("\nDieses Programm ermittelt den Aggregatzustand von Wasser");
        printf("\nBitte Temperatur eingeben, z.B. 100.00: ");
        scanf("%lf", &temp);
        if (temp < -272 || temp >= 1000)
                printf("\nDu uebertreibst ein bisschen...\n");
        else if (temp <= 0.0)
                printf("\nDas Wasser ist gefroren, sozusagen EISEIS\n");
        else if (temp < 100.00)
                printf("\nDas Wasser ist fluessig, also Wasser\n");
        else if (temp >= 100.00)
                printf("\nDas Wasser ist gasfoermig, quasi Wasserdampf\n");
}

Selbstverständlich ist das Programm weitestgehend nutzlos, das tut dem Lernerfolg aber keinen Abbruch. Allerdings gab mir jemand den Tip, dass ich doch das Programm so umschreiben könnte, dass es etwas flexibler wäre. Also um genau zu sein schrieb er dies:

[2012-09-10 14:04:19] <_MrTux_> Fotografiona: next step: Wasser und Grenztemperaturen durch Variable ersetzen, damit man das Programm leicht für andere Stoffe umschreiben kann. :)
[2012-09-10 14:04:52] <Fotografiona> _MrTux_: true story
[2012-09-10 14:05:21] <benni_b> oder den Druck noch mit einberechnen.
[2012-09-10 14:05:49] <benni_b> so kann man dann immer weiter machen und irgendwann sitzt man auf dem mars und muss felsen zerballern.
[2012-09-10 14:06:03] <Fotografiona> _MrTux_: also variable, so dass der/die UserInnen per eingabe die Variablen bestimmt?
[2012-09-10 14:07:43] <_MrTux_> so weit habe ich noch gar nicht gedacht.
[2012-09-10 14:07:58] <fengor> erstmal nur hartkodiert
[2012-09-10 14:08:19] <fengor> hat den vorteil, das wenn du das programm fuer andere stoffe anpassen willst die temperaturen nicht mehr an x stellen sondern nru noch an einer aendern musst
[2012-09-10 14:08:45] <_MrTux_> Du betrachtest das Programm sehr von der Nutzerseite – das solltest Du auch nicht vergessen. Softwaretechnisch machst Du das Programm flexibler, wenn Du diese Variablen einführst. Davon sieht der Nutzer erstmal nichts, aber Dein Code wird flexibler und wiederverwendbarer.
[2012-09-10 14:08:50] <_MrTux_> Genau.
[2012-09-10 14:09:41] <Fotografiona> also im sinne von – ProgrammiererIn will das programm für einen anderen Stoff verwenden und muss dann möglichst wenig oim Code verändern um es anzupassen?
[2012-09-10 14:09:55] <_MrTux_> in Nachfolgeschritten könntest Du aus Deinem Programm eine Funktion machen, die Stoffart und Grenztemperaturen entgegennimmt und die entsprechende Ausgabe macht. Und dann könntest Du überlegen, den Nutzer z.B. erstmal den Stoff auswählen lassen.
[2012-09-10 14:09:59] <_MrTux_> ja
[2012-09-10 14:10:01] <Fotografiona> okay
[2012-09-10 14:10:15] <Fotografiona> ist das sowas wie ein Teil der Code-Etikette?
[2012-09-10 14:10:34] <Fotografiona> ein Programm flexibel machen im Sinne von  den Aufwand minimieren um es anzupassen?
[2012-09-10 14:13:15] <_MrTux_> Ja, sozusagen. Du willst ja nach Möglichkeit nichts doppelt programmieren, d.h. den Code so wiederverwendbar wie möglich gestalten.
[2012-09-10 14:13:43] <Fotografiona> okay
[2012-09-10 14:14:21] <_MrTux_> Im Design heißt das, dass Du die Invarianten und Varianten in Deinem Algorithmus suchst und in einer Funktion dann nur die entsprechenden Invarianten unterbringst. Im einfachsten Fall also z.B. Werte, die nicht im Sinne des Algorithmus fest sind, in Variablen zu legen.
[2012-09-10 14:17:46] <_MrTux_> Weiter würde ich in Deinem Programm auch nicht gehen. Wenn Du die Wiederverwendbarkeit im Hinterkopf behältst, fällt Dir mit der Zeit und Erfahrung von selbst auf, worauf man das Prinzip anwenden könnte.

 

Diese Tips und weitere gab man mir im neuen QUALITÄTSCHANNEL #fionalerntprogrammieren auf freenode. Danke nochmal an die Beteiligten! Wem das jetzt nichts sagt: Dabei handelt es sich um einen Chatroom, den ihr entweder über http://webchat.freenode.net/ erreichen könnt oder indem ihr euch einen IRC-Client runterladet. Ich benutze meist irssi oder Smuxi. Fragen dazu am Besten in die Kommentare. Jedenfalls können wir ab jetzt kollektiv dort lauern, ich bin die meiste Zeit online und dort erreichbar. Und ein paar freundliche Menschen lauern dort ebenfalls und haben mir heute bereits mehrmals Fragen beantworten können. Überhaupt lohnt es sich, zu wissen was IRC ist und sich darin zurechtfinden zu können. IRC ist zwar ein furchtbar altes Chat-Protokoll, wird aber weiterhin verwendet für die verschiedensten Zwecke. Bspw. zur internen Firmen-Kommunikation, um live über Podcasts diskutieren zu können, um eine lose Gruppe von Freaks zu vernetzenn, oder wie hier, um eine Themen-bezogene Plattform für Austausch, Vernetzung, Wissenszirkulation etc. zu schaffen. Aber ich nutze diese schlampige Erklärung mal, um mich zu motivieren, einen vernünftigen Guide für die IRC-Nutzung zu schreiben.
So. Genug gespeedbloggt, ich halte euch auf dem Laufenden.
Macht’s gut, ich gehe jetzt nicht-programmieren.

 

Folgen

Erhalte jeden neuen Beitrag in deinen Posteingang.

Schließe dich 105 Followern an