Mit diesem Bild (auf “weiterlesen” klicken) von heute Nachmittag lasse ich den vorletzten Tag vor den Weihnachtsferien ausklingen und wünsche ein frohes Fest.

Bis dann!

Ich hab in diesem Blog, glaube ich zumindest gerade, noch nicht weiter darüber gesprochen, aber ich war und bin Teil der studentischen Selbstverwaltung an der Universität Wuppertal.

Ich war in der letzten Legislaturperiode Mitglied des Studierendenparlaments (StuPa) und Vorsitzender des Allgemeinen Studierendenausschusses (AStA). In dieser Legislaturperiode bin ich Referent für Presse- und Öffentlichkeitsarbeit des AStA.

Als Mitglied der Liste “Freibeuter und Grüne” war ich nicht direkt für oder im Namen der Piratenpartei in diesen Gremien vertreten, aber ich hab immer versucht die Ziele und/oder Prinzipien, die ich damit verbinde, zu vertreten oder als Richtlinie zu nutzen.

Da, vielleicht auch aufgrund des Erfolges in Berlin, noch mehr Hochschulgruppen entstehen, dachte ich, ich könnte einige Sachen aufschreiben, die mir zur Arbeit in der studentischen Selbstverwaltung einfallen.

Vergesst “Links” und “Rechts”

Uns Piraten haftet bisher der große Vorteil an, dass wir bisher nicht so recht in das übliche Links-Rechts-Schema passen.
Was einige als Nachteil betrachten, habe ich immer als Vorteil gesehen.
Wir müssen uns keine gedanklichen Beschränkungen auferlegen sondern können, unabhängig von überholten Schemata, die besten Lösungen für die Probleme der Studierenden finden.

“Links” und “Rechts” das sind auch Begriffe, die wir als Piraten nicht nutzen sollten. Sie stehen für eine überholte und engstirnige Sichtweise, bei der man versucht alles, möglichst einfach, in irgendwelche Schubladen zu stecken.
Moderner Politik, die wir mit der Piratenpartei betreiben wollen, steht das nicht gut zu Gesicht.

Der AStA in dem ich Vorsitzender war galt übrigens als linker, der in dem ich jetzt tätig bin als rechter AStA. Wie bereits gesagt, finde ich diese Einteilung nicht besonders sinnvoll. Auch im rechten AStA gibt es Ideen die, dem klassischen Schema nach, als “linke Ideen” eingeordnet werden könnten.

Nun gut, lasst euch einfach nicht auf diese Links-Rechts-Sache ein.

Miteinander statt Gegeneinander

Wichtig für eure Arbeit ist, zumindest habe ich es so empfunden, dass ihr die Universität(sleitung) nicht als Feind anseht. Die haben naturbedingt auch kein Interesse daran, es sich mit den Studierenden zu verscherzen, auch wenn das Handeln manchmal so wirken mag.

Es ist wichtig, die Bedeutung des Zusammenspiels zwischen studentischer Selbstverwaltung und Universität(sleitung) zu verstehen. Die studentische Selbstverwaltung übernimmt einen Teil der Aufgaben, die sonst keiner übernehmen kann. So stellt es sich zumindest bei uns dar.

Die Universität kann schwerlich Parties für die Studierenden veranstalten, die studentische Selbstverwaltung hingegen kann dies. Ähnlich sieht es teilweise mit Beratungsangeboten, Veranstaltungen verschiedenster Arten uvm. aus. Der AStA unterliegt nicht den Beschränkungen, die der Universität auferlegt sind, damit sind wir flexibler in unseren Handlungen.

Als Piraten sollten wir uns zum einen dieses Umstandes bewusst sein und zum anderen an der Verständigung zwischen Studierenden und Universität arbeiten. Auf lange Sicht gesehen profitieren, meiner Meinung nach, die Studierenden von einer guten Beziehung zwischen den leitenden Stellen der Universität und den gewählten Vertretern der Studierendenschaft.

Vorsicht vor Jugendorganisationen

Nehmt euch in Acht vor Mitgliedern der Jugendorganisationen der anderen Parteien.

Einige von ihnen sind stärker darauf bedacht, einer Parteilinie zu folgen, als für ein gemeinsames Ziel einzustehen. Das kann ohne Zweifel zu Problemen führen und ihr solltet das nicht aus den Augen verlieren. Das mag sich bei “Koalitionsgesprächen” noch als recht harmlos oder unbedeutend darstellen, aber wenn es darum gehen sollte unbeliebte Entscheidungen zu treffen, dann ist das nicht mehr wirklich lustig.

Wenn einer wichtigen Entscheidung dann im Wege steht, dass sich das im Parteibuch schlecht machen könnte, dann solltet ihr euch was einfallen lassen. Die Leute absägen oder sowas. ;-D

Das sind die drei wichtigsten Sachen, die mir gerade einfielen.

Wenn ihr konkrete Fragen habt, dann immer her damit. Entweder hier als Kommentar oder per E-Mail.

In 1:25 Stunden behandeln wir alle momentan (industriell) eingesetzten Druckverfahren.

Das ist zwar erstmal nur ein Schnelldurchlauf, aber wir planen für jedes Verfahren eine eigene Folge zu machen und da sowohl auf Allgemeines aber auch auf Besonderheiten einzugehen.

Idealerweise schaffen wir so für Auszubildende der Druck- und Medienbranche kurzweilige Folgen, mit denen man sich im Bereich der Druckverfahren weiterbilden kann. Das wäre zumindest wünschenswert.

Besonders freuen wir uns hier natürlich auch über Feedback oder Wünsche “von außen”. Die nehmen wir gerne auf und werden Sie soweit wie möglich umsetzen.

Ja, es ist fast schon zu spät dafür, aber noch hab ich ungefähr eine Stunde Zeit das zu sagen. Das muss mal zählen.

Und ich hab auch lange nichts mehr geschrieben. Wie so oft. Trotzdem ist natürlich (mal wieder) einiges passiert, dass ich im Folgenden kurz zusammenfassen möchte.

Ich will auch gleich die Gelegenheit nutzen und etwas auf das Kommende herausblicken. :-)

Zum Beispiel ist “passiert”, dass ich Mitte des Monats bei Heidelberg war. Heidelberger Druckmaschinen in Heidelberg bzw. Wiesloch (Produktionsstätte). Über die Vorlesung zu Offset-Drucksystemen wird meist eine Fahrt dorthin angeboten und krankheitsbedingt konnte ich als Nachrücker doch mit. Pech für die Dame die erkrankt ausfiel, Glück für mich.
Und ich muss sagen, das war sehr interessant. Natürlich darf man nicht vergessen, dass es sich dabei in gewisser Weise um eine Werbeveranstaltung für Heidelberg handelt, aber trotzdem gab es eine Menge zu sehen und zu lernen.
Neben unserem Besuch in der Print Media Academy und dem nur einen Steinwurf entfernten Showroom waren wir auch in der Produktionsstätte Wiesloch.
In Wiesloch werden beispielsweise Plattenbelichter und Druckmaschinen montiert. Das sind zumindest die Bereiche, die wir uns dort schwerpunktmäßig angesehen haben. Sehr beeindruckend die Sache.
In Heidelberg selbst haben wir uns verschiedene Druckvorführungen angeschaut, einen Überblick über Prinect erhalten und schwerpunktmäßig über Farbwerke und Verpackungsdruck (ein Markt den Heidelberg gerade verstärkt für sich erschließt) gesprochen.
Die Verpflegung durch Heidelberg war herausragend, die Unterbringung in der Jugendherberge Heidelberg war auch absolut in Ordnung und untadelig. Die Organisation der ganzen Fahrt an sich war sehr gut, vielen Dank an den Kommilitonen der sich darum gekümmert hat (und hier vermutlich mitliest). Auch die Fahrt verlief trotz des Winterwetters gut.

Winterwetter bringt mich dann auch zum nächsten Punkt.
In Wuppertal war in den letzten Tagen/Wochen wetterbedingt meist ein Riesenchaos.
Die Busse fuhren, wenn sie überhaupt fuhren, unregelmäßig. Meist aber auch nicht den ganzen Tag. Der Busverkehr wurde meist gegen Mittag eingestellt, weil man nicht mehr gegen den “Jahrhundertwinter” ankam.

Kurzer Einwurf:
Die Sache mit dem “Jahrhundertwinter” ist übrigens interessant. Erstmal Finanzmittel für die Räumdienste kürzen, und wenn es dann tatsächlich winterlich wird (so mit Schnee und Eis und so), dann behauptet man es sei ein Jahrhundertwinter und man käme deshalb nicht dagegen an. Dazu habe ich noch was Interessantes auf den NachDenkSeiten gefunden.

Zurück zu Wuppertal.
Auch da wird natürlich an allen Ecken und Enden gespart um den Busbahnhof bald für zig Millionen auf Jahre hin in eine Großbaustelle verwandeln zu können. Da muss natürlich auch beim Winterdienst gespart werden.
Ärgerlich für die Studenten die mühevoll mit der Bahn anreisen um dann festzustellen, dass sie dann noch komplett den Berg zu Fuß herauf müssen.
Wir Wohnheimbewohner sparen uns da gut die Hälfte der Strecke, aber es ist trotzdem einfach nervig durch Tiefschnee und über schlecht geräumte Gehwege zum Campus hoch zu müssen.
Die Informationspolitik bezüglich der Verkehrssituation ist von Seiten der Wuppertaler Stadtwerke übrigens grausam. Auf deren Internetseite steht dann, dass der Verkehr eingeschränkt sei und es zu Verzögerungen kommen könnte und das davon folgende Straßen besonders betroffen seien. Dann folgt eine Liste von Straßen von denen ich in aller Regel noch nie gehört habe.
Anstatt zu sagen, dass Linie X und Y nicht fahren und Linie Z in Richtung soundso nur bis Haltestelle alpha fährt, nein, die macht man diese komische Sache mit den Straßen.
Abhilfe schaffen hier die fleißigen Twitterer, die unter dem Hashtag #talbus versuchen sich selbst und alle anderen zu informieren. wuppertal_bus ist übrigens KEIN Angebot der Stadtwerke, sondern ein Bot der die Informationen von der Seite der WSW holt und bei twitter publiziert. Das bekommen die selbst wohl nicht hin…

Das gute Winterwetter hat mich dann auch auf meiner Rückreise am 23. noch kalt erwischt.
Die Zugfahrt verlief von Wuppertal bis Paderborn ohne Probleme. Die Züge waren sogar erstaunlich leer, alles schien gut. Bis Paderborn.
Da hatte sich die Bahn dann überlegt die S5 Richtung Hannover (die mich auch nach Steinheim bringt) ausfallen zu lassen. Kein Problem hab ich mir gedacht, die nächste Bahn kommt in einer Stunde. Nein, die fiel auch aus. Also ab aufs nächste Gleis. Da wär ich immerhin schonmal bis auf 10 Kilometer an zuhause heran gekommen. Dort angekommen fiel dieser Zug aufgrund eines Schadens am Triebfahrzeug auch aus, die Fahrten der S5 wurden für den Tag komplett gestrichen. Eisregen und so. Großartig, so stellt man sich das vor.
Glücklicherweise tat sich dann eine Mitfahrgelegenheit auf und ich kam, natürlich viel später als geplant, zuhause an.
Ich bin mir nicht sicher, ob sowas bei einer Privatisierung der Bahn besser oder schlechter würde.
Aber mit der Null-Informationen-Politik die da in Paderborn gefahren wurde, das Reisecenter hatte pünktlich um Sieben die Türen geschlossen, macht man sich bestimmt keine Freunde.

Sonst könnte ich jetzt noch darüber philosophieren wie zeitfressend (und ernüchternd) die Arbeit als AStA-Vorsitzender sein kann, aber das will ich mal lassen.

Stattdessen will ich lieber schonmal was fürs nächste Jahr ankündigen.

Ich habe soviel Gutes, und dabei Kostenloses, aus dem Internet erhalten, dass es mal Zeit wird, etwas zurückzugeben.

Deshalb hab ich mir überlegt im kommenden Jahr ein paar der Bilder die fotolia und Panthermedia nicht haben wollten hier kostenlos zur Verfügung zu stellen. Das Ganze mit einer Creative Commons-Lizenz ausgestattet, damit man auch was damit machen kann. Mal sehen, wie ich das aufziehe, mehr Infos dazu folgen…

So, jetzt ist noch 5 Minuten lang Weihnachten, die Zeit will ich mir lassen um das Fest nochmal zu genießen… ;-D

Wenn man vorher nichts mehr voneinander liest, dann wünsche ich bereits jetzt einen guten Rutsch und alles Gute für das neue Jahr!

Ach ja, die Typen von der RMF haben dieses Jahr anscheinend nichts gemacht, zumindest haben sie sich nicht gemeldet. Entweder sind die alle tot oder sie hecken irgendwas aus… Man darf gespannt sein.

Eine dieser Sachen war das Grundpraktikum zu PostScript und PDF. Da ging es um “den Hintergrund” von PDF und nicht darum wie das vorne herum gut aussieht und druckbar ist.

In diesem Rahmen sollten wir auch PostScript “programmieren”.

Aufgabe war es zwei Pacmans zu erstellen, die sich gegenseitig “fressen”. Das ging soweit ohne Probleme und so haben mein Kommilitone Basti und ich uns überlegt, dass Pacman mit Schleifen noch eine Nummer cooler wäre…

Wir haben uns die Arbeit dafür geteilt.

Basti hat die ursprüngliche Erzeugung des Pacmans so in eine Funktion umgeschrieben, dass man über die Parameterübergabe der Funktion die Position des Pacmans bestimmen kann.
Ich hab das dann noch so erweitert, dass man auch die Farbe übergeben kann. Hielt ich für konsequent. :-)

Paramaterübergabe ist in PostScript übrigens ein ätzendes Thema, da Variablen auf einem Stack gespeichert werden und man nicht “mal einfach so” auf eine Variable zugreifen kann, sondern den Stack entsprechend bearbeiten muss… Bäh…

Das Ganze haben wir dann in zwei for-Schleifen eingeschlossen und man erhält dann eine hübsche Ausgabe, die ich hier erstmal als Bild zeigen will.

Ja, soviel dazu. Jetzt fehlt natürlich noch der Quelltext für diese hübsche Sache. Wer einen PostScript-Interpreter hat, der kann damit rumspielen, alle anderen müssen sich das so anschauen und darüber freuen… ;-D

Sorry für den etwas zerstörten Sourcecode, leider hat mein Syntax-Highlighter auch nix für PostScript, muss für den Moment so gehen…

%!PS-Adobe-3.0		% Dies ist ein PS-3 Programm
%%Title: Pacman		% Der PS-interne TItel des Programms

/Helvetica-Bold		% PS-Font angeben
findfont		% aktuellen Font im System
72 640 moveto		% Anfangspunkt x, y fuer setzten Text
40 scalefont setfont		% Schrift skalieren und verwenden
(PacMan mit Schleife) show		% Text "PacMan mit Schleife" schreiben

70 120 moveto		% Cursor fuer aktuellen Pfad auf
				% aktuellen Punkt setzen (x, y)
525 120 lineto		% Linie vom aktuellen Punkt zu (x, y) ziehen,
				% Endpunkt wird neuer aktueller Punkt
0 552 rlineto		% Linie relativ vom aktuellen Punkt ziehen
				% (delta x, delta y), Endpunkt wird neuer
				% aktueller Punkt
70 672 lineto		% Linie vom aktuellen Punkt zu (x, y) ziehen
closepath		% Pfad schliessen
stroke		% Pfad zeichnen

% --------------- PacMan-Definition --------------------
/drawpacman {

x y moveto		% Kreismittelpunkt
x y 20 30 330 arc		% Linie und Kreis ziehen
closepath		% Kreis schliessen
gsave		% Grafischen Status speichern
cr cg cb setrgbcolor		% RGB-Wert fuer Fuellung setzen
fill		% Aktuellen Pfad fuellen und loeschen
grestore		% Grafischen Status wiederherstellen
2 setlinewidth		% Dicke der Umrisslinie setzen
stroke		% Umrisslinie ziehen
x 5 add y 12 add 2 0 360 arc		% Augenumriss definieren
0.0 0.0 0.0 setrgbcolor		% RGB-Wert fuer Fuellung setzen
fill		% Auge fuellen

} def

% ------------------------------------------------------

% -- Schleife mit Aufruf der PacMan-Definition --
% -- Initialwerte fuer die Farbe -- %
/cr 0.1 def
/cg 1.0 def
/cb 0.1 def
% -- Ende Initialwerte -- %

600 -50 150 {

/y exch def

% -- Farbtransformation ueber die y-Achse -- %
/cr cr 0.1 add def
/cg cg 0.1 sub def
%/cb cb 0.1 add def
% -- Ende Farbtransformation -- %

   100 50 500 {

       % -- Farbtransformation ueber die x-Achse -- %
       % /cr cr 0.1 add def
       % /cg cg 0.1 add def
       % /cb cb 0.1 add def
       % -- Ende Farbtransformation -- %

       /x exch def
       x y cr cg cb drawpacman

   } for

} for

showpage		% Seite drucken und Seitenspeicher
				% loeschen, Programmende

Anscheinend rechnet man in Wuppertal nicht damit, dass es im Winter auch schneien könnte. Anders lässt sich zumindest nicht wirklich erklären, warum die Straßen einfach nicht geschoben werden.

Der Busverkehr ist ein reines Glücksspiel und die Informationen die durch die Stadtwerke herausgegeben werden sind nicht gerade schön zu lesen und zu verstehen. Mich interessiert welche Linien fahren und nicht in welcher Straße kein Busverkehr stattfindet…

Auch die Uni ist natürlich vom Schnee… naja, “überrascht”… worden, aber man gibt sich Mühe, mit der Lage umzugehen.

Anbei jetzt ein paar Impressionen vom Campus Freudenberg.

Viermal der Taschenrechner, aber immer etwas modifiziert.

Viel Spaß damit!

#include <stdio.h>

int main(void)
{
	int zahl1, zahl2;
	char operator;

	printf("--- Einfacher Taschenrechner ---\n");
	printf("--------------------------------\n");
	printf("Dieses Programm kann mathematische Operationen \nvon zwei Zahlen mit den vier Grundrechenarten durchfuehren.\n");
	printf("(Return bestaetigt Eingaben)\n\n");

	// erste Zahl erfassen und in Variable speichern
	printf("Erste Zahl eingeben: ");
	scanf("%d", &zahl1);
	putchar('\n');

	// Tastaturpuffer leeren
	while(getchar()!='\n');

	// Operator erfassen
	printf("Operator eingeben: ");
	operator = getchar();
	putchar('\n');

	// zweite Zahl erfassen und in Variable speichern
	printf("Zweite Zahl eingeben: ");
	scanf("%d", &zahl2);
	putchar('\n');

	printf("Danke fuer Ihre Eingabe, das Ergebnis lautet wie folgt: \n");

	if(operator == '+') printf("%d %c %d = %d\n", zahl1, operator, zahl2, (zahl1+zahl2));
	if(operator == '-') printf("%d %c %d = %d\n", zahl1, operator, zahl2, (zahl1-zahl2));
	if(operator == '*') printf("%d %c %d = %d\n", zahl1, operator, zahl2, (zahl1*zahl2));
	if(operator == '/') printf("%d %c %d = %d\n", zahl1, operator, zahl2, (zahl1/zahl2));

	printf("\nProgramm beendet.");

	return 0;
}

#include <stdio.h>

int main(void)
{
	float zahl1, zahl2, ergebnis;
	char operator;
	char abbruch = 'n';

	printf("--- Einfacher Taschenrechner ---\n");
	printf("--------------------------------\n");
	printf("Dieses Programm kann mathematische Operationen \nvon zwei Zahlen mit den vier Grundrechenarten durchfuehren.\n");
	printf("(Return bestaetigt Eingaben)\n\n");

	while (abbruch == 'n') {
	  // Variablen initialisieren
	  zahl1 = 0;
	  zahl2 = 0;

	  // erste Zahl erfassen und in Variable speichern
	  printf("Erste Zahl eingeben: ");
	  scanf("%f", &zahl1);
	  putchar('\n');

	  // Tastaturpuffer leeren
	  while(getchar()!='\n');

	  // Operator erfassen
	  printf("Operator eingeben: ");
	  operator = getchar();
	  putchar('\n');

	  // zweite Zahl erfassen und in Variable speichern
	  printf("Zweite Zahl eingeben: ");
	  scanf("%f", &zahl2);
	  putchar('\n');

	  printf("Danke fuer Ihre Eingabe, das Ergebnis lautet wie folgt: \n");

	  switch (operator) {
	    case '+': { ergebnis = (zahl1+zahl2); printf("%f %c %f = %f\n", zahl1, operator, zahl2, ergebnis); break; }
	    case '-': { ergebnis = (zahl1-zahl2); printf("%f %c %f = %f\n", zahl1, operator, zahl2, ergebnis); break; }
	    case '*': { ergebnis = (zahl1*zahl2); printf("%f %c %f = %f\n", zahl1, operator, zahl2, ergebnis); break; }
	    case '/': { ergebnis = (zahl1/zahl2); printf("%f %c %f = %f\n", zahl1, operator, zahl2, ergebnis); break; }
	  }

	  // Tastaturpuffer leeren
	  while(getchar()!='\n');
	  // Abbruchvariable erfassen
	  printf("\nBeenden? (j/n):");
	  abbruch = getchar();

	}

	printf("\nProgramm beendet.");

	return 0;
}

#include <stdio.h>

float addiere(float, float);
float subtrahiere(float, float);
float multipliziere(float, float);
float dividiere(float, float);
void ausgabe();

  // Gloable Variablendeklaration
	float zahl1, zahl2, ergebnis;
	char operator;

int main(void)
{
	char abbruch = 'n';

	printf("--- Einfacher Taschenrechner ---\n");
	printf("--------------------------------\n");
	printf("Dieses Programm kann mathematische Operationen \nvon zwei Zahlen mit den vier Grundrechenarten durchfuehren.\n");
	printf("(Return bestaetigt Eingaben)\n\n");

	while (abbruch == 'n') {
	  // Variablen initialisieren
	  zahl1 = 0;
	  zahl2 = 0;

	  // erste Zahl erfassen und in Variable speichern
	  printf("Erste Zahl eingeben: ");
	  scanf("%f", &zahl1);
	  putchar('\n');

	  // Tastaturpuffer leeren
	  while(getchar()!='\n');

	  // Operator erfassen
	  printf("Operator eingeben: ");
	  operator = getchar();
	  putchar('\n');

	  // zweite Zahl erfassen und in Variable speichern
	  printf("Zweite Zahl eingeben: ");
	  scanf("%f", &zahl2);
	  putchar('\n');

	  printf("Danke fuer Ihre Eingabe, das Ergebnis lautet wie folgt: \n");

	  switch (operator) {
	    case '+': { ergebnis = addiere(zahl1, zahl2); ausgabe(); break; }
	    case '-': { ergebnis = subtrahiere(zahl1, zahl2); ausgabe(); break; }
	    case '*': { ergebnis = multipliziere(zahl1, zahl2); ausgabe(); break; }
	    case '/': { ergebnis = dividiere(zahl1, zahl2); ausgabe(); break; }
	  }

	  // Tastaturpuffer leeren
	  while(getchar()!='\n');
	  // Abbruchvariable erfassen
	  printf("\nBeenden? (j/n):");
	  abbruch = getchar();

	}

	printf("\nProgramm beendet.\n\n");

	return 0;
}

float addiere(float zahl1, float zahl2) { return (zahl1+zahl2); }
float subtrahiere(float zahl1, float zahl2) { return (zahl1-zahl2); }
float multipliziere(float zahl1, float zahl2) { return (zahl1*zahl2); }
float dividiere(float zahl1, float zahl2) { return (zahl1/zahl2); }
void ausgabe() { printf("%f %c %f = %f\n", zahl1, operator, zahl2, ergebnis); }

#include <stdio.h>

void addiere(float, float, float*);
void subtrahiere(float, float, float*);
void multipliziere(float, float, float*);
void dividiere(float, float, float*);
void ausgabe();

  // Globale Variablendeklaration
  float zahl1 = 0, zahl2 = 0, ergebnis = 0;
  char operator;

int main(void)
{
	char abbruch = 'n';

	printf("--- Einfacher Taschenrechner ---\n");
	printf("--------------------------------\n");
	printf("Dieses Programm kann mathematische Operationen \nvon zwei Zahlen mit den vier Grundrechenarten durchfuehren.\n");
	printf("(Return bestaetigt Eingaben)\n\n");

	while (abbruch == 'n') {
	  // erste Zahl erfassen und in Variable speichern
	  printf("Erste Zahl eingeben: ");
	  scanf("%f", &zahl1);
	  putchar('\n');

	  // Tastaturpuffer leeren
	  while(getchar()!='\n');

	  // Operator erfassen
	  printf("Operator eingeben: ");
	  operator = getchar();
	  putchar('\n');

	  // zweite Zahl erfassen und in Variable speichern
	  printf("Zweite Zahl eingeben: ");
	  scanf("%f", &zahl2);
	  putchar('\n');

	  switch (operator) {
	    case '+': { addiere(zahl1, zahl2, &ergebnis); ausgabe(); break; }
	    case '-': { subtrahiere(zahl1, zahl2, &ergebnis); ausgabe(); break; }
	    case '*': { multipliziere(zahl1, zahl2, &ergebnis); ausgabe(); break; }
	    case '/': { dividiere(zahl1, zahl2, &ergebnis); ausgabe(); break; }
	  }

	  // Tastaturpuffer leeren
	  while(getchar()!='\n');
	  // Abbruchvariable erfassen
	  printf("\nBeenden? (j/n):");
	  abbruch = getchar();

	}

	printf("\nProgramm beendet.\n\n");

	return 0;
}

void addiere(float v_zahl1, float v_zahl2, float* v_ergebnis) { *v_ergebnis = (v_zahl1+v_zahl2); }
void subtrahiere(float v_zahl1, float v_zahl2, float* v_ergebnis) { *v_ergebnis = (v_zahl1-v_zahl2); }
void multipliziere(float v_zahl1, float v_zahl2, float* v_ergebnis) { *v_ergebnis = (v_zahl1*v_zahl2); }
void dividiere(float v_zahl1, float v_zahl2, float* v_ergebnis) { *v_ergebnis = (v_zahl1/v_zahl2); }
void ausgabe() { printf("Danke fuer Ihre Eingabe, das Ergebnis lautet wie folgt:\n%f %c %f = %f\n", zahl1, operator, zahl2, ergebnis); }

Heute mit Highlights wie Forward-Deklarationen, Strukturen mittels typedef und dem ermittelten der größten von drei eingegebenen Zahlen… Das Beste ist aber das “dreiecksförmige” Ausgeben eines Zeichens. Sehr zu empfehlen!

#include <stdio.h>

int max(int, int, int);
int zahlen[3];

int main()
{
  system("clear");
  printf("Dieses Programm liefert die Groesste von drei eingegebenen Zahlen.\n\n");
  printf("Bitte drei Ganzzahlen eingeben und mit Return bestaetigen: ");
  scanf("%d %d %d", &zahlen[0], &zahlen[1], &zahlen[2]);
  putchar('\n');

  printf("Die groesste eingegebene Zahl war die %d. Zahl: %d\n\n", (max(zahlen[0],zahlen[1],zahlen[2])), zahlen[max(zahlen[0],zahlen[1],zahlen[2])-1]);

  return 0;
}

int max(int a, int b, int c)
{
  if(a>b && a>c) return 1;
  if(b>a && b>c) return 2;
  if(c>a && c>b) return 3;
}

#include <stdio.h>

// Forward-Deklaration
int add(int, int);

// ==============================================================
// Forward-Deklaration produkt
int produkt(int, int);
// ==============================================================

int main(void)
{
    // Variablendefinitionen
    int a = 5, b = 100;
    int *pa = &a, *pb = &b;
    // Wert- und Adressangabe über Variablenbezeichner
    printf("Wert von a: %d; Wert von b: %d \n", a, b);
    printf("Adresse von a: %p; Adresse von b: %p \n", &a, &b);
    // Wert- und Adressangabe über Zeiger
    printf("Wert von a: %d; Wert von b: %d \n", *pa, *pb);
    printf("Adresse von a: %p; Adresse von b: %p \n", pa, pb);
    printf("================================================\n\n");
    // Funktionsaufruf (call-by-value)
    printf("add: %d + %d = %d\n", a, b, add(a, b));

// ==============================================================
    // Funktionsaufruf produkt
    printf("produkt: %d * %d = %d\n", a, b, produkt(a, b));
// ==============================================================
    printf("Wert von a: %d; Wert von b: %d \n\n", a, b);
    return 0;
}

// Funktionsdefinition add
int add(int wert_1, int wert_2)
{
    wert_1 = 11;
    wert_2 = 22;
    return (wert_1 + wert_2);
}

// ==============================================================
// Funktionsdefinition
// ==============================================================
int produkt(int wert_1, int wert_2)
{
    return (wert_1 * wert_2);
}

#include <stdio.h>
#include <string.h>

void person_erfassen();

typedef struct sPerson
{
       char vorname[20];
       char nachname[20];
       int alter;
       int gewicht;
} sPerson;

sPerson Person1;
sPerson Person2;

int main()
{
    sPerson Person1 = { "Max", "Mustermann", 30, 85 };

    person_erfassen();

    printf("\n\n");

    printf("Ausgabe der Struktur:\n");
    printf("=====================\n\n");
    printf("Person 1\nName: %s %s\nAlter: %d\nGewicht: %d\n\n",Person1.vorname, Person1.nachname, Person1.alter, Person1.gewicht);
    printf("Person 2\nName: %s %s\nAlter: %d\nGewicht: %d",Person2.vorname, Person2.nachname, Person2.alter, Person2.gewicht);
    printf("\n\n");
    return 0;
}

void person_erfassen()
{
     char temp_vorname[20], temp_nachname[20];
     int temp_alter, temp_gewicht;

     printf("Bitte Vornamen und Nachnamen eingeben und mit Return bestaetigen:\n");
     scanf("%s %s", temp_vorname, temp_nachname);

     printf("Alter: ");
     scanf("%d", &temp_alter);

     printf("Gewicht: ");
     scanf("%d", &temp_gewicht);

     strcpy(Person2.vorname, temp_vorname);
     strcpy(Person2.nachname, temp_nachname);
     Person2.alter = temp_alter;
     Person2.gewicht = temp_gewicht;
}

#include <stdio.h>
#include <string.h>

char zeichen;
int zeilenanzahl = 0;
int auswahl = 0;

int menue(void);
void erzeuge_halbes_dreieck(char, int);
void erzeuge_dreieck(char, int);

int main()
{
  system("clear");
  printf("Dieses Programm kann ein beliebiges Zeichen wiederholt in Form \neines halben oder ganzen Dreiecks ausgeben.\n");
  printf("(Eingaben werden mit [Return] bestaetigt.)\n\n");

  // Zeichen fuer die formatierte Ausgabe waehlen
  printf("Bitte zunaechst das gewuenschte Zeichen eingeben: ");
  zeichen = getchar();
  while(getchar() != '\n');

  // Hoehe der Figur
  while((zeilenanzahl > 15) || (zeilenanzahl == 0))
  {
    printf("Bitte die Hoehe der Figur (max. 15) eingeben: ");
    scanf("%d", &zeilenanzahl);
    while(getchar() != '\n');
    putchar('\n');
  }

  while(1)
  {
    switch(menue())
    {
    case 49: {
                erzeuge_halbes_dreieck(zeichen, zeilenanzahl);
                while(getchar() != '\n');
                break;
              }
    case 50: {
                erzeuge_dreieck(zeichen, zeilenanzahl);
                while(getchar() != '\n');
                break;
              }
    case 51: { return 0; }
    }
  }
  return 0;
}

int menue(void)
{
    while(getchar() != '\n');
    printf("%d",auswahl);
    printf("\nBitte die gewuenschte Aktion waehlen:\n");
    printf("(1) Halbes Dreieck\n(2) Ganzes Dreieck\n(3) Programmende\nIhre Auswahl: ");

    auswahl = getchar();

    return auswahl;
}

void erzeuge_halbes_dreieck(char _zeichen, int zeilenanzahl)
{
  int zaehler1 = 0, zaehler2 = 0;

  char zeichen[2];
  zeichen[0] = _zeichen;
  zeichen[1] = '\0';

  char leerzeichen[2];
  leerzeichen[0] = 32;
  leerzeichen[1] = '\0';

  char string_zeichen[15];
  string_zeichen[0] = zeichen[0];
  string_zeichen[1] = '\0';

  char string_leerzeichen[14];
  string_leerzeichen[0] = '\0';

  char *p_zeichen = &zeichen[0];
  char *p_leerzeichen = &leerzeichen[0];
  char *p_str_zeichen = &string_zeichen[0];
  char *p_str_leerzeichen = &string_leerzeichen[0];

  zaehler2 = (zeilenanzahl-2);

  // Mit Leerzeichen auffuellen...
  for(zaehler1=0; zaehler1 <= zaehler2; zaehler1++)
  { p_str_leerzeichen = strcat(p_str_leerzeichen,p_leerzeichen); }

  // Ausgabe -> Zeichen-String verlaengern, Leerzeichen-String kuerzen
  for(zaehler1=0; zaehler1 < zeilenanzahl; zaehler1++)
  {
    printf("%s%s\n", p_str_leerzeichen, p_str_zeichen);
    p_str_zeichen = strcat(p_str_zeichen,p_zeichen);
    string_leerzeichen[zaehler2] = '\0';
    zaehler2--;
  }
}

void erzeuge_dreieck(char _zeichen, int zeilenanzahl)
{
  int zaehler1 = 0, zaehler2 = 0;

  char zeichen[2];
  zeichen[0] = _zeichen;
  zeichen[1] = '\0';

  char leerzeichen[2];
  leerzeichen[0] = 32;
  leerzeichen[1] = '\0';

  char string_zeichen[29];
  string_zeichen[0] = zeichen[0];
  string_zeichen[1] = '\0';

  char string_leerzeichen[14];
  string_leerzeichen[0] = '\0';

  char *p_zeichen = &zeichen[0];
  char *p_leerzeichen = &leerzeichen[0];
  char *p_str_zeichen = &string_zeichen[0];
  char *p_str_leerzeichen = &string_leerzeichen[0];

  zaehler2 = (zeilenanzahl-2);

  // Mit Leerzeichen auffllen...
  for(zaehler1=0; zaehler1 <= zaehler2; zaehler1++)
  { p_str_leerzeichen = strcat(p_str_leerzeichen,p_leerzeichen); }

  // Ausgabe -> Zeichen-String verlngern, Leerzeichen-String krzen
  for(zaehler1=0; zaehler1 < zeilenanzahl; zaehler1++)
  {
    printf("%s%s\n", p_str_leerzeichen, p_str_zeichen);
    p_str_zeichen = strcat(p_str_zeichen,p_zeichen);
    p_str_zeichen = strcat(p_str_zeichen,p_zeichen);
    string_leerzeichen[zaehler2] = '\0';
    zaehler2--;
  }
}

Heute dabei: Fakultätsberechnung, Pfingstdatumsberechnung mit Gaußscher Osterformel und die Subtraktion von m*n-Matrizen.

#include <stdio.h>
#include <limits.h>

int main(void)
{
 int i; // "Laufvariable i"
 int faktor = 0; // "Groesster Faktor n" wird mit 0 initialisiert um Sprung in die erste while-Schleife zu erzwingen
 int produkt = 1; // "Produkt p" wird mit 1 initialisiert um zu verhindern, dass 0 als Produkt auftaucht
 int temp_ergebnis; // "Hilfsvariable hilf" - zur temporaeren Speicherung des Fakultaetsergebnisses
 int ende = 0; // Hilfsvariable um die Berechnung zu stoppen, sobald die Grenze ueberschritten wurde

 printf("Fakultaet berechnen\n");
 printf("-------------------\n\n");

 /* Die Eingabe einer Zahl groesser 1 erscheint sinnvoll,
    da die Fakultaetsberechnung mit einer Zahl = 1 oder gar < 1
    kein brauchbares Ergebnis liefert. */
 while(faktor < 2)
 {
    printf("Bitte eine ganze Zahl groesser 1 eingeben.\n");
    printf("Die Eingabe anschliessend mit [Return] bestaetigen.\n\n");

    printf("Bitte Faktor fuer die Fakultaetsberechnung eingeben: ");
    scanf("%d",&faktor);
    putchar('\n');
 }

 printf("Als Faktor wurde %d angegeben. Fakultaetsberechnung wird gestartet...\n\n",faktor);

 /* i wird an dieser Stelle mit 2 initialisiert, da dies dem ersten moeglichen Wert von faktor entspricht
    und so sichergestellt werden kann, dass die Fakultaetsberechnung fuer einen sinnvollen Wertebereich
    (ab 1 x 2) durchgefuehrt wird. */
 for(i=2; i<=faktor; i++)
 {
    if(produkt < (INT_MAX/2))
    {
      temp_ergebnis = produkt;
      produkt *= i;
      printf("1 * ... * %2.d = %13.d \n",i, produkt);
    }
    else
    {
      printf("\nDer maximale Wert (INT_MAX/2 = %d) wurde ueberschritten, Berechnung gestoppt.\n", (INT_MAX/2));
      printf("Das letzte Produkt innerhalb der Grenze wurde mit dem Faktor %d erreicht:\n", (i-2));
      printf("1 * ... * %d = %d\n\n",(i-2), temp_ergebnis);

      // Grenze wurde ueberschritten, Berechnung stoppen. Dazu bietet sich ein break; in der for-Schleife an,
      // das ueber diese Variable gesteuert wird
      ende = 1;
    }
    if(ende) break;
 }

  return 0;
}

#include <stdio.h>
#define M 24
#define N 5

int main()
{
  int jahr = 0, a, b, c, d, e, ostern, tag, monat;

  printf("Pfingsten berechnen\n");
  printf("-------------------\n");
  printf("Dieses Programm berechnet das Pfingstdatum \nfuer ein beliebiges Jahr zwischen 1900 und 2099.\n\n");

  while(jahr<1900 || jahr>2099)
  {
    printf("Bitte geben Sie eine Jahreszahl ein: ");
    scanf("%d)",&jahr);
    putchar('\n');
  }

  // vereinfachte Gausssche Osterformel
  a = jahr%19;
  b = jahr%4;
  c = jahr%7;
  d = (19*a+M)%30;
  e = (2*b+4*c+6*d+N)%7;

  if(d+e==35)
    ostern=50;
  else if(d==28 && e==6 && ((11*M+11%30)<19))
    ostern=29;
  else
    ostern=(22+d+e);

  // Pfingsten ist 50 Tage nach Ostern, das entsprechende Datum dafuer ermitteln
  if(ostern<=31)
  {
    monat = 3;
    tag = ostern;
  }
  else
  {
    monat = 4;
    tag = (ostern-31);
  }

  tag += 19;

  if(tag>31)
  {
    tag -= 31;
    monat = 6;
  }
  else
    monat = 5;

  printf("Pfingsten ist am %d.%d.%d.\n\n", tag, monat, jahr);

  return 0;
}

#include <stdio.h>
#include <string.h>

#define ZEILEN 3
#define SPALTEN 3

int main()
{
  // Matrizen zur Aufnahme der Daten
  int matrixA[SPALTEN][ZEILEN], matrixB[SPALTEN][ZEILEN], matrixErg[SPALTEN][ZEILEN];
  int i, j; // Zaehlervariablen fuer Schleifen

  // Fuellen der Arrays mit Nullen, damit auch bei Fehleingaben gerechnet werden kann
  memset(matrixA,0,sizeof(matrixA));
  memset(matrixB,0,sizeof(matrixB));

  printf("Matrizen-Subtraktion\n");
  printf("--------------------\n");
  printf("Mithilfe dieses Programmes koennen zwei %dx%d-Matrizen \nvoneinander subtrahiert werden.\n\n", ZEILEN, SPALTEN);

  printf("Hinweis zur Eingabe:\n");
  printf("Die Daten werden zeilenweise erfasst. \nEinzelne Werte durch Leerzeichen trennen, Eingabe mit [Return] bestaetigen.\n\n");

  // Erste Matrix einlesen
  printf("Erste Matrix\n------------\n");

  for(i=0;i<ZEILEN;i++)
  {
    printf("Bitte Werte fuer die %d. Zeile eingeben:\n",(i+1));
    scanf("%d %d %d",&matrixA[i][0],&matrixA[i][1],&matrixA[i][2]);
  }

  printf("\nVielen Dank, Daten uebernommen.\n\n");

  // Zweite Matrix einlesen
  printf("Zweite Matrix\n-------------\n");

  for(i=0;i<ZEILEN;i++)
  {
    printf("Bitte Werte fuer die %d. Zeile eingeben:\n",(i+1));
    scanf("%d %d %d",&matrixB[i][0],&matrixB[i][1],&matrixB[i][2]);
  }

  printf("\nVielen Dank, Daten uebernommen.\n\n");

  printf("Die Subtraktion der beiden Matrizen fuehrt zu folgendem Ergebnis:\n");

  // Subtraktion der Matrizen und Ergebnisausgabe
  for(i=0;i<ZEILEN;i++)
  {
    printf("| ");
    for(j=0;j<SPALTEN;j++)
    {
      matrixErg[i][j] = (matrixA[i][j]-matrixB[i][j]);
      printf("%4d", matrixErg[i][j]);
    }
    printf(" |");
    putchar('\n');
  }

  return 0;
}

Für wen? Gute Frage.

Entweder stolpert jemand zufällig darüber, weil er gerade nach irgendwelchen C/C++-Grundlagen sucht oder er ist mehr oder weniger zielgerichtet hier gelandet, weil er auch Druck- und Medientechnologie studiert, diese Veranstaltungen vor sich hat, Panik schiebt und nach Musterlösungen gesucht hat.

Für den zweiten Fall möchte ich eine Sache gesagt haben: Kopiert die Quelltexte nicht nur, versteht sie. In der Klausur müsst ihr mit Stift und Papier programmieren, dafür ist ein Verständnis der Prinzipien dahinter durchaus notwendig…

Nach dem Sprung gibt´s gleich mal die Quellcodes für das erste Praktikum.

Ach übrigens, als Entwicklungsumgebung gehe ich von einem Linux-System aus, die Darstellung erfolgt in einer Konsole…

“Hello World!” in C

#include <stdio.h>

int main(void)
{
	printf("Hallo Welt!\n");

	return 0;
}

Volumenberechnung eines rechteckigen Körpers

#include <stdio.h>

int main(void)
{
	int laenge, breite, hoehe;

	printf("Volumenberechnung:\n");
	printf("Laenge in m eingeben: ");
	scanf("%d", &laenge);
	putchar('\n');
	printf("Sie gaben fuer die Laenge den Wert %d m ein. \n", laenge);

	printf("Breite in m eingeben: ");
	scanf("%d", &breite);
	putchar('\n');
	printf("Sie gaben fuer die Breite den Wert %d m ein.\n", breite);

	printf("Hoehe in m eingeben: ");
	scanf("%d", &hoehe);
	putchar('\n');
	printf("Sie gaben fuer die Hoehe den Wert %d m ein.\n", hoehe);

	printf("Das Volumen ist: %d Kubikmeter.\n", (laenge*breite*hoehe));

	return 0;
}

Zahlen in Dezimal-, Oktal- und Hexadezimalschreibweise darstellen

#include <stdio.h>

int main(void)
{
	int zahl1, zahl2, zahl3, zahl4, zahl5;
	printf("Bitte geben Sie 5 ganze Zahlen im Bereich von 0-999 ein.\n");
	printf("Zahlen durch Leerzeichen trennen, Return bestaetigt die Eingabe.\n");

	scanf("%d %d %d %d %d", &zahl1, &zahl2, &zahl3, &zahl4, &zahl5);

	printf("\tDezimal  |\tOktal  |\tHexadezimal\n");
	printf("-----------------------------------------------------\n");

	printf("\t%7.d  |\to%04o  |\t0x%03x\n", zahl1, zahl1, zahl1);
	printf("\t%7.d  |\to%04o  |\t0x%03x\n", zahl2, zahl2, zahl2);
	printf("\t%7.d  |\to%04o  |\t0x%03x\n", zahl3, zahl3, zahl3);
	printf("\t%7.d  |\to%04o  |\t0x%03x\n", zahl4, zahl4, zahl4);
	printf("\t%7.d  |\to%04o  |\t0x%03x\n", zahl5, zahl5, zahl5);

	printf("-----------------------------------------------------\n");

	return 0;
}

Das Ganze mit Fließkommazahlen und wissenschaftlicher Schreibweise der Zahlen

#include <stdio.h>

int main(void)
{
	float zahl1, zahl2, zahl3, zahl4, zahl5;
	printf("Bitte geben Sie 5 Fliesskommazahlen ein.\n");
	printf("Zahlen durch Leerzeichen trennen, Return bestaetigt die Eingabe.\n");
	printf("ACHTUNG! Den Punkt als Dezimaltrennzeichen verwenden, Komma bricht das Programm ab.\n");

	scanf("%f %f %f %f %f", &zahl1, &zahl2, &zahl3, &zahl4, &zahl5);

	printf("\t      Dezimal |\tWissenschaftlich\n");
	printf("-------------------------------------------------\n");
	printf("\t%12.3f  |\t%.2e\n", zahl1, zahl1);
	printf("\t%12.3f  |\t%.2e\n", zahl2, zahl2);
	printf("\t%12.3f  |\t%.2e\n", zahl3, zahl3);
	printf("\t%12.3f  |\t%.2e\n", zahl4, zahl4);
	printf("\t%12.3f  |\t%.2e\n", zahl5, zahl5);
	printf("-------------------------------------------------\n");

	return 0;
}

Ein einfacher “Taschenrechner”

#include <stdio.h>

int main(void)
{
	int zahl1, zahl2;
	char operator;

	printf("--- Einfacher Taschenrechner ---\n");
	printf("--------------------------------\n");
	printf("Dieses Programm kann mathematische Operationen \nvon zwei Zahlen mit den vier Grundrechenarten durchfuehren.\n");
	printf("(Return bestaetigt Eingaben)\n\n");

	// erste Zahl erfassen und in Variable speichern
	printf("Erste Zahl eingeben: ");
	scanf("%d", &zahl1);
	putchar('\n');

	// Tastaturpuffer leeren
	while(getchar()!='\n');
	// Operator erfassen
	printf("Operator eingeben: ");
	operator = getchar();
	putchar('\n');

	// Operator pruefen
	if((operator != '+') && (operator != '-') && (operator != '*') && (operator != '/'))
	{
		while((operator != '+') && (operator != '-') && (operator != '*') && (operator != '/'))
		{
			while(getchar()!='\n');
			printf("Sie haben einen ungueltigen Operator eingegeben!\nBitte einen gueltigen Operator eingeben: ");
			operator = getchar();
		}
	}

	// zweite Zahl erfassen und in Variable speichern
	printf("Zweite Zahl eingeben: ");
	scanf("%d", &zahl2);
	putchar('\n');

	printf("Danke fuer Ihre Eingabe, das Ergebnis lautet wie folgt: \n");

	if(operator == '+')
		printf("%d %c %d = %d\n", zahl1, operator, zahl2, (zahl1+zahl2));

	if(operator == '-')
		printf("%d %c %d = %d\n", zahl1, operator, zahl2, (zahl1-zahl2));

	if(operator == '*')
		printf("%d %c %d = %d\n", zahl1, operator, zahl2, (zahl1*zahl2));

	if(operator == '/')
		printf("%d %c %d = %d\n", zahl1, operator, zahl2, (zahl1/zahl2));

	return 0;
}

1004 Stimmen sind übrigens gigantische 8,1% Wahlbeteiligung. Schande, Schande…

Ansonsten ist hier in Wuppertal Super-Wetter und man hört praktisch aus der ganzen Stadt Vuvuzelas und Jubelrufe wegen des Fußballspiels. Ist aber auch bisher eine Hammer-Partie… Und da es jetzt weitergeht schreib ich erstmal gar nicht mehr. Vielleicht kommt später noch was… :-D

Die Dame der Schilderdruckfirma wies mich darauf hin, daß PDF ein AppleFormat sei, welches von ihrem CorelDraw nicht geöffnet werden könne

gefunden auf Twitter

Prof: Ja, was müssen Sie da machen?

- Schweigen im Saal, dann melde ich mich -

Prof: “Ja?”

Ich: “Hm, da muss eine Forward-Deklaration des Konstruktors mit Funktionsüberladung durchgeführt werden.”

- Wieder Schweigen im Saal -

Prof: “Ja gut, das hat jetzt keiner verstanden (Anmerkung: er schon, wie mir sein freudiges Lächeln zeigte), sagen sie das noch mal anders…”

Ich: “Wir müssen mehrere Konstruktoren mit mehreren Variablen schreiben…”

- Erleichterung im Saal -

Mir soll nochmal einer sagen nen Info-LK würde sich nicht irgendwann auszahlen… ;-D

Thema momentan sind übrigens, wie für den Fachmann zu erkennen, Klassen, Vererbung, abstrakte Datentypen und all sowas. Und dabei hilft der Info LK schon ganz ordentlich.

Das objektorientierte Denken und Handeln das wir damals beigebracht bekommen haben, kann hier natürlich 1 zu 1 wieder angewandt werden (sofern man es noch drauf hat ;-D). Und ich merke, dass allgemein das Programmieren, z.B. in PHP, durchaus nützlich ist. Natürlich ist die Sprache in C/C++ anders, aber die Abläufe sind halt doch die gleichen. Wie´s so ist…

Ach shit, der letzte Artikel ist vom 11. Mai, ich schäme mich dafür. Gibt´s nen Titel für den inaktivsten aktiven Blog des Netzes? Der gehört sicher mir…

Dabei gibt es gar nicht so wenig zu erzählen, je nachdem wie man es sieht. Neben der letzten Entwicklung von meiner Datenauskunftssache (liegt schon ewig rum) hat sich natürlich auch hier in Wuppertal einiges getan.

Man soll es kaum glauben, aber hier scheint tatsächlich die Sonne. Kein Scheiss. Es ist warm und keine Wolken und all sowas… Ich will mal hoffen, dass hält noch etwas an, man kann sich wahrlich dran gewöhnen. Ändert nichts daran, dass ich bei Zeiten ein “Wenn schon Regen, dann in Wuppertal”-Shirt haben möchte.

Montag dieser Woche waren wir in kleinem Kreis bei Interprint in Arnsberg und haben uns da mal einen sehr guten Überblick über den Dekortiefdruck verschafft. Beeindruckend, auch wenn ich mir Tiefdruckmaschinen etwas größer vorgestellt hatte. Wahrscheinlich sind Illustrationstiefdruckmaschinen etwas größer, das werde ich bei Zeiten mal prüfen… Hehe…

Ansonsten arbeiten wir hier mit mehreren Leuten daran ins StuPa der Uni Wuppertal einzuziehen um die Welt zu verbessern (irgendwo muss man anfangen). “Früher” (bis Mitte Mai so) waren wir die “Piraten an der Bergischen Universität”, aber da wir den Themen von “Campus Grün” auch sehr nahe standen (bzw. die unseren) haben wir ein Bündnis gegründet (Kompetenzergänzung, yeah!) und sind nun das “Bündnis Freibeuter und Grüne”. Webseite kann man sich mal hier anschauen: www.freibeuter-und-gruene.de. Mehr Inhalte folgen…

Gleich (ok, um 13 Uhr) hab ich dann Vorlesung mit vorhergehendem Test. Vier Tests bilden da die Note fürs Semester. Ist zwar noch stärker verschult, aber eigentlich recht angenehm. Nimmt den Lernaufwand doch etwas aus den Semester”ferien” raus. Das Fach heisst übrigens “Reproduktionstechnik”…

Mal an die Leute aus der Branche: Kennt ihr diese Sachen die heute niemand mehr macht? Dichtewerte von Hand berechnen, Transmissionsgrade von belichteten Filmen (sic!) berechnen und sowas… Ich dachte das sei tot und man müsste das nicht mehr können. Blödsinn! Das kommt einem hier an jeder zweiten Ecke entgegen. Krank. Richtig krank. Aber gut, einfach mitnehmen und bei Zeiten (nach dem vierten Test oder so) vergessen…

Vorher packe ich jetzt gerade Sachen, weil es am Wochenende wieder nach Hause geht. Da ist´s doch einfach schöner als hier. Ah, eine Sache hab ich noch.

Mein Shirt4Link-Shirt kam nach zwei Tagen an (die Jungs sind schnell!) und das trage ich heute auch. Der Fotobeweis ist mal wieder Murks. Das passiert, wenn man die Kamera selber hält, im Automatikmodus ist und vergessen hat die Belichtungsmessung von Integral- auf Spotmessung zu stellen. Da kann so ein Wuppertaler-Frühsommerhimmel schonmal die Belichtung zerfetzen und selbst Photoshop rettet da nicht mehr viel…

Der geneigte Beobachter fragt sich nun, was da unten im Fenster gelb und rot spiegelt… Die Antwort ist… … … … eine lippische Flagge! :-D Heimat FTW!

Jep! Die hängt hier seit einigen Wochen schon, trotzt Wind und Wetter und repräsentiert die Heimat. Man beachte auf diesem Bild übrigens den blauen Himmel…

Hier das Ganze nochmal von außen. Das Foto hab ich die Tage im Halbdunkeln (mit Automatikmodus ;-D) gemacht, deshalb ist das auch eher bescheiden…

Das war´s jetzt wirklich fürs Erste. Ich werd mal weiter Sachen packen. Und dann gibt´s dieses Wochenende noch mindestens einen Eintrag. Versprochen. (Vielleicht hätte ich das nicht versprechen sollen…)

Der Titel dieses Eintrags ist die recht passende Beschreibung (von unserer Fachschaft stammend) dessen, was hier gerade in Wuppertal los ist. Die Wuppertaler Stadtwerke haben den Busverkehr aufgrund der Wetterlage eingestellt, damit kommt man nur noch zu Fuß oder per Auto hier hoch zum Campus Freudenberg…

Keine Ahnung warum, aber das Bild ist leider von der Fachschaftsseite entfernt worden, dafür biete ich ein Bild vom Schneeengel machen an… ;-D Grausige iPhone-Bildqualität…