* "Principles of Programming Languages" (PoPL), SS2012 (Prüfung geschoben)
  * Dauer ~ 30min
  * Prüfer: Ronald Veldema
  * Beisitzer: Georg Dotzler
  * Ergebnis: sehr zufriedenstellend (1.3)

==== Vorbemerkung ====
Es scheint hilfreich zu sein, schnell zu reden (Philippsen-Style), dann kommt man schnell durch, und Fragen welche man nicht korrekt hatte fallen nicht so ins Gewicht. \\
Ich hatte ziemliche Probleme die 800 Seiten der Vorlesung zu strukturieren, aber in der Prüfung wird wert darauf gelegt, dass man vor allem die Idee verstanden hat (nicht nur das Wort weiß). Die konkrete Syntax der (Beispiel-) Programmiersprachen ist absolut egal, aber man darf doch einiges an Beispielen demonstrieren. \\
Die Fragen kommen übrigens von 2 Zetteln, also gut möglich das sich die Variation in Grenzen hält ;)

==== Fragen ====
P: Ich will eine Programmiersprache entwickeln, die "for" kann. Wie beschreibe ich das semantisch \\
S legt einen gnadenlos guten Start hin und hat schon mal keine Ahnung. Lösung war 
operationale, axiomatische und denotationale Semantik und Attributgramatik erklären, 1. Vl, Folie 37.

==== Imperativ ====
P: Was zeichnet Imperativ aus?\\
S erklärt, aber keine Ahnung was die ausschlaggebende Buzzwords waren, irgendwann war P einfach zufrieden ;)

P: C-Präprozessor: Was macht er? \\
S: Code transformieren

P: Beispiel:
<code c>
#define x y[2]
int x = {1,2};
printf("%d",y[1]);
</code>
Was kommt raus?\\
S:
<code c>
int y[2] = {1,2};
printf("%d",y[1]);
</code>

P: Was ist ihre Lieblingssprache\\
S: Uff, Java?

P: Okay, was ist //Introspection//\\
S: Reflection, man arbeitet mit Metaklassendaten, kann via String Methoden adressieren

==== Objektorientiert ====
P: Was ist überladen?\\
S: Verschiedene Parameter bei Funktionen mit gleichen Namen

P: was ist //Kovarianz//?

P: Mehrfache Vererbungen, wie geht das in Java?\\
S: Nur mit Interfaces, keine abstrakten Klassen. Problem sind die gleich lautenden Methoden aus verschieden Klassen.

P: Wie macht das C++ bei mehrdeutigen Methoden?\\
S: Man gibt die Oberklasse explizit an ( O::foo(); ).\\
Andere Sprachen gehen einfach sequentiell nach der Nennung vor.

P: Was bedeutet //virtual// bei der Vererbung in C++\\
<code cpp>
class Foo : public virtual Bar ...
</code>

P: Was sind //Mixins//?\\
S: Funktionalität implementieren (keine Interfaceimplementierung!) und an eine Klasse/Interface hängen

==== Funktional ====
P: Was ist das (grundsätzliche) Kennzeichen von funktionalen Sprachen?\\
S: Keine (globalen) Variablen\\
(Evtl. auch einfach sagen: Gibt keine Seiteneffekte. Damit spart man sich folgende Nachfrage:)

P: Wie sieht es mit Klassen aus?\\
S: Gibt's (siehe Haskell) aber dürfen keine Attribute haben.

P: Wie schreibt man eine Funktion die die Länge einer Liste ermittelt\\
S: 
<code haskell>
len [] = 0
len [_|X] = (len X) + 1
</code>

P: Was sind //list comprehensions//\\
S verpeilt's mal wieder, obwohl's eigentlich einfach ist, z.B.: [x | x <- [0..], x%2==0] für alle geraden Zahlen

P: Es gibt ja eigentlich keine Seiteneffekte... Wie ist das mit I/O?

==== Logik ====
P: Ich diktiere einmal, sie machen daraus Prolog-Code: "Wer ein Fahrrad hat ist reich, Georg und Ronald haben ein Fahrrad."\\
S:
<code prolog>
reich(J) :- fahrrad(J).
fahrrad(georg).
fahrrad(ronald).
</code>

P: Wer ist reich, und wieso kommt das Ergebnis?\\
S:
<code>
?- reich(X).
X=georg
X=ronald
</code>
Unifikation (jeweils) und das zweite Ergebnis durch Backtracking.

P: Wie implementiert man eine Summenfunktion (alle Zahlen abwärts bis 1 aufsummieren)?\\
S:
<code>
sum(1) :- 1.
sum(N) :- M is N-1, sum(M)+N.
</code>
(Schluesselwort //is// ist wichtig)

==== Parallel ====
P: Was ist das Konzept hinter Occam / Go zur Kommunikation verschiedener Threads\\
S: Channels (+ allgemeine Erklärung, one-way und two-way, warten usw)

P: Wie macht ADA das?\\
S: Rendezvous

P: Gehen in ADA ebenfalls Objekte\\
Ja

P: Ich will in ADA eine Fabrik bauen, die sowohl etwas konsumiert als auch eine StopAll-Möglichkeit hat. Wie geht das?\\
S hat's verpeilt, Lösung ist:
<code ada>
select
	when <cond1> => accept <entry1(arg1)> do ... end <entry1>
	when <cond2> => accept <entry2(arg2)> do ... end <entry2>
end select
</code>

P: Wie geht das mit Transaktionen\\
S erklärt accept oder roll-back 

P: Wir haben zwei Funktionen welche gleichzeitig laufen:
<code>
f1 {
	x++;
	print(x);
}
f2 {
	x--;
	print(x);
}
</code>
Wie läuft das da mit Transaktionen? Und was wird ausgegeben?

==== Aspektorientiert ====
P: Was ist das?\\
S: Man konzentriert sich in der Methode nur auf die grundlegende Funktionalität, Rest (gutes Beispiel: Logging) wird in einem extra Modul beschrieben und per Aspekte (Pointcut, after() bzw before()) reingewoben.

==== Weitere ====
P: Hm, wir haben noch Zeit. Okay, wie geht folgendes mit XQuery
<code>
for $i in $x
	if ($i.failure > 5)
		return $i
</code>
S bemerkt, dass es darauf hinaus läuft, dass JEDES $i mit der Bedingung zurück geliefert wird, nicht nur das Erste (wie bei konventionellem //return//)