FreitagsrundenWiki - Benutzerbeiträge [de]

E-Mail

2024-03-12T15:50:10Z

Milan: bruh

{{veraltet}}
Diese Seite hilft euch, eure TU-Mailadresse (deinName@mailbox.tu-berlin.de bzw. vorname.nachname@campus.tu-berlin.de), die von der [[TubIT]] bereitgestellt wird, sowie eure E-Mail-Adresse (deinName@cs.tu-berlin.de) im [[Informatik-Rechnerbetrieb|CS-Netz]] auch von zu Hause aus zu nutzen.

Bei beiden handelt es sich aus historischen Gründen um verschiedene Mailboxen. Er ist empfehlenswert einfach alle mails der CS-Adresse an den tubit-Account weiterzuleiten.

'''Achtung: ''' E-mails an eure TU-Adresse gelten als zugegangen, d.h. beispielsweise bei Änderung eines Prüfungstermins gilt ein "Hab ich nicht gelesen" nicht als Ausrede. Ihr solltet also eure TU-Mails auf jeden Fall regelmäßig lesen!

== Webfrontend ==

Ihr spart euch die ganze Arbeit euren Mailclient konfigurieren zu müssen, wenn ihr einfach das vom [[IRB]] zur Verfügung gestellte [https://mail.cs.tu-berlin.de/mail/ Webinterface] benutzt. Für die neuen reinen TubIT-Accounts ist Webmail über [https://webmail.tu-berlin.de https://webmail.tu-berlin.de] zu benutzen.

== Mailclient ==

Da aber manche Menschen einen richtigen Client vorziehen und das Frontend auch etwas unkomfortabel zu bedienen ist, folgen in den weiteren Abschnitten die Informationen, wie man zu Hause einen Mailclienten wie zum Beispiel KMail, Thunderbird, The Bat! oder auch Outlook einrichten kann.

Weitere Informationen: [http://www.eecs.tu-berlin.de/irb/v-menu/dienste_irb-login/e-mail/e-mail_dienste/ IRB Dokumentation]

Das IRB-Webinterface: [https://mail.cs.tu-berlin.de:4430/src/login.php https://mail.cs.tu-berlin.de:4430/src/login.php] bzw.
Tubit: [https://webmail.tu-berlin.de https://webmail.tu-berlin.de]

=== Emails empfangen ===

Das Abrufen eurer Emails erfolgt ausschließlich per [https://secure.wikimedia.org/wikipedia/de/wiki/IMAP IMAP] oder Webmail. Gegenüber POP3 ist IMAP vorzuziehen, da es die modernere und flexiblere Methode ist. Ausserdem bleiben bei IMAP die Emails in der Regel auf dem Server, so dass ihr auch per Webmail auf die Emails zugreifen könnt, wenn ihr euren Rechner mal nicht dabei habt. (Kann man im Client umstellen, wenn man möchte.)

Zum 30.06.2011 wurde der POP3-Dienst offiziell eingestellt. Der Abruf von E-Mails ist nur noch über den IMAP-Dienst (IMAPS) oder per Webmail möglich. Anleitungen zum Umstellen und weitere Infos unter http://www.tubit.tu-berlin.de/menue/dienste/internet/e-mail/der_e-mail_service/ 

==== IMAP ====

Um einen IMAP Zugang zu konfigurieren, braucht ihr die folgenden Informationen:

mit Tubit-Account:
{|
|Server: || mailbox.tu-berlin.de
|-
|Port: || 993
|-
|Verschlüsselung: || SSL
|-
|Authentifizierung || Passwort, normal
|}

mit altem IRB-Account:
{|
|Server: || mail.cs.tu-berlin.de
|-
|Port: || 993
|-
|Verschlüsselung: || SSL
|}

In beiden Fällen ist 'sichere Authentifizierung' zu deaktivieren, da die Verbindung als solche schon verschlüsselt ist und es nicht funktionieren kann, da die Passwörter auf Serverseite nicht im Klartext vorliegen - was dazu aber Vorraussetzung ist.

Tragt diese Informationen in euer Email-Programm ein und der Empfang sollte funktionieren. Wenn ihr dabei Probleme habt, könnt ihr gerne jemanden von [[Mitglieder_der_Freitagsrunde|uns]] ansprechen.

Auch hier gilt wieder: <strike> Das SSL-Zertifikat wurde von der TU selbst signiert, die Warnung kann ignoriert werden</strike> Es sollte das DFN oder TU-Root-Zertifikat importiert werden: [http://www.tubit.tu-berlin.de/trustcenter/home/ Trustcenter der TUB.]

Weitere Informationen: siehe [http://www.eecs.tu-berlin.de/irb/v-menu/dienste_irb-login/e-mail/e-mail_dienste/ IRB Dokumentation]

=== Emails versenden ===

Mit einem tubit-Account funktioniert das mit folgenden Daten:

{|
|Server: || mailbox.tu-berlin.de
|-
|Port: || 465
|-
|Verschlüsselung: || SSL
|-
|SMTP-Auth (PLAIN oder LOGIN)
|}

Auch hier gilt wieder: Das SSL-Zertifikat wurde von der TU selbst signiert, <strike>die Warnung kann ignoriert werden</strike> importiert das DFN-Zertifikat. 'Sichere Authentifizierung' muss abgeschaltet werden, da dies auf den ersten Blick unlogischerweise das vorliegen der Passwörter im Klartext auf den Servern der TU erfordern würde.

[[Kategorie: Überleben im Fakultätsnetz]]
[[Kategorie: Fakultäts-ABC]]

== Häufige Probleme ==
=== Telekom-Kunde ===
[[Datei:Telekomnutzer.png|thumb|Webinterface]]

Da die Mailserver der TU-Berlin als nicht vertrauenswürdig eingestuft sind, müssen diese per Hand im Router freigegeben werden. Dazu muss lediglich die Adresse des SMTP-Maileingangsservers im Webinterface freigeschaltet werden. Die Logindaten findet ihr auf der Rückseite eures Routers.

=== SpamAssassin ===
Aus irgendeinem Grund hat der SpamAssassin des IRB (mail.cs nicht mailbox) ein Problem damit, wenn man seine eigene IP Adresse beim HELO angibt,
anstelle von cs.tu-berlin.de
Da es aber [http://cr.yp.to/smtp/helo.html Standard] sein sollte, seinen SMTP Server nicht zu belügen,
braucht man sich nicht wundern, wenn alle eigenen EMails bei den Empfängern als Spam markiert verenden.
Der IRB kommentiert die Angabe einer dynamischen IP bei HELO übrigens mit "gefälscht" und "verdächtig".
Klingt komisch, ist aber so.

Christoph

=== Versand wird abgelehnt ===
Wenn beim Mailversand via SMTP die Mail mit dem Fehler
5.7.1<a.b@c.de>: Recipient Adress rejected: Access denied
abgelehnt wird, dann liegt das daran, dass ihr vergesen habt, euch gegenüber dem Mailserver zu authentisieren.

Ihr müsst dafür bei den Verbindungseinstellungen für den TLS-Versand euer CS-Login und Passwort angeben. Siehe Screenshots auf der IRB-Seite [http://www.eecs.tu-berlin.de/irb/v-menu/dienste_irb-login/e-mail/e-mail_dienste/].

=== Mail-Client auf Handys ===
Bei vielen Handys mit E-Mail-Clients und SSL Unterstützung ist die Liste der Stammzertifikate recht klein. Die Folge bei mir (Sony Ericsson K300i) war, dass ich immer die Nachricht "Ungültiges Zertifikat" bekam. Wenn ihr neue Zertifikate hinzufügen könnt, so solltet ihr Versuchen das Zertifikat "Root 5 - Equifax Secure Global eBusiness CA-1" von der Seite http://www.geotrust.com/resources/root_certificates/index.asp zu installieren. Bei mir ging es dann danach :)

Zusatzbemerkung: Ich musste das DER-Zertifikat nehmen und dieses zunächst herunterladen, die Endung von *.cer nach *.der verändern, damit dieses als ein DER-Zertifikat vom Handy erkannt wurde, diese Datei dann wieder auf einen Server laden und mit dem Browser in meinem Handy herunterladen. Das wird jedoch Sony Ericsson Handy spezifisch sein... Genauso wie der Umstand, dass ich zusätzlich SMTP-Benutzer und Passwort nochmal angeben musste, obwohl diese identisch mit denen vom Empfangsserver sind (und dies nach der Hilfe auf dem Handy in diesem Fall angeblich nicht nötig sein soll). Vermutlich benutzt der Mail-Client der SE-Handys erst dann SMTP-Auth. Nun funktioniert aber wirklich alles ;)

Jan Saputra

=== "550-Diese Mail wurde nicht ausgeliefert" ===
Wer an eine (oder mehrere) tu-berlin.de Addressen im ''CC:'' schreibt und das z.B. vom IRB aus, dem kann es passieren das die mails abgelehnt werden:
<pre>
<name@mailbox.tu-berlin.de>: host mail.tu-berlin.de[130.149.7.33]
said: 550-Diese Mail wurde nicht ausgeliefert, weil die
SPAM-Wahrscheinlichkeit 550 95% betraegt. Fuer Hilfe wenden Sie sich bitte
an Postmaster@TU-Berlin.DE. (in reply to end of DATA command)
</pre>

Loesung:
* tu-berlin.de-User direkt ins ''An:'' Feld nehmen
* Bisschen warten und nochmal schicken ''(ungeprueft.. aber ich kann diesen 550-SPAM nicht reproduzieren.. vllt. passierts nur wenn die Message-ID ne Primzahl ist *ironie* )''

CVS

2024-03-12T15:37:53Z

Milan: vgl. https://de.wikipedia.org/wiki/Concurrent_Versions_System

{{veraltet}}
CVS ist die Abkürzung für '''Concurrent Versions System'''. Es dient der
Verwaltung von Dokumenten mit kompletter Änderungshistorie. Dokumente
sind dabei meist Quellcode.

Mehr über CVS siehe [http://de.wikipedia.org/wiki/Concurrent_Versions_System Wikipedia]

== CVS im Fakultätsnetz ==

Ein CVS-Repository kann theoretisch jeder Benutzer in einem Verzeichnis
seines Homedirectories anlegen.

Anmerkung: '''$CVSREPO''' soll hier ein Verzeichnisname sein, in dem das Repository liegen soll, z.B.: CVSREPO="Sem6_VerteilteSysteme"

mkdir ~/'''$CVSREPO'''
cvs -d ~/'''$CVSREPO''' init

Will man das Repository mit einer Arbeitsgruppe teilen, empfiehlt es sich
eine eigenen UNIX-Gruppe im CS-Netz anzulegen, man muss dann dieser Gruppe
Leserechte und Schreibrechte für das Repository-Verzeichnis geben und das Gruppen-Sticky-Bit (chmod g+s) für das Verzeichnis setzen, bevor man das Repository initialisiert.

Leider gibt es bei der Sache einen Haken:

Das cvs-Programm ruft auf den Servern die Funktion getcwd() auf. Diese
schlägt unter Solaris aber offenbar fehl, wenn irgendein Teil des Pfades
nicht lesbar ist. Das bedeutet, dass Ihr allen Gruppen, die auf
Euer Repository zugreifen wollen Leserechte für Euer Homeverzeichnis
geben müsst . (im Zweifel also all...)

chmod 755 '''$HOME'''

Auf jeden Fall sollte man das sticky-bit auf das Repository-Verzeichnis setzen,
damit dor von den anderen Gruppenmitgliedern angelegt Dateien auch der Gruppe
gehören...

chmod 2770 ~/'''$CVSREPO'''

Diese Probleme (und eine Reihe anderer) treten bei der Nutzung von [[Subversion]] (svn) nicht auf!

Opal FAQ

2024-03-12T15:27:31Z

Milan:

{{historisch}}
Vor noch nicht allzu langer Zeit, an einem nicht allzu weit entfernten Ort wurden einst alle Studis von einer schweren Programmiersprache dahingerafft ...

Aber nein! Nicht alle!

Eine kleine Gruppe unermüdlich lernender Studenten widersetzten sich dem Bösen, wild entschlossen diesem Missstand ein ende zu bereiten, setzten sie sich zusammen und schrien "[https://secure.wikimedia.org/wikipedia/de/wiki/FAQ FAQ]-[[Opal]]" gen Himmel...

Nun ja, mehr spare ich mir hier, auf jeden Fall haben "damals" jede menge Leute in der Newsgroup informatik1 (bln.lv.tub.cs.informatik1) gepostet und sehr wertvolle Tips und Tricks zusammengetragen. Diese sind hier aufgeführt mit der ausdrücklichen Bitte, sie zu ergänzen.

Eine weitere (zum Großteil englische) Informationsquelle sind die [http://projects.uebb.tu-berlin.de/opal/trac/wiki/Documentation offiziellen Dokumentationen]. Außerdem gibt es seit 2012 Bestrebungen eine Web-Umgebung für OPAL zu entwickeln. Wer diese nutzen möchte, findet sie unter: http://opal.gehaxelt.in/, auch Entwickler sind herzlich willkommen: https://github.com/gehaxelt/PHP-Webopal/.

__TOC__
==Wie sieht eine OPAL-Struktur aus?==
===Minimalbeispiel für eine OPAL-Struktur===
Na gut, es ginge noch kleiner, aber an diesem Beispiel kann man mehr erklären.
<pre>
SIGNATURE MeineStruktur
IMPORT Nat ONLY nat

FUN meinPlus : nat ** nat -> nat
</pre>
Für die Signatur (MeineStruktur.sign) und
<pre>
IMPLEMENTATION MeineStruktur
IMPORT Nat COMPLETELY

FUN meinPlus : nat ** nat -> nat
DEF meinPlus(a,b) == a + b
</pre>
für die Implementierung (MeineStruktur.impl)

Zuallererst: Der Dateinname (ohne Endung), also der Name der Struktur, muss in der Schreibung exakt mit dem Namen der Signatur (hinter <code>SIGNATURE</code>) und der Implementierung (hinter <code>IMPLEMENTATION</code>) übereinstimmen und darf keine Leerzeichen oder Sonderzeichen enthalten. Nach Übereinkunft werden Strukturnamen mit großem Anfangsbuchstaben geschrieben.

Als nächster Begriff taucht in beiden Dateien <code>IMPORT</code> auf. Hiermit werden andere Strukturen eingebunden. Diese müssen sich entweder im selben Verzeichnis befinden, oder zu OPAL gehören. Darauf folgt der Name der Struktur (im Beispiel Nat für die natürlichen Zahlen). In der Signatur folgt nun der Begriff <code>ONLY</code>. Damit sagt man, dass man nur bestimmte Teile der Struktur benötigt, im Beispiel <code>nat</code> (dies ist die Sorte der natürlichen Zahlen). Was man benötigt ist, in der Signatur, gewöhnlich nur das, was nach dem <code>:</code> steht, ohne die Zeichen <code>**</code> und <code>-></code>.

In der <code>IMPLEMENTATION</code> sieht der Import etwas anders aus: hier wird <code>COMPLETELY</code> benutzt. <code>COMPLETELY</code> bedeutet, dass alles aus der Struktur in importiert wird, in diesem Fall also die Zahlen, Funktionen für Addition und Multiplikation und noch eine ganze Menge mehr (man könnte auch <code>ONLY</code> benutzen, aber dann müsste man jede Funktion, Zahl, usw. hinter dem <code>ONLY</code> notieren). Was nun folgt ist in beiden Dateien wieder das gleiche:
<pre>
FUN meinPlus : nat ** nat -> nat
</pre>
Hiermit wird eine Funktion deklariert, das Schlüsselwort <code>FUN</code> bedeutet, dass an dieser Stelle eine Funktion angekündigt wird. Danach folgt der Name der Funktion (in diesem Fall meinPlus), nach dem Doppelpunkt folgt die Abbildung. Dies Funktion bildet zwei natürlichen Zahlen (<code>nat</code>) auf eine natürliche Zahl ab. Einfacher: die Funktion nimmt zwei Eingabewerte an und gibt einen Wert zurück und alle Werte haben denselben Typ. D.h. es dürfen nur (in diesem Fall) nur Zahlen angegeben werden.

Hier endet die Signatur bereits, denn sie dient nur dazu anderen Strukturen zu zeigen was in der Struktur enthalten ist. Ähnlich einem Taschenrecher: aus der Taste seht ihr das Pluszeichen und wisst: dieser Taschenrechner kann addieren. Was ihr nicht wisst, ist wie intern addiert wird. Bei OPAL steht das in der Implementierung nach dem Begriff <code>DEF</code> für Definition.

===Wie sieht ein Funktions-Deklaration in OPAL aus?===
<pre>
FUN funktion : ausgabe
</pre>
Für eine konstante Funktion. Diese Funktion wird aufgerufen und gibt immer den selben Wert zurück. In OPAL bspw. die Funktion pi, sie gibt immer (näherungsweise) Pi zurück.
<pre>
FUN funktion : eingabe -> ausgabe
</pre>
Für eine Funktion, die zu einem Wert übergeben bekommt und einen Wert zurück gibt. In OPAL bspw. die Funktion <code>~</code> sie erhält einen Wahrheitswert und negiert diesen.
<pre>
FUN funktion : eingabe1 ** eingabe2 -> ausgabe
</pre>
Für eine Funktion, die zwei Werte annimmt (ein Tupel) und daraus einen Wert macht. Beispiele in OPAL sind: <code>+,-,*</code>.
<pre>
FUN funktion : eingabe -> ausgabe1 ** ausgabe2
</pre>
Für eine Funktion, die einen Wert erhält und ein Tupel zurück gibt. Eine solche Funktion könnte bei einem benannten Punkt als Eingabe, die Koordinaten als Tupel zurück geben.

Vor bzw. nach dem <code>-></code> können beliebig viele Eingaben bzw. Ausgabe notiert werden:
<pre>
FUN funktion: eingabe1 ** eingabe2 ** eingabe3 -> ausgabe1 ** ausgabe2
</pre>
Dies Funktion macht aus einem Tripel ein Tupel.

==Wie sieht ein Kommentar in OPAL aus?==
===Warum überhaupt Kommentare?===
Selbst geübte Programmierer wissen bei bestimmten Quelltexten nicht sofort, was sie bedeuten. Das einfachste Mittel um diesen Missstand auszuräumen ist die Nutzung von Kommentaren. Es gehört zum guten Stil seine Projekte angemessen zu kommentieren, außerdem sind Kommentare ein gute Gedächtnisstütze.
===Wie sieht ein Kommentar in OPAL aus?===
In OPAL gibt es zwei Arten von Kommentaren: einzeilige Kommentare und mehrzeilige:
<pre>
-- Ich bin ein Kommentar.
</pre>
Einzeilige Kommentare beginnen mit der Zeichenkombination <code>--</code>, danach muss ein Leerzeichen folgen. Nach diesem Zeichen wird alles bis zum Ende der Zeile als Kommentar gewertet uns nicht weiter interpretiert.
<pre>
/* Ich bin ein
mehrzeiliger Kommentar
/* P.S. Mich kann man verschachteln */
*/
</pre>
Ein mehrzeiliger Kommentar beginnt mit der Zeichenfolge <code>/*</code> (hier muss nicht zwingend danach ein Leerzeichen gesetzt werden). Danach wird alles, was bis zur Zeichenfolge <code>*/</code> geschrieben wurde nicht weiter Interpretiert. Diese Kommentare eignen sich für längere Texte (z.B. Urhebervermerke, Lizenzen) und zum auskommentieren von unfertigem Code:
<pre>
DEF test(<>) == <>
/* Hier ist irgendwo ein Fehler
DEF test(a::A) == IF a > 5 THEN a::<>
ELSE test(A)
<-- fehlt da was?
*/
</pre>
Der vorige Quelltext ist fehlerhaft und würde deshalb nicht ausgeführt werden. Die fehlerhafte Stelle wurde auskommentiert, um das Programm ausführbar zu machen (außerdem wurde zusätzlicher Text vermerkt). D.h. ein Kommentar darf auch Schlüsselwörter enthalten, diese werden aber nicht beachtet.
<pre>
DEF funktion(a,b) == IF a = b -- THEN c
ELSE d
FI
</pre>
Die Funktion würde zu einem Fehler führen, denn das <code>THEN</code> würde nicht mehr interpretiert werden, weil ein Kommentarzeichen davor steht.

== Wie konstruiert man eine Liste? ==
Herzlichen dank für diesen Beitrag an Florian Lorenzen .

> Man kann dann viele aussagekräftige Beispiele mit :: und <>
> angeben (seq, seq[seq], leere seq usw.)

Da ich, wie ich fürchte, mit diesem unsäglichen % angefangen habe -- nicht ahnend welchen didaktischen Flurschaden ich damit anrichten würde -- hier zum Ausgleich einige erklärende Beispiele mit den Listenkonstruktoren.

1. Sei S eine Sequenz aus alphas (FUN S : seq[alpha]).

<pre>
DEF S == a :: b :: c :: d :: <>
</pre>

S ist eine Sequenz aus a, b, c, d und der leeren Liste. Da ::
rechtsassoziativ ist, wird der obige Ausdruck wie folgt aufgelöst:

<pre>
~~~> a :: (b :: (c :: (d :: <>)))
</pre>

Es wird also zunächst eine Liste aus d und <> konstruiert, vor die dann c gehängt wird. Die rekursive Struktur der Liste

<pre>
Liste := Element :: Liste
</pre>

ist deutlich.

<pre>
DEF S == <>
</pre>

S ist eine leere Liste.

Bei langen Elementen kann die Liste der Übersicht halber ohne weiteres auch umgebrochen werden.
<pre>
"laaaaaaaaaaaaaaaaaaaaaaaaaaange Wortguppe" :: "nicht ganz so lange Wortgruppe" :: "etwas kürzere Wortgruppe" :: "noch kürzere Wortgr" :: "noch k" :: <>
</pre>
vs.
<pre>
"laaaaaaaaaaaaaaaaaaaaaaaaaaange Wortguppe"
:: "nicht ganz so lange Wortgruppe"
:: "etwas kuerzere Wortgruppe"
:: "noch kuerzere Wortgr"
:: "noch k"
:: <>
</pre>

2. Sei S eine Sequenz von Sequenzen von alphas (FUN S : seq[seq[alpha]]).

<pre>
DEF S == (a :: b :: c :: <>) :: (d :: e :: <>) :: <>
</pre>

Dieser Ausdruck wird wie folgt aufgelöst:

<pre>
~~~> (a :: b :: c :: <>) :: ((d :: e :: <>) :: <>)
</pre>

Es wird also zuerst eine Liste aus dem (d :: e :: <>) und <> kostruiert, vor die dann das Element (a :: b :: c :: <>) gehängt wird. Das die beiden erwähnten Elemente wiederum Listen sind, ändert nichts daran, wie die äußere Sequenz konstruiert wird.

<pre>
DEF S == (a :: b :: c :: <>) :: <>
</pre>

S ist eine Liste mit gerade genau einem Element, das wiederum eine Liste ist.

<pre>
DEF S == <> :: <> :: <>
</pre>

S ist eine Liste, die aus zwei leeren Listen besteht, nicht aus dreien, wie es zuerst scheint. Dies wird wiederum deutlich, wenn der Ausdruck aufgelöst wird:

<pre>
~~~> <> :: (<> :: <>)
</pre>

In der Klammer wird aus dem Listenelement "<>" durch ":: <>" eine Liste erzeugt, vor die dann das Element "<>" gehängt wird. dass die beiden Elemente der Liste nun leere Listen (dass es Listen seien müssen, ist sowieso klar) sind, ändert nichts daran, wie die äußere Liste konstruiert wird. Man beachte, dass die enstandene Liste nicht leer ist, dass also aus vielen leeren Listen eine nicht-leere Liste entstehen kann.

Eine Liste aus drei leeren Listen sieht dann dementsprechend folgendermaßen aus:

<pre>
DEF S == <> :: <> :: <> :: <>
</pre>

Eine Liste aus einer leeren Liste so:

<pre>
DEF S == <> :: <>
</pre>

Erst die Definition

<pre>
DEF S == <>
</pre>

erzeugt eine Liste von Listen, die wirklich leer ist.

Programmierpraktisch sollte beachtet werden, dass

<pre>
S == <> :: <> oder S == <> :: <> :: <> :: ...
</pre>

nicht durch <>?(S) oder das Muster f(<>) angefangen werden kann, da S eindeutig nicht leer ist.

== Benutzung des Interpreters oasys ==

=== Starten von oasys, Ausführen von Programmen ===
Der OPAL-Interpreter oasys lässt sich von der Shell (auch Terminal oder Konsole) aus starten mit:
<pre>
oasys
</pre>
Um den Interpreter zu verlassen gibt man im Interpreter ein q für Quit ein:
<pre>
> q
</pre>
Hat man nun seine Dateien erstellt (z.B. Aufgabe1.impl und Aufgabe1.sign), muss man diese Dateien zuerst laden. Dafür muss man oasys in dem Verzeichnis starten, in dem die Dateien gespeichert sind. In welchem Verzeichnis ihr euch momentan befindet, erkennt ihr (meistens) an dem Verspann der Konsole.
<pre>
user@opalix ~/MPGI1/HA1/ $
</pre>
Dieser Nutzer befindet sich, ausgehend von seinem Benutzerverzeichnis, im Verzeichnis MPGI1/HA/. Welche Dateien und Ordner sich noch in diesem Verzeichnis befinden, kann man mit dem Befehl <code>ls</code> oder <code>dir</code> herrausfinden. Mir dem Befehl <code>cd</code> kann das Verzeichnis gewechselt werden (in das übergeordnete Verzeichnis gelangt man bspw. mit der Angabe <code>cd ..</code>:
<pre>
user@opalix ~/MPGI1/HA1/ $ cd ..
user@opalix ~/MPGI1/ $
</pre>
Also wechselt in das Verzeichnis wo sich die Dateien Aufgabe1.impl und Aufgabe1.sign beispielsweise befinden und starten von dort aus auf der shell den OPAL-Interpreter oasys. Wenn ihr oasys gestartet habt, könnt ihr das Verzeichnis nur wechseln, wenn ihr oasys vorher beendet (mit dem Befehl <code>q</code>), es ist jedoch ohne Probleme möglich eine weitere Shell zu öffnet und dort oasys in einem anderen Verzeichnis zu starten.

Als nächstes müssen die Dateien dem Interpreter zur Verfügung gestellt werden. Mit dem Interpreter-Befehl a (append file = Datei anfügen) lassen sich Dateien in den Interpreter laden. Dabei gibt man nur den Dateinamen ohne die Dateiendung an (bei langen Namen kann die <code>Tab</code>-Taste zur automatischen Vervollständigung genutzt werden, der Punkt am Ende ist egal).
<pre>
> a Aufgabe1
loading Aufgabe1.impl
loading Aufgabe1.sign
>
</pre>
Wenn die Dateien erfolgreich geladen wurden wird das wie hier in dem Beispiel gezeigt quittiert. Außerdem erstellt oasys ein Verzeichis namens OCS.

Für oasys ist es notwendig, dass man zunächst den Fokus auf eine spezielle Datei legt. Dies erreicht man mit dem Befehl f (f für set focus). Wenn man die impl-Datei fokussiert, kann man auf alle Funktionen zugreifen die in dort implementiert wurden. So kann man aber unter Umständen vergessen eine vernüftige Signature (sign-Datei) zu schreiben und eine entsprechende Kapselung vorzunehmen (wichtig sobald mit mehr als einem Modul gearbeitet wird). Es ist gut sinnvolle Kapselung gleich mit zu lernen.
<pre>
> f Aufgabe1.impl
Aufgabe1.impl>
</pre>
oder: um zu testen welche Funktionen von außen erreichbar sind:
<pre>
> f Aufgabe1.sign
Aufgabe1.sign>
</pre>
Wenn das Fokussieren funktioniert hat, verändert sich eure Eingabe wie im Beispiel angegeben.
Um Funktionen auszuführen befehligt man oasys mit dem Befehl e (e für evaluate). Dabei wird aus der fokussierten Datei eine Funktion mit den Parametern die ihr in der Signatur festgelegt habt ausgewertet. Um diese vielen Begriffe zu verdeutlichen gehen wir mal davon aus, dass wir in der Datei eine Funktion add implementiert haben die zwei ganze Zahlen addiert. Diese Funktion ruft man dann so auf:
<pre>
Aufgabe1.impl>e add(1,2)
starting evaluator process
3
Aufgabe1.impl>
</pre>

=== Eingabe von Zahlen, Denotations (Strings), Sequenzen und einzelne Buchstaben (Chars) ===

Beispiel:
<pre>
> e funktionMitVielenArgumenten("lkajbblsd", "627849"!, 30,"c"!, %(1,23,9,1,8))
</pre>

Erklärung: Das erste Argument ist eine Denotation, d.h. einfach ein String.
Die muss man einfach immer in Anführungszeichen setzen. :)

Das zweite ist eine Zahl. Da sie größer als 32 ist muss man sie als String hinschreiben (Anführungszeichen), den man dann mit dem Operator "!" in eine Zahl umwandeln kann.

Das dritte ist eine kleinere Zahl als 32, daher kann man sie direkt hinschreiben.

Das vierte ist ein Char, also ein einfacher Buchstabe. Da man das nicht direkt eingeben kann übergibt man Opal wieder einen String und wandelt ihn (da er nur einen Buchstaben enthält) mit dem "!" in einen Char um.

Das fünfte ist eine Sequenz, man kann sie direkt in dieser Form
hinschreiben, zu beachten gibt es nur ;) dass man so höchstens 8 Elemente verknüpfen kann. Will man mehr eingeben muss man eben 2 (oder noch mehr) dieser Dinger mit ++ verknüpft hinschreiben.

Diese Art Sequenzen zu schreiben eignet sich für Programmtests, wenn man sich die etwas umständliche Schreibweise sparen möchte. Wenn in einer Aufgabe der Umgang mit Listen geprüft werden soll, wird diese Schreibweise nicht empfohlen, da sie den rekursiven Aufbau der Liste verschleiert. Wenn eine Liste aber ähnlich einer Menge benutzt wird, ist die <code>%</code>-Schreibweise durchaus legitim.

Bsp: eine seq[nat] könnte man also so schreiben.
<pre>
%(4,3,5,8,2,21,5,5) ++ %(6,"78"!,"269"!,"987"!,"654"!,"321"!)
</pre>

Eine seq[seq[nat]] könnte man dann so schreiben
<pre>
%( %(1,3,2), %(1,2,3))
</pre>

(man beachte die notwendige Umwandlung da die Zahlen zum Teil größer als 32 sind. :))

(!!!) Vorsicht (!!!) man sollte im Normalfall keine Leerzeichen zwischen die Argumente setzen! Das funktioniert zwar meistens, leider aber nicht immer!
(Das gilt natürlich nur für die Kommandozeile, in den Syntax-Files selber sind Leerzeichen ziemlich wurscht. :))

Also nochmal: Vorsicht vor Leerzeichen in Funktionsaufrufen!

Ich hatte schon Fehlermeldungen weil ich in Funktionen nach dem Komma ein Leerzeichen eingebaut hatte.

Bsp: func1("9023"!, "0234"!)

Lässt man das weg, funktionierte (bisher) alles:
<pre>
func1("9023"!,"0234"!)
</pre>

Speziell wenn man Texte in Nummern umwandelt (siehe oben) scheint das zu Problemen zu führen. (Dieses Problem hatte ich selbst bisher nur wenn ich von der Shell (Kommandozeile aus direkt Argumente in eine Funktion füttern wollte. Ansonsten trat es nicht auf. :)

=== Oasys an der Shell herumkommandieren: ===

Herzlichen Dank an Roman Lechtchinsky

Warum funktioniert der Aufruf

<pre>
> e f(\\x. 2 * x, 4)
</pre>

unter oasys nicht?

Das liegt daran, dass Du in oasys fuer jeden Backslash \\ eingeben muss, also

<pre>
> e f(\\\\x. ...)
</pre>

Das hat nichts mit OPAL zu tun, sondern mit der Skript-Sprache (TCL), in der
das Interpreter-Frontend implementiert ist (nehme ich zumindest an).
Anm.: angeblich ist die readline-Bibliothek verantwortlich...

Alternativ kann man das quote von TCL (das sind geschweifte Klammern) um den ganzen Ausdruck legen, dann kann man es auch bequem, wie in einer Datei eingeben, also

<pre>
> e {f(\\x. 2 * x, 4)}
</pre>

==Fehler/Probleme mit OPAL ==

=== Warum funktionieren Zahlen über 32 nicht? ===

In [[Opal]] sind die Zahlen auch Funktionen (genauer konstante Funktionen), d.h. wenn eine Zahl eingeben wird, wird eine Funktion mit dem Namen der Zahl ausgeführt, die die Zahl als Wert zurückgibt. Deshalb müsste für jede Zahl eine Funktion existieren. Da das nicht möglich ist, gibt es eine Funktion, die eine Zeichenkette (denotation) in eine Zahl umwandelt. Diese Funktion heißt <code>!</code>:
<pre>
"zahl"!
</pre>
Aber warum funktioniert das bei Zahlen unter 32 auch ohne diese Funktion? Naja, einige Zahlen sind für bequemeres Eingeben doch als Funktion definiert:

Die Zahlen von <code>0</code>-<code>32</code>, die Zweierpotenzen <code>64,128,256,512,1024</code> und die Zahlen <code>100, 1000, 10000, 100000, 1000000</code>. Daneben gibt es noch die Konstanten <code>pi</code> und <code>e</code> für die ludolfsche Zahl (Pi) und die eulersche Zahl.

=== Warum funktionieren (manchmal) auch Zahlen unter 32 nicht? ===

Dies ist meistens der Fall, wenn das Programm mit oasys über die Signatur aufgerufen wird. In der Signatur werden meistens nur die Sorten (bspw. <code>nat</code>, <code>denotation</code>) importiert, da Zahlen auch Funktionen sind, müsste man diese auch importieren. Etwas flexibler ist es, die Umwandlungsfunktion <code>!</code> zu importieren. Dann müssen zwar alle Zahlen erst von einer Zeichenkette umgewandelt werden, aber so kann man überhaupt mit Zahlen arbeiten:
<pre>
IMPORT Nat ONLY nat !
</pre>
Natürlich kann man auch <code>COMPLETELY</code> statt <code>ONLY</code> benutzen. Dies wird aber teilweise als schlechter Stil empfunden.

=== Warum funktionieren Kommazahlen nicht? ===
Zuallererst: Kommazahlen werden in Opal mit einem Punkt notiert, bspw. ist <code>3,14159</code> in Opal <code>3.14159</code>.

Wie bei der [[#Warum_funktionieren_Zahlen_.C3.BCber_32_nicht.3F | Frage zu Zahlen über 32]] bereits beschrieben, müssten gleich benutzbare Zahlen als (konstante) Funktion in einer Struktur definiert (und deklariert) sein. Das ist nicht der Fall (außer bei <code>pi</code> und <code>e</code>). Der Standardfehler den <code>oasys</code> in diesem Fall ausgibt ist:
<pre>
ERROR [at ...] no matching operation for .
ERROR [check] language error
</pre>

<code>oasys</code> hält also das Komma (den Punkt) für eine (binäre) Funktion. Um Kommazahlen in Opal zu benutzen, müssen sie "kontruiert" werden. Hierfür enthalten Strukturen, die Kommazahlen nutzen, die Funktion <code>!</code>. Kommazahlen werden also als Denotation geschrieben: "<code>3,14159</code>" und dann mit der (unären) Funktion <code>!</code> umgewandelt: !"<code>3,14159</code>" oder "<code>3,14159</code>"!, inbesondere bei der Nutzung in längeren Gleichungen oder der oasys-Eingabe kann dieses Ausrufezeichen (da unär) schon einmal für unerwartete Fehler sorgen (mehr dazu [[#Was_ist_Pr.C3.A4fix-.2C_Infix-_und_Postfixnotation.3F|Was ist Präfix-, Infix- und Postfix-Notation?]]).

=== Warum kann man Denotations immer nutzen und Zahlen nicht? ===

Wenn eine OPAL-Struktur interpretiert (und später übersetzt) wird, lädt der Interpreter bestimmte Strukturen automatisch. Diese heißen bspw. <code>BOOL</code> und <code>DENOTATION</code> und stellen elementare Funktionen zur Verfügung. Deshalb kann man ohne den Import von irgendwelchen Strukturen IF-THEN-ELSE-Konstrukte in OPAL nutzen und mit Denotations arbeiten (nicht aber mit Zahlen, denn die werden nicht automatisch importiert). Die in der Schreibung ähnlichen Strukturen <code>Bool</code> und <code>Denotation</code> stellen aber noch weitere Funktionen zur Verfügung, deshalb müssen sie gelegentlich doch importiert werden.

=== Warum wird meine Backtick-Funktion (`) nicht benutzt? ===

Die Backtick-Funktion für eigene Datentypen muss in der .sign-Datei mit deklariert sein.

=== Warum funktioniert WHERE nicht ohne weiteres mit Lambda-Ausdrücken? ===

Wenn man Lambda mit WHERE kombinieren will muss man den ganzen Body der Funktion klammern

Das geht so:
<pre>
DEF qsolve1 == \\ a, b, c .( /* <--- */
(x1, x2)
WHERE
x1 == (-(b) + d) / (2 * a)
x2 == (-(b) - d) / (2 * a)
d == sqrt((b * b) - (4 * a * c))

) /* <----- */
</pre>

Wichtig ist dabei, dass nach dem Punkt, mit dem der Lambda Ausdruck die Argumentliste abschließt, kein Leerzeichen oder irgendetwas anderes ist, sondern gleich die öffnende Klammer kommt. Ansonsten funktioniert es nicht!

=== Häufige Fehlermeldungen ===

Folgende Fehlermeldung ist ziemlich haeufig:

==== Expected ... instead of .... ====

Hier handelt es sich um einen einfachen Syntaxfehler. Falls Ihr meint, alles korrekt geschrieben zu haben, überprueft auch nochmal die Klammerung der Ausdrücke (es muss genausoviele öffnende wie schliessende Klammern geben). Vielleicht ist ja auch nur ein FI vergessen worden...

==== Expected was `:' instead of `->' ====

Dieser Fehler kann trotz korrekt vorhandenem <code>:</code> auftreten. Beispiel:
FUN `: nat -> stream -> denotation
erzeugt den Fehler, dahingegen
FUN ` : nat -> stream -> denotation
nicht.

Es hilft also eventuell das Einfügen von Whitespace.

==== improperly named function definition target or parameter ... ====

In diesem Fall sollte man ueberpruefen, ob die Deklaration der Funktion (FUN ...) fehlt. Vielleicht ist gerade dieser Teil auskommentiert, oder man hat schlicht und einfach vergessen, die Signaturdatei zu speichern. Mir ist letzteres auch schon unterlaufen, d.h. man sucht nach einem Fehler, der eigentlich nicht vorhanden ist.

==== missing else in ... ====

Passiert, wenn bei der Verwendung des Dijkstra-IFs während der Auswertung ein Fall eingetreten ist, der nicht abgedeckt wird. Bei dieser Funktion würde es z.B. bei testeZahl(10) auftreten:
DEF testeZahl(x) == IF x > 10 THEN true IF x < 10 THEN false FI
Es müsste ein < oder > durch <= bzw. >= ersetzt werden, oder der Fall = explizit aufgeführt werden.

==== ambigious infix application ====

Dieser Fehler deutet darauf hin, dass bei Infix-Notation die Klammern nicht eindeutig gesetzt werden konnten. Ein Beispiel sind die logischen Funktionen <code>/\</code> (und) und <code>\/</code> (oder). Opal hat hierfür keine Klammerregelung, der Ausdruck
<pre>
false /\ true \/ true
</pre>
kann auf zwei Arten geklammert werden: entweder <code>'''('''false /\ true''')''' \/ true</code> (ausgewertet zu true) oder <code>false /\ '''('''true \/ true''')'''</code> (ausgewertet zu false).

=== Was ist Präfix-, Infix- und Postfixnotation? ===
...oder wie man Minuszeichen hassen lernt.

Bei der '''Präfix'''-Notation wird der Funktionsname vor den Argumenten geschrieben, bspw. <code>!"33"</code>, oder +(3,5). Bei Funktionen mit mehr als einem Parameter müssen die Argumente in Klammern gesetzt und durch Kommas getrennt werden.

Die '''Infix'''-Notation ist nur bei zweistelligen (oder binären) Funktionen möglich (also Funktionen mit genau zwei Parametern). Beispiele dafür sind die Funktionen <code>+, /\, *,</code> usw.:
<pre>
5 + 6
true /\ false
4 * 6
</pre>
Bei den meisten zweistelligen Funktione sind auch solche Konstruktionen möglich: <code>3 + 4 + 9 + 2</code>, die Klammerung wird implizit vorgenommen, auch Mischungen wie <code>3 + 4 * 7 + 3</code> werden den mathematischen Gesetzen entsprechend geklammert.

Die '''Postfix'''-Notation ähnelt der Präfix-Notation, nur dass hier hier der Funktionsname nach den Parametern notiert wird. Bspw. <code>"33"!</code> oder <code>(6,3)-</code>.

Insbesondere bei einstelligen (unären) Funktionen, wie <code>!</code>, oder <code>-</code> (als Vorzeichen), kommt es öfter zu solchen Fehlermeldungen:

<pre>
ERROR [HOF.impl at 32.5-32.33]: undefined identification
1. <32,5-33> wrongly typed implementation
left: real->real
right: ((nat**nat->nat)->real)->real
2. <32,5-33> wrongly typed implementation
left: real->real
right: ((real**real->real)->real)->real
3. <32,5-33> wrongly typed implementation
left: real->real
right: ((real->real)->real)->real

ERROR [check]: language error
aborted
</pre>

Könnte das etwas mit dem Gebrauch von Minuszeichen zu tun haben. :(

Ich hatte größte Schwierigkeiten den folgenden Code zum Funktionieren zu überreden, Code-Zeilen wie das hier:

<pre>
FUN test : ( real -> real ) -> ( real -> real )
DEF test( r ) == \\ x . r( -x )
</pre>

Funktionieren nicht.

Das Problem ist das der Compiler für das minuszeichen ( r( -x )) zwei Argumente zu erwarten scheint. (Obwohl er das laut Spezifikation nicht müsste)

Die Löung lag für mich darin entweder "0 - x" zu schreiben oder das x in eigene Klammern zu setzen ( x ). Beides funktioniert hier.

Einen änlichen Fehler hatte ich als ich so etwas schreib: " a - b + c "

Ich musste das dann als ( a - ( b + c ) ) schreiben damit es
funktionierte.

Hope it helps!

Hier habe ich noch eine Erklärung von Klaus Didrich bekommen (thx!)

Das Prinzip, dass Funktionen keine Sonderbehandlung erfahren, erstreckt sich auch auf das unäre Minuszeichen. Folgendes geht:

<pre>
-(1) (analog zu "f(1)")
(1-) (analog etwa zu "(5!)")
</pre>

Dein Problem mit "a - b + c" kann ich allerdings nicht nachvollziehen.

Und gleich nochmal etwas, hierfür danke ich Archi Varius.

<pre>
+ ( 0, 1 ) = 0 + 1 = ( 0, 1 ) +

! 5 = 120 = 5 !

- 1 = 1 -
</pre>

Und nochmal. :)) Diesmal herzlichen Dank wieder an Klaus Didrich.

Wird den in [[Opal]], jeder Infixoperator der nur einen Operand bekommt hinter
den Operand geschrieben wird? (Das fände ich ja etwas beschränkt...)

:Es ist viel schlimmer :-) Es ist beides möglich. Du kannst jeden einstelligen Operator auch hinter den Operanden schreiben, dazu brauchst Du keine besondere Deklaration.

:Ob man IF <>?(S) THEN ... oder IF S <>? THEN ... schreibt, macht keinen Unterschied. Eine Mischung aus Postfix- und Infix-Applikationen kann der Compiler leider nicht analysieren, da kommt dann die Meldung "no possible bracketing for infix found". In dem Fall hilft Klammern: (5!) + 3, (S#) > 0

:Auch bei zweistelligen Funktionen kann man es sich aussuchen, ob man die Präfix- oder die Infixschreibweise vorzieht: +(5,3) oder 3 + 5 sind beide erlaubt.

=== Opal und Zugriffsrechte (ext2 versus fat) ===
Herzlichen Dank für diesen Tip an Thomas Brinker!

==== Du setzt [[Opal]] unter [[Linux]] ein ====

[[Opal]]-fehlermeldung:
Operation not permitted

Grund:
Die Dateien liegen nicht in einer ext2-Partition sondern in einer
FAT-Partition. (in FAT geht das mit den named Pipes nicht)

Abhilfe:

Dateien in ext2 Partition umkopieren. Alternativ die aktuelle Opal-Version 2.3m
benutzen, wenn /tmp auf einer Partition liegt, die named Pipes unterstützt.

==== Du setzt [[Opalix]] unter VirtualBox mit Shared Folders ein ====

Im Grunde das gleiche wie vorher, siehe [[Opalix 2007#Fehler:_Operation_not_permitted|Opalix-Seite]].

=== Was bedeutet ein Fehler in Zeile 0? ===

Bei einem ansonsten korrekten Programm hat mich diese Fehlermeldung vorhin eine laaange Fehlerjagd gekostet...

<pre>
Person.impl>e Birthday(date(30,12,"79"!)
ERROR [at 0.3-0.4]: Expected was `)' instead of `IN'
ERROR [check]: language error
aborted
</pre>

In diesem Fall hatte ich auf der Eingebe-Zeile im Interpreter eine schließende Klammer vergessen. :))

Man kann diese Fehler recht leicht erkennen. Sie finden immer auf Zeile '''0''' statt. Das ist die Eingabe-Zeile in der Shell. :))
(" ERROR [at 0.3-0.4]:")

Der Fehler muss folglich auch nicht immer ein Syntax-Fehler sein (wie oben), sondern kann auch durch die Sprache in der die Eingabe von <code>oasys</code> programmiert ist hervorgerufen werden (siehe [[#Oasys_an_der_Shell_herumkommandieren: | Oasys an der Shell herumkommandieren]]).

=== Nicht nachvollziehbare Laufzeitfehler ===

Wenn das eigene Programm eine Struktur S enthält und die Bibliotheca Opalica ebenfalls eine Struktur S bereitstellt, kann es unter Umständen zu nicht nachvollziehbaren Laufzeitfehlern komen, wie etwa

<pre>
RUNTIME ERROR: TreeConv at <252,5-11> : missing else in asSeqIn'TreeConv:tree**seq->seq
Aborted (core dumped)
</pre>

unter Ubuntu oder

<pre>
Bus Error (core dumped)
</pre>

unter Solaris 10 Sparc.

In diesem Fall enthält das Programm eine Struktur Tree und die Bibliotheca Opalica hat ebenfalls eine solche Struktur.

Die einzige Lösung des Problems ist die Umbenennung der Struktur S, da alle zu einem Opal-Programm gelinkten Strukutren verschiedene Namen haben müssen. Eine Übersicht aller in der Bibliotheca Opalica vorhandenen Strukturen gibt es bspw. über den "Structure Index" der Dokumentation: http://projects.uebb.tu-berlin.de/opal/dosfop/latest/bibopalicaman/Structure_Index.html, Alternativ können die Befehle <code>l</code>, oder <code>ll</code> (umfangreicher als <code>l</code>) in oasys benutzt werden.

Es ist ein Bug im Opal-Compiler, dass in solchen Fällen keine Fehlermeldung ausgegeben wird, sondern es so aussieht als ob das Programm korrekt übersetzt wurde. Details können in diesem Ticket nachgelesen werden: http://projects.uebb.tu-berlin.de/opal/trac/ticket/50

Unter MacOS X tritt das Problem aufgrund des Mach-O Formats und einer anderen Link-Semantik nicht auf.

=== oasys: Too many open files ===

oasys detektiert einen verboteten zyklischen Import innerhalb von IMPLEMENTATIONs nicht.

Es gibt stattdessen die Fehlermeldung sobald eine Funktion des Programms ausgewertet wird:
<pre>
starting evaluator process
sh: 1: 1: Too many open files
evaluator: cannot retrieve symbols of `pconn-in-289-25/10/94'
connection lost
</pre>

Ausserdem werden im temporären Verzeichnis (z. B. /tmp) Unmengen von Dateien liegengelassen.

Zyklische Importe sind in Opal verboten. Die einzige Losung ist also eine Umstrukturierung des Programms. Der Opal-Compiler ocs detektiert das Problem korrekt.

== Hilfreiche Tipps ==

=== Zwischenergebnisse zur Fehlersuche ausgeben (<code>printf</code>-Debugging) ===

Oftmals wünscht man sich eine Möglichkeit, Zwischenergebnisse auf der Konsole auszugeben, z.B. um Fehler zu finden und den Programmablauf zu verfolgen. Da man in einer rein-funktionalen Sprache wie Opal nicht einfach ein <code>printf</code> einfügen kann, muss man etwas tricksen. Mit Hilfe der "Funktion" <code>EXEC</code> aus der <code>Com</code>-Struktur kann aus dem Ablauf heraus Text ausgeben, da sie eine Möglichkeit darstellt, Seiteneffekte auszufühen. Das sieht dann so aus:

<pre>
SIGNATURE DebugHelper[ResultType]

SORT ResultType

FUN || : ResultType ** denotation -> ResultType
</pre>

<pre>
IMPLEMENTATION DebugHelper[ResultType]

IMPORT Com COMPLETELY
Stream COMPLETELY
ComCompose COMPLETELY

FUN || : ResultType ** denotation -> ResultType
DEF result || msg == EXEC(writeLine(stdOut, msg); succeed(result))
</pre>

Speichert die beiden Code-Schnippsel in den Dateien <code>DebugHelper.{sign,impl}</code> und schon könnt ihr auf einfachste Weise Debug ausgaben machen. Schreibt dafür einfach die Debugausgabe auf die rechte Seite des "Debugoperators" <code>||</code>.

Beispiel:
<pre>
IMPLEMENTATION Beispiel

IMPORT Nat COMPLETELY
NatConv COMPLETELY
Denotation COMPLETELY
DebugHelper COMPLETELY

FUN foo: nat ** nat -> nat
DEF foo(x, y) ==
LET
res == (x + y) || "in x=" ++ `(x) ++ " y=" ++ `(y)
IN
res || "out =" ++ `(res)
</pre>

Output:
<pre>
Beispiel.impl>e foo(2,3)
starting evaluator process
in x=2 y=3 <<----- Debug
out =5 <<----- Infos
5
Beispiel.impl>
</pre>

Ähnliche Funktionalität bietet auch die <code>DEBUG</code> Struktur aus der Bibliotheca Opalica, allerdings sind dort die Funktionen IMHO nicht ganz so schön einzubauen.

=== Syntax Highlighting ===

Anleitungen und Vorgaben zum [[Opal Syntax-Highlighting]] finden sich auf einer extra Seite.

=== Opal-Quelltexte mit TeX/LaTeX setzen ===

[[WikiPedia:TeX|TeX]]/[[WikiPedia:LaTeX|LaTeX]] ist ein sehr mächtiges Textsatzsystem, das für kleinere Dokumente über Diplomarbeiten bis hin zu kompletten Büchern verwendet werden kann.

Da liegt es nahe, einfach auch Hausaufgaben optisch ansprechend in hoher Qualität damit setzen zu lassen.

Für das Setzen von Quellcodes gibt es u.a. das [ftp://ftp.tex.ac.uk/tex-archive/macros/latex/contrib/listings/listings.pdf Listings-Package] für TeX/LaTeX. Hier gibt es jedoch kein vordefiniertes Syntax-Highlighting für OPAL. Außerdem steht die opal2x.sty [http://projects.uebb.tu-berlin.de/opal/trac/raw-attachment/wiki/Documentation/dokopal2x.pdf], [http://projects.uebb.tu-berlin.de/opal/trac/raw-attachment/wiki/Documentation/opal2x.tar.gz] zur Verfügung.

[[Kategorie: Opal]]

=== Opal für Windows ===

Kurz: Es gibt kein Opal für [[Windows]].

Lang: Jedenfalls in keiner benutzbaren Fassung. Im Rahmen einer Dissertation entsteht zwar Opal.NET (also Opal für die MS .NET Plattform), diese Version wird jedoch vorraussichtlich nicht als "stable release" erscheinen.

=== Opal unter Cygwin ===

Opal unter Cygwin wird nicht von der PSS Gruppe unterstützt und funktioniert erfahrungsgemäß '''nicht'''.

Erfahrungsbericht von Tobias Deichmann in der Info1 Newsgroup:

:''...also ich hab mich da letztes Jahr knapp 4 Wochen lang dran probiert und kann dir nur einen Tipp geben: Lass es.''

:''Hab es zwar soweit geschafft, dass wenigstens einige Kommandozeilenbasierende OPAL-Programme wenigstens halbwegs fehlerfrei liefen (ok, sie stürzten trotzdem einigermaßen oft ab oder wir man das auch immer bezeichnen möchte), aber das richtige Problem kommt erst, wenn du das Ganze dann noch mit der grafischen Java Benutzeroperfläche (kurz GUI) von OPAL verwenden willst. Da funktioniert dann gar keins der Programme, es zerschießt dir dabei regelmäig die komplette cygwin bzw. OPAL Installation und es ist einfach nervig. Mein Rat an dich ist also, es lieber mit Opalix oder sonstwas zu probieren, als dich durch cygwin zu quälen, denn das führt eigentlich zu nichts...''

Als Alternative bieten sich [[Opalix]] und [[Opal für Linux]] an.

=== Opal via SSH ===

Eine weitere Möglichkeit Opal von Zuhause aus zu benutzen ist sich über SSH auf einen der Uni-Server zu verbinden und so "remote" zu arbeiten. Welche Server zur Verfügung stehen und wie SSH benutzt wird steht auf der [[SSH|SSH-Seite]].

==Tabellen und Listen==
Anmerkung: Die folgenden Tabellen werden noch erweitert.

===Wichtige Strukturen===
{| class="wikitable sortable"
! Name !! class="unsortable" style="text-align:left" | Inhalt !! class="unsortable" style="text-align:left" | Auswahl von Funktionen
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Nat.html#SEC82 Nat]
| Stellt Funktionen und Sorten der natürlichen Zahlen bereit
| +,-,*,div,mod
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/NatConv.html#SEC98 NatConv]
| Stellt Funktionen zur Umwandlung von natürlichen Zahlen in andere Typen bereit
| asChar, asInt, asReal, `
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Real.html#SEC88 Real]
| Stellt Funktionen und Sorten der reellen Zahlen bereit
| +,-,*,/
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/RealConv.html#SEC100 RealConv]
| Stellt Funktionen zur Umwandlung von reellen Zahlen in andere Typen bereit
| asNat, asInt, `, ``
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Int.html#SEC75 Int]
| Stellt Funktionen und Sorten der ganzen Zahlen bereit
| +,-,*,div,mod
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/IntConv.html#SEC96 IntConv]
| Stellt Funktionen zur Umwandlung von reellen Zahlen in andere Typen bereit
| asNat, asReal, `
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Bool.html#SEC24 Bool]
| Stellt Funtionen und Sorten für boolsche Ausdrücke zur Verfügung
| /\, \/, =>
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/BoolConv.html#SEC30 BoolConv]
| Stellt eine Funktion zur Umwandlung von Wahrheitswerten (true/false) in Text zu Verfügung
| nur `
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Char.html#SEC48 Char]
| Stellt Funktionen für Buchstaben und Zeichen/Eingaben zur Verfügung
| pred, newline, lower?, whitespace?
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/CharConv.html#SEC61 CharConv]
| Stellt Funktionen zur Umwandlung von Buchstaben/Zeichen zur Verfügung
| `, asNat, asDigitNat
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Denotation.html#SEC50 Denotation]
| Stellt Funktionen für Textverarbeitung zur Verfügung
| #, slice, empty?
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/String.html#SEC287 String]
| Stellt Funktion für dynamische Textverarbeitung bereit
| #, empty?, ++, %
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/StringConv.html#SEC301 StringConv]
| Stellt Funktionen zur Umwandlung von Zeichenketten bereit
| asSeq, asString, `
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Seq.html#SEC215 Seq]
| Stellt Grundfunktionen für die Arbeit mit Listen zur Verfügung
| <>, ::, exist?, %
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/SeqConv.html#SEC229 SeqConv]
| Stellt eine Grundfunktion zur Umwandlung von Listen bereit
| nur `
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/SeqFilter.html#SEC231 SeqFilter]
| Stellt eine Filterfunktion auf Listen zzgl. Hilfsfunktionen zur Verfügung
| filter, partition, split
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/SeqMap.html#SEC240 SeqMap]
| Enthält eine Funktion zur Umwandlung von Listen
| nur map oder *
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/SeqReduce.html#SEC247 SeqReduce]
| Stellt Funktionen zur Reduktion von Listen bereit
| reduce oder /, \
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/SeqZip.html#SEC255 SeqZip]
| Stellt Funktionen zum Zusammenfügen und Zertrennen von Listen zur Verfügung
| zip, unzip
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Option.html#SEC189 Option]
| Stellt einen Zugriffstyp und Zugriffsfunktionen für Datentypen zur Verfügung
| cont, <, =
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Compose.html#SEC109 Compose]
| Stellt Funktionen zur Komposition von Funktionen bereit
| o, ;
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Tree.html#SEC325 Tree]
| Stellt Grundfunktionen zur Arbeit mit Bäumen zur Verfügung
| lrotate, %, #
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/TreeConv.html#SEC368 TreeConv]
| Stellt Funktionen zur visuell ansprechenden Ausgabe von Bäumen bereit
| asSeqIn, `, graphic
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Com.html#SEC844 Com]
| Stellt Grundfunktionen für die Behandlung von Monaden bereit
| succeed, yield, break
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/ComCompose.html#SEC846 ComCompose]
| Funktionen zur Komposition von Monaden
| &, ;
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/BasicIO.html#SEC915 BasicIO]
| Stellt Grundfunktionen für Ein- und Ausgabe bereit
| ask, writeLine, write
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/File.html#SEC943 File]
| Stellt Funktionen für den Dateizugriff zu Verfügung
| open, reopen, close
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Void.html#SEC36 Void]
| Stellt einen leeren Datentyp bereit (wichtig für Monaden)
| nur void (Datentyp)
|}
Außerdem stellt OPAL die Struktur [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Basics.html#IDX201 Basics] zur Verfügung, diese lädt automatisch folgende Strukturen:
[http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/ABORT.html#SEC19 ABORT],
[http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/BOOL.html#SEC15 BOOL],
[http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Bool.html#SEC24 Bool],
[http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/BoolConv.html#SEC30 BoolConv],
[http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Char.html#SEC48 Char],
[http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/CharConv.html#SEC61 CharConv],
[http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/DENOTATION.html#SEC17 DENOTATION],
[http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Denotation.html#SEC50 Denotation],
[http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Int.html#SEC75 Int],
[http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/IntConv.html#SEC96 IntConv],
[http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Nat.html#SEC82 Nat],
[http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/NatConv.html#SEC98 NatConv],
[http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Real.html#SEC88 Real],
[http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/RealConv.html#SEC100 RealConv].

'''Hinweis:''' Einige Strukturen importieren bereits andere, die Einzelheiten finden sich in der Referenz.

===Interessante Strukturen===
Anmerkung: Diese Strukturen werden im Studium nicht zwingend behandelt, enthalten aber interessante Zusatzinformationen und erleichtern die Arbeit, wenn man über die Studieninhalte hinaus mit OPAL experimentieren möchte. Einige Strukturen sind auch hilfreich bei der sinnvollen Strukturierung von eigenen Strukturen (auch bei Hausaufgaben).

{| class="wikitable sortable"
! Name !! class="unsortable" style="text-align:left" | Inhalt !! class="unsortable" style="text-align:left" | Auswahl von Funktionen
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/ABORT.html#IDX56 ABORT]
| Lässt eigene Fehlerbehandlungstexte zu
| nur ABORT
|-
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Set.html#SEC482 Set]
| Struktur die Funktionen und Typen auf Mengen enthält
| {}, incl, forall?
|}

===Wichtige Funktionen===
'''Anmerkung:''' Funktionen mit demselben Namen verhalten sich in verschiedenen Strukturen ähnlich (Prinzip der Orthogonalität). Einige Funktionen heißen aber auch gleich und machen völlig verschiedene Dinge. Für viele Funktionen gibt es mehrere Namen.
{| class="wikitable sortable"
! Name !! class="unsortable" style="text-align:left" | weitere Namen !! class="unsortable" style="text-align:left" | Beschreibung !! class="unsortable" style="text-align:left" | enthalten in
|-
| div
| /
| Divisions-Operator (für ganze Zahlen)
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Nat.html#IDX1225 Nat], [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Int.html#SEC75 Int]
|-
| mod
| %
| Rest der ganzzahligen Division
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Nat.html#IDX1225 Nat], [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Int.html#SEC75 Int]
|-
| /
| keine
| Divisionsoperator
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Real.html#SEC88 Real]
|-
| pow
| ^
| Potenzfunktion
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Nat.html#IDX1225 Nat], [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Int.html#SEC75 Int], [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Real.html#SEC88 Real]
|-
| ++
| keine
| Konkatenation von Werten
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Denotation.html#SEC50 Denotation], [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/String.html#SEC287 String], [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Seq.html#SEC215 Seq]
|-
| even?
| keine
| Gibt an, ob eine Zahle gerade ist
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Nat.html#IDX1225 Nat], [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Int.html#SEC75 Int]
|-
| odd?
| keine
| Gibt an, ob eine Zahl ungerade ist
| [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Nat.html#IDX1225 Nat], [http://projects.uebb.tu-berlin.de/opal/dosfop/2.4a/bibopalicaman/Int.html#SEC75 Int]
|}

===Wichtige oasys-Befehle===
Mehr zu dieser Tabelle: http://projects.uebb.tu-berlin.de/opal/trac/raw-attachment/wiki/Documentation/OasysManual.pdf
{| class="wikitable sortable"
! Befehl !! class="unsortable" style="text-align:left" | <abbr title="Langform">LF</abbr> !! class="unsortable" style="text-align:left" | Bedeutung !! class="unsortable" style="text-align:left" | Beispiel
|-
| a
| append
| Füge eine Struktur hinzu
| <code>a MeineStruktur</code>
|-
| f
| focus
| Öffne einen Teil der Struktur (Signatur oder Implementierung)
| <code>f MeineStruktur.impl</code>
|-
| e
| evaluate
| Werte einen Ausdruck aus
| <code>e meineFunktion(12,"33"!)</code>
|-
| ex
| evaluate execute
| Werte einen Ausdruck aus, führe die resultierenden Kommandos aus
| <code>ex meineMonadenFunktion</code>
|-
| x
| execute
| Führe das Kommando (die Funktion) aus
| <code>x meineMonadenFunktion</code>
|-
| r
| reload
| Erzwingt das Neuladen von veränderten Strukturen
| <code>r</code> ohne Argument
|-
| l, ll
| list
| Liste alle bekannten Strukturen auf (l: Kurzversion, ll: Langversion)
| <code>l</code>, oder <code>ll</code> ohne Argument
|}

Softwaretechnik und Programmierparadigmen

2024-03-08T12:16:03Z

Milan:

'''Softwaretechnik und Programmierparadigmen (SWTPP)''' gibt (zumindest laut Modulbeschreibung) eine Einführung im Bereich Softwareengineering und behandelt die Programmiersprachen Haskell, OCL und Prolog, sowie das Hoare-Kalkül.

'''TL;DR: '''
VL sind useless, Haskell selber lernen & mit HA rechtzeitig anfangen, Tutorien lohnen sich, Spickzettel vollmachen

== Guide ==
Die Modulbewertung (95er Schlüssel) setzt sich aus einer Hausaufgabe (30P), einem MC-Test (20P) und einer Klausur (50P) zusammen.

=== Lehrangebot ===
Die Vorlesungen sind (Stand WiSe 23/24) wenig lehrreich. Es werden einfache Inhalte durch- und Programmiersprachen vorgekaut, Komplizierteres (Hoare) wird nicht gut erklärt. Es lohnt sich daher, die Inhalte auf eigene Faust zu lernen, indem du die Folien durchgehst, ggf. googelst und bei Unklarheiten Tutor*Innen fragst.

Die Tutorien sind einigermaßen interessant gestaltet und die TutorInnen cool. Tutorienbesuch verringert den Lernaufwand später erheblich, da genau die Aufgabenformate behandelt werden, die dann auch in Test und Klausur rankommen. Es werden auch Fallstricke in der Klausur genannt und Tipps gegeben. Geh einfach hin.

=== Haskell-Hausaufgabe ===
Haskell ist eine funktionale Progammiersprache, die nicht unbedingt intuitiv ist. Anstatt mit den VL-Folien zu lernen, empfielt es sich, die ersten sechs Kapitel des kostenlosen Online-Buches [https://learnyouahaskell.github.io/chapters.html "Learn you a Haskell for great good"] durchzuarbeiten, davon klaut Glesner auch nur.

Die Hausaufgabe ist idR. interessant und machbar, wenn du '''rechtzeitig''' anfängst: Einfach direkt, wenn du Haskell nicht kannst. Solltest du Haskell können, oder in anderen Programmiermodulen keine Probleme gehabt haben, plane 2-3 Wochen, je nach Pensum, ein. Die Sprechstunden sind am Schluss überfüllt.

=== Test ===
Im ersten Test kamen Prolog und Programmierparadigmen dran. Hier in die Tutorien gehen und Alttests durcharbeiten.
Suche im Netz ein Prolog-Cheat sheet und schreib, das was du brauchst, auf den Spickzettel.

=== Klausur ===
In der Klausur kamen MC-Fragen, Diagramme, OCL und das Hoare-Kalkül dran. Man durfte 3 Blätter (6 Seiten) Spickzettel benutzen. Für die MC-Fragen lohnt es sich, Notizen aus der VL auf den Spicker zu schreiben.
Für OCL die wichtigen Funktionen (auch hier: Cheat sheet) auf den Spickzettel schreiben. Für die Diagramme und Hoare in die Tutorien gehen und Altklausuren durchrechnen. Hoare gab dieses Jahr einfache Punkte mit nur wenig Übung.

Softwaretechnik und Programmierparadigmen

2024-03-08T12:14:14Z

Milan:

'''Softwaretechnik und Programmierparadigmen (SWTPP)''' gibt (zumindest laut Modulbeschreibung) eine Einführung im Bereich Softwareengineering und behandelt die Programmiersprachen Haskell, OCL und Prolog, sowie das Hoare-Kalkül.

'''TL;DR: '''
VL sind useless, Haskell selber lernen & mit HA rechtzeitig anfangen, Tutorien lohnen sich, Spickzettel vollmachen

== Guide ==
Die Modulbewertung (95er Schlüssel) setzt sich aus einer Hausaufgabe (30P), einem MC-Test (20P) und einer Klausur (50P) zusammen.

=== Lehrangebot ===
Die Vorlesungen sind (Stand WiSe 23/24) wenig lehrreich. Es werden einfache Inhalte durch- und Programmiersprachen vorgekaut, Komplizierteres (Hoare) wird nicht gut erklärt. Es lohnt sich daher, die Inhalte auf eigene Faust zu lernen, indem du die Folien durchgehst, ggf. googelst und bei Unklarheiten Tutor*Innen fragst.

Die Tutorien sind einigermaßen interessant gestaltet und die TutorInnen cool. Tutorienbesuch verringert den Lernaufwand später erheblich, da genau die Aufgabenformate behandelt werden, die dann auch in Test und Klausur rankommen. Es werden auch Fallstricke in der Klausur genannt und Tipps gegeben. Geh einfach hin.

=== Haskell-Hausaufgabe ===
Haskell ist eine funktionale Progammiersprache, die nicht unbedingt intuitiv ist. Anstatt mit den VL-Folien zu lernen, empfielt es sich, die ersten sechs Kapitel des kostenlosen Online-Buches [https://learnyouahaskell.github.io/chapters.html "Learn you a Haskell for great good"] durchzuarbeiten, davon klaut Glesner auch nur.

Die Hausaufgabe ist idR. interessant und machbar, wenn man '''rechtzeitig''' anfängt: Einfach direkt, wenn du Haskell nicht kannst. Solltest du Haskell können, oder in anderen Programmiermodulen keine Probleme gehabt haben, plane 2-3 Wochen, je nach Pensum, ein. Die Sprechstunden sind am Schluss überfüllt.

=== Test ===
Im ersten Test kamen Prolog und Programmierparadigmen dran. Hier in die Tutorien gehen und Alttests durcharbeiten.
Suche im Netz ein Prolog-Cheat sheet und schreib, das was du brauchst, auf den Spickzettel.

=== Klausur ===
In der Klausur kamen MC-Fragen, Diagramme, OCL und das Hoare-Kalkül dran. Man durfte 3 Blätter (6 Seiten) Spickzettel benutzen. Für die MC-Fragen lohnt es sich, Notizen aus der VL auf den Spicker zu schreiben.
Für OCL die wichtigen Funktionen (auch hier: Cheat sheet) auf den Spickzettel schreiben. Für die Diagramme und Hoare in die Tutorien gehen und Altklausuren durchrechnen. Hoare gab dieses Jahr einfache Punkte mit nur wenig Übung.

Softwaretechnik und Programmierparadigmen

2024-03-06T19:12:45Z

Milan:

'''Softwaretechnik und Programmierparadigmen (SWTPP)''' gibt (zumindest laut Modulbeschreibung) eine Einführung im Bereich Softwareengineering und behandelt die Programmiersprachen Haskell, OCL und Prolog, sowie das Hoare-Kalkül.

'''TL;DR: '''
VL sind useless, Haskell selber lernen & mit HA rechtzeitig anfangen, Tutorien lohnen sich, Spickzettel vollmachen

== Guide ==
Die Modulbewertung (95er Schlüssel) setzt sich aus einer Hausaufgabe (30P), einem MC-Test (20P) und einer Klausur (50P) zusammen.

=== Lehrangebot ===
Die Vorlesungen sind (Stand WiSe 23/24) wenig lehrreich. Es werden einfache Inhalte durch- und Programmiersprachen vorgekaut, Komplizierteres (Hoare) wird nicht gut erklärt. Es lohnt sich daher, die Inhalte auf eigene Faust zu lernen, indem du die Folien durchgehst, ggf. googelst und bei Unklarheiten Tutor*Innen fragst.

Die Tutorien sind einigermaßen interessant gestaltet. Tutorienbesuch verringert den Lernaufwand später erheblich, da genau die Aufgabenformate behandelt werden, die dann auch in Test und Klausur rankommen. Es werden auch Fallstricke in der Klausur genannt und Tipps gegeben. Geh einfach hin.

=== Haskell-Hausaufgabe ===
Haskell ist eine funktionale Progammiersprache, die nicht unbedingt intuitiv ist. Anstatt mit den VL-Folien zu lernen, empfielt es sich, die ersten sechs Kapitel des kostenlosen Online-Buches [https://learnyouahaskell.github.io/chapters.html "Learn you a Haskell for great good"] durchzuarbeiten, davon klaut Glesner auch nur.

Die Hausaufgabe ist idR. interessant und machbar, wenn man '''rechtzeitig''' anfängt: Einfach direkt, wenn du Haskell nicht kannst. Solltest du Haskell können, oder in anderen Programmiermodulen keine Probleme gehabt haben, plane 2-3 Wochen, je nach Pensum, ein. Die Sprechstunden sind am Schluss überfüllt.

=== Test ===
Im ersten Test kamen Prolog und Programmierparadigmen dran. Hier in die Tutorien gehen und Alttests durcharbeiten.
Suche im Netz ein Prolog-Cheat sheet und schreib, das was du brauchst, auf den Spickzettel.

=== Klausur ===
In der Klausur kamen MC-Fragen, Diagramme, OCL und das Hoare-Kalkül dran. Man durfte 3 Blätter (6 Seiten) Spickzettel benutzen. Für die MC-Fragen lohnt es sich, Notizen aus der VL auf den Spicker zu schreiben.
Für OCL die wichtigen Funktionen (auch hier: Cheat sheet) auf den Spickzettel schreiben. Für die Diagramme und Hoare in die Tutorien gehen und Altklausuren durchrechnen. Hoare gab dieses Jahr einfache Punkte mit nur wenig Übung.

Softwaretechnik und Programmierparadigmen

2024-03-06T19:11:02Z

Milan: 3. sg. -> 2. sg; grammar

'''Softwaretechnik und Programmierparadigmen (SWTPP)''' gibt (zumindest laut Modulbeschreibung) eine Einführung im Bereich Softwareengineering und behandelt die Programmiersprachen Haskell, OCL und Prolog, sowie das Hoare-Kalkül.

'''TL;DR: '''
VL sind useless, Haskell selber lernen & mit HA rechtzeitig anfangen, Tutorien lohnen sich, Spickzettel vollmachen

== Guide ==
Die Modulbewertung (95er Schlüssel) setzt sich aus einer Hausaufgabe (30P), einem MC-Test (20P) und einer Klausur (50P) zusammen.

=== Lehrangebot ===
Die Vorlesungen sind (Stand WiSe 23/24) wenig lehrreich. Es werden einfache Inhalte durch- und Programmiersprachen vorgekaut, Komplizierteres (Hoare) wird nicht gut erklärt. Es lohnt sich daher, die Inhalte auf eigene Faust zu lernen, indem du die Folien durchgehst, ggf. googelst und bei Unklarheiten Tutor*Innen fragst.

Die Tutorien sind einigermaßen interessant gestaltet. Tutorienbesuch verringert den Lernaufwand später erheblich, da genau die Aufgabenformate behandelt werden, die dann auch in Test und Klausur rankommen. Es werden auch Fallstricke in der Klausur genannt und Tipps gegeben. Geh einfach hin.

=== Haskell-Hausaufgabe ===
Haskell ist eine funktionale Progammiersprache, die nicht unbedingt intuitiv ist. Anstatt mit den VL-Folien zu lernen, empfielt es sich, die ersten sechs Kapitel des kostenlosen Online-Buches [https://learnyouahaskell.github.io/chapters.html "Learn you a Haskell for great good"] durchzuarbeiten, davon klaut Glesner auch nur.
Die Hausaufgabe ist idR. interessant und machbar, wenn man '''rechtzeitig''' anfängt: Einfach direkt, wenn du Haskell nicht kannst. Solltest du Haskell können, oder in anderen Programmiermodulen keine Probleme gehabt haben, plane 2-3 Wochen, je nach Pensum, ein. Die Sprechstunden sind am Schluss überfüllt.

=== Test ===
Im ersten Test kamen Prolog und Programmierparadigmen dran. Hier in die Tutorien gehen und Alttests durcharbeiten.
Suche im Netz ein Prolog-Cheat sheet und schreib, das was du brauchst, auf den Spickzettel.

=== Klausur ===
In der Klausur kamen MC-Fragen, Diagramme, OCL und das Hoare-Kalkül dran. Man durfte 3 Blätter (6 Seiten) Spickzettel benutzen. Für die MC-Fragen lohnt es sich, Notizen aus der VL auf den Spicker zu schreiben.
Für OCL die wichtigen Funktionen (auch hier: Cheat sheet) auf den Spickzettel schreiben. Für die Diagramme und Hoare in die Tutorien gehen und Altklausuren durchrechnen. Hoare gab dieses Jahr einfache Punkte mit nur wenig Übung.

Cafe Shila

2024-03-06T16:34:53Z

Milan:

Das '''Café Shila''' ist ein studentisch geführtes Café an der TU Berlin hinter dem Mathegebäude.

Generell ist man im Shila hilfsbereit, aber hässlich.

Ansonsten gilt das Shila als das beste Café der Uni. Wenn es nicht gerade schimmelt.

== Angebote==
* Mate
* Kaffee (0,4€)
* Tee (versch. Sorten)
* Bier
* Sekt
* Wein
* Cola
* Spezi
* Limo (Proviant, schiebt anders)
* Wasser laut & leise
* Schokolade fest & flüssig
* Erdnüsse

* man kann hier auch die örtliche Mikrowelle nutzen

== Siehe auch ==
* [[I-cafe]]

* [https://maps.app.goo.gl/puBafydEHK8SeE4k6 Google-Maps-Link]

[[Kategorie:Wichtige Orte]]
[[Kategorie:Fakultäts-ABC]]

Cafe Shila

2024-03-06T16:29:03Z

Milan:

Das '''Café Shila''' ist ein studentisch geführtes Café an der TU Berlin hinter dem Mathegebäude.

Generell ist man im Shila hilfsbereit, aber hässlich.

Ansonsten gilt das Shila als das beste Café der Uni. Wenn es nicht gerade schimmelt.

== Angebote==
* Mate
* Kaffee (0,4€)
* Tee (versch. Sorten)
* Bier
* Sekt
* Wein
* Cola
* Spezi
* Limo (Proviant, schiebt anders)
* Wasser laut & leise
* Schokolade Block & heiß
* Erdnüsse

* man kann hier auch die örtliche Mikrowelle nutzen

== Siehe auch ==
* [[I-cafe]]

* [https://maps.app.goo.gl/puBafydEHK8SeE4k6 Google-Maps-Link]

[[Kategorie:Wichtige Orte]]
[[Kategorie:Fakultäts-ABC]]

Cafe Shila

2024-03-06T16:28:34Z

Milan: update :)

Das '''Café Shila''' ist ein studentisch geführtes Café an der TU Berlin hinter dem Mathegebäude.

Generell ist man im Shila hilfsbereit, ebenso wie bei der Freitagsrunde. Also ebenso einfach fragen!

Ansonsten gilt das Shila als das beste Café der Uni. Wenn es nicht gerade schimmelt.

== Angebote==
* Mate
* Kaffee (0,4€)
* Tee (versch. Sorten)
* Bier
* Sekt
* Wein
* Cola
* Spezi
* Limo (Proviant, schiebt anders)
* Wasser laut & leise
* Schokolade Block & heiß
* Erdnüsse

* man kann hier auch die örtliche Mikrowelle nutzen

== Siehe auch ==
* [[I-cafe]]

* [https://maps.app.goo.gl/puBafydEHK8SeE4k6 Google-Maps-Link]

[[Kategorie:Wichtige Orte]]
[[Kategorie:Fakultäts-ABC]]

Softwaretechnik und Programmierparadigmen

2024-03-04T15:23:17Z

Milan: updated swtpp

Softwaretechnik und Programmierparadigmen (SWTPP) gibt (auf dem Papier) eine Einführung im Bereich Softwareengineering und behandelt die Programmiersprachen Haskell, OCL und Prolog, sowie das Hoare-Kalkül.

'''TL;DR: '''
VL sind useless, Haskell selber lernen & mit HA rechtzeitig anfangen, Tutorien lohnen sich, Spickzettel vollmachen

== Guide ==
Die Modulbewertung (95er Schlüssel) setzt sich aus einer Hausaufgabe (30P), einem MC-Test(20P) und einer Klausur(50P) zusammen.

=== Lehrangebot ===
Die Vorlesungen sind (Stand WiSe 23/24) wenig lehrreich. Es werden ewig lange einfache Sachen durch- und Programmiersprachen vorgekaut, Komplizierteres (Hoare) wird nicht gut erklärt. Es lohnt sich sehr, die Inhalte auf eigene Faust zu lernen, indem man die Folien durchgeht, ggf. googelt und bei Unklarheiten Tutor*Innen fragt.

Die Tutorien sind einigermaßen interessant gestaltet. Tutorienbesuch verringert den Lernaufwand für Test und Klausur erheblich, da Aufgabenformate genau behandelt werden, die dann auch rankommen. Es werden auch Fallstricke in der Klausur genannt und Tipps gegeben.

=== Haskell-Hausaufgabe ===
Haskell ist eine funktionale Progammiersprache, die nicht unbedingt intuitiv ist. Anstatt die VL zu benutzen, empfielt es sich, die ersten sechs Kapitel des kostenlosen Online-Buches [https://learnyouahaskell.github.io/chapters.html "Learn you a Haskell for great good"] durchzuarbeiten, davon klaut Glesner auch nur.
Die Hausaufgabe ist idR. interessant und machbar, wenn man '''rechtzeitig''' anfängt - einfach direkt, wenn man Haskell nicht kann. Die Sprechstunden sind am Schluss überfüllt.

=== Test ===
Im ersten Test kamen Prolog und Programmierparadigmen dran. Hier in die Tutorien gehen und Alttests durcharbeiten.
Suche im Netz ein Prolog-Cheat sheet und schreib, das was du brauchst es auf den Spickzettel.

=== Klausur ===
In der Klausur kamen MC-Fragen, Diagramme, OCL und das Hoare-Kalkül dran. Man durfte 3 Blätter (6 Seiten) Spickzettel benutzen. Für die MC-Fragen lohnt es sich, Notizen aus der VL auf den Spicker zu schreiben.
Für OCL die wichtigen Funktionen auf den Spickzettel schreiben. Für die Diagramme und Hoare in die Tutorien gehen und Altklausuren durchrechnen. Hoare gab dieses Jahr einfache Punkte mit nur wenig Übung.

Softwaretechnik und Programmierparadigmen

2024-03-04T13:30:54Z

Milan: added SWTPP Guide

Softwaretechnik und Programmierparadigmen (SWTPP) gibt (auf dem Papier) eine Einführung im Bereich Softwareengineering und behandelt die Programmiersprachen Haskell, OCL und Prolog, sowie das Hoare-Kalkül.

'''TL;DR: '''
VL sind useless, Haskell selber lernen & mit HA rechtzeitig anfangen, Tutorien lohnen sich, Spickzettel vollmachen

== Guide ==
Die Modulbewertung (95er Schlüssel) setzt sich aus einer Hausaufgabe (30P), einem MC-Test(20P) und einer Klausur(50P) zusammen.

=== Lehrangebot ===
Die Vorlesungen sind (Stand WiSe 23/24) wenig lehrreich. Es werden ewig lange einfache Sachen durch- und Programmiersprachen vorgekaut, Komplizierteres (Hoare) wird nicht gut erklärt. Es lohnt sich sehr, die Inhalte auf eigene Faust zu lernen, indem man die Folien durchgeht, ggf. googelt und bei Unklarheiten Tutor*Innen fragt.

Die Tutorien sind einigermaßen interessant gestaltet. Tutorienbesuch verringert den Lernaufwand für Test und Klausur erheblich, da Aufgabenformate genau behandelt werden, die dann auch rankommen. Es werden auch Fallstricke in der Klausur genannt und Tipps gegeben.

=== Haskell-Hausaufgabe ===
Haskell ist eine funktionale Progammiersprache, die nicht unbedingt intuitiv ist. Anstatt die VL zu benutzen, empfielt es sich, die ersten sechs Kapitel des kostenlosen Online-Buches [https://learnyouahaskell.github.io/chapters.html "Learn you a Haskell for great good"] durchzuarbeiten, das klaut Glesner auch nur.
Die Hausaufgabe ist idR. interessant und machbar, wenn man '''rechtzeitig''' anfängt - einfach direkt, wenn man Haskell nicht kann. Die Sprechstunden sind am Schluss überfüllt.

=== Test ===
Im ersten Test kamen Prolog und Programmierparadigmen dran. Hier in die Tutorien gehen und Alttests durcharbeiten.
Suche im Netz ein Prolog-Cheat sheet und schreib es auf den Spickzettel.

=== Klausur ===
In der Klausur kamen MC-Fragen, Diagramme, OCL und das Hoare-Kalkül dran. Man durfte 3 Blätter (6 Seiten) Spickzettel benutzen. Für die MC-Fragen lohnt es sich, Notizen aus der VL auf den Spicker zu schreiben.
Für OCL die wichtigen Funktionen auf den Spickzettel schreiben. Für die Diagramme und Hoare in die Tutorien gehen und Altklausuren durchrechnen.

Jobs

2024-02-28T20:33:08Z

Milan:

Die Uni ist ein wunderbarer Platz, um gute Leute zu finden, die auch noch für wenig Geld arbeiten. Das wissen Unternehmen und deshalb kleben sie die Pinwände unserer Gebäude mit Stellenangeboten zu. Wer keine Lust hat, durch die Uni zu laufen (Laufen ist überbewertet), der kann sich entweder hier im Wiki umschauen oder sich an unserer Jobs-Mailingliste anmelden.

Und wer ein Job-Angebot bekannt machen möchte, der kann einfach an die Mailingliste schreiben und muss nicht mehr mühselig Zettel kleben. Bitte die [[Mailingliste:Jobs|Anleitung]] beachten.

== Was für Jobs gibt es ==

Es gibt…
* Stellen als [[Arbeiten_an_der_TU|Tutor*in (auch studentische*r Mitarbeiter*in)]] an der TU,
* viel zu tun [[Jobs in der Freitagsrunde|in der Freitagsrunde]] – unbezahlt, aber nicht umsonst ;-)
* Jobs auch außerhalb der Uni

== Wie ist die Bezahlung? ==

* Meist Verhandlungssache
* Viele richten sich nach dem Regelstundensatz der TU Berlin für Tutor*inn*en (~14 Euro/Stunde) oder locken mit geringfügig mehr

== Hinweise ==
Denke daran, dass du - vor allem kurz vor Studienabschluss - eine qualifizierte Arbeitskraft für lau bist. Du musst zwar eingearbeitet werden, aber das müssen alle, bei dir dauert das eventuell nur etwas länger. Zur Orientierung: in der freien Wirtschaft ist ein Stundenlohn von ~20€ auch ohne Abschluss durchaus möglich.
Ansonsten sollten Arbeitszeiten und Stundenzahl mit dem Studium und deiner aktuellen Situation vereinbar sein.
Homeoffice ist nach Corona in einigen Firmen der Standard.

== Wo findet man Jobs? ==

* Auf der [https://tub.stellenticket.de/de/welcome/ Stellenticket-Seite der TU Berlin]
* oder auf unserer Jobs-Liste: '''[mailto:jobs@lists.freitagsrunde.org jobs@lists.freitagsrunde.org]'''
** [http://lists.freitagsrunde.org/mailman/listinfo/jobs An- und Abmeldung]
** [http://lists.freitagsrunde.org/pipermail/jobs/ Archiv]
* [https://www.innocampus.tu-berlin.de/jobs/ Aktuelle Ausschreibungen bei innoCampus (ehem. MuLF)]

== Jobs anbieten ==

Wer Jobs hat, kann über [[Mailingliste:Jobs|unsere Mailingliste]] Ausschreibungen einfach an suchende Studierende schicken.

[[Kategorie: Uni-ABC]]
__FORCETOC__

Jobs

2024-02-28T20:28:29Z

Milan:

Die Uni ist ein wunderbarer Platz, um gute Leute zu finden, die auch noch für wenig Geld arbeiten. Das wissen Unternehmen und deshalb kleben sie die Pinwände unserer Gebäude mit Stellenangeboten zu. Wer keine Lust hat, durch die Uni zu laufen (Laufen ist überbewertet), der kann sich entweder hier im Wiki umschauen oder sich an unserer Jobs-Mailingliste anmelden.

Und wer ein Job-Angebot bekannt machen möchte, der kann einfach an die Mailingliste schreiben und muss nicht mehr mühselig Zettel kleben. Bitte die [[Mailingliste:Jobs|Anleitung]] beachten.

== Was für Jobs gibt es ==

Es gibt…
* Stellen als [[Arbeiten_an_der_TU|Tutor*in (auch studentische*r Mitarbeiter*in)]] an der TU,
* viel zu tun [[Jobs in der Freitagsrunde|in der Freitagsrunde]] – unbezahlt, aber nicht umsonst ;-)
* Jobs auch außerhalb der Uni

== Wie ist die Bezahlung? ==

* Meist Verhandlungssache
* Viele richten sich nach dem Regelstundensatz der TU Berlin für Tutor*inn*en (~14 Euro/Stunde) oder locken mit geringfügig mehr

Denke daran, dass du - vor allem kurz vor Studienabschluss - eine qualifizierte Arbeitskraft für lau bist. Du musst zwar eingearbeitet werden, aber das müssen alle, bei dir dauert das eventuell nur etwas länger. Zur Orientierung: in der freien Wirtschaft ist ein Stundenlohn von ~20€ auch ohne Abschluss durchaus möglich. Ansonsten kann man immer noch an den Arbeitszeiten und -länge verhandeln, so dass sie mit dem Studium vereinbar sind.

== Wo findet man Jobs? ==

* Auf der [https://tub.stellenticket.de/de/welcome/ Stellenticket-Seite der TU Berlin]
* oder auf unserer Jobs-Liste: '''[mailto:jobs@lists.freitagsrunde.org jobs@lists.freitagsrunde.org]'''
** [http://lists.freitagsrunde.org/mailman/listinfo/jobs An- und Abmeldung]
** [http://lists.freitagsrunde.org/pipermail/jobs/ Archiv]
* [https://www.innocampus.tu-berlin.de/jobs/ Aktuelle Ausschreibungen bei innoCampus (ehem. MuLF)]

== Jobs anbieten ==

Wer Jobs hat, kann über [[Mailingliste:Jobs|unsere Mailingliste]] Ausschreibungen einfach an suchende Studierende schicken.

[[Kategorie: Uni-ABC]]
__FORCETOC__

Jobs

2024-02-28T20:28:05Z

Milan: Hungerlohn erhöht, eigenen Senf dazugegeben

Die Uni ist ein wunderbarer Platz, um gute Leute zu finden, die auch noch für wenig Geld arbeiten. Das wissen Unternehmen und deshalb kleben sie die Pinwände unserer Gebäude mit Stellenangeboten zu. Wer keine Lust hat, durch die Uni zu laufen (Laufen ist überbewertet), der kann sich entweder hier im Wiki umschauen oder sich an unserer Jobs-Mailingliste anmelden.

Und wer ein Job-Angebot bekannt machen möchte, der kann einfach an die Mailingliste schreiben und muss nicht mehr mühselig Zettel kleben. Bitte die [[Mailingliste:Jobs|Anleitung]] beachten.

== Was für Jobs gibt es ==

Es gibt…
* Stellen als [[Arbeiten_an_der_TU|Tutor*in (auch studentische*r Mitarbeiter*in)]] an der TU,
* viel zu tun [[Jobs in der Freitagsrunde|in der Freitagsrunde]] – unbezahlt, aber nicht umsonst ;-)
* Jobs auch außerhalb der Uni

== Wie ist die Bezahlung? ==

* Meist Verhandlungssache
* Viele richten sich nach dem Regelstundensatz der TU Berlin für Tutor*inn*en (~14 Euro/Stunde) oder locken mit geringfügig mehr

Denke daran, dass du - vor allem kurz vor Studienabschluss - eine qualifizierte Arbeitskraft für lau bist. Du musst zwar eingearbeitet werden, aber das müssen alle, bei dir dauert das eventuell nur etwas länger. Zur Orientierung: in der Freien Wirtschaft ist ein Stundenlohn von ~20€ auch ohne Abschluss durchaus möglich. Ansonsten kann man immer noch an den Arbeitszeiten und -länge verhandeln, so dass sie mit dem Studium vereinbar sind.

== Wo findet man Jobs? ==

* Auf der [https://tub.stellenticket.de/de/welcome/ Stellenticket-Seite der TU Berlin]
* oder auf unserer Jobs-Liste: '''[mailto:jobs@lists.freitagsrunde.org jobs@lists.freitagsrunde.org]'''
** [http://lists.freitagsrunde.org/mailman/listinfo/jobs An- und Abmeldung]
** [http://lists.freitagsrunde.org/pipermail/jobs/ Archiv]
* [https://www.innocampus.tu-berlin.de/jobs/ Aktuelle Ausschreibungen bei innoCampus (ehem. MuLF)]

== Jobs anbieten ==

Wer Jobs hat, kann über [[Mailingliste:Jobs|unsere Mailingliste]] Ausschreibungen einfach an suchende Studierende schicken.

[[Kategorie: Uni-ABC]]
__FORCETOC__

Tipps zum richtigen Studieren

2024-02-28T20:16:25Z

Milan: typo

== Lehrveranstaltungen ==

* [[gute Gruppen finden|Sucht euch eine gut funktionierende Lern-Gruppe]]. (Dreiergruppen sind am besten. Andere Größen taugen nicht viel im Vergleich. Wenn ihr keine Wahl habt, trefft euch zu noch größeren Gruppen und teilt euch dann in Dreiergruppen auf.)
** Am besten ist es, wenn eine Gruppe für mehrere Veranstaltungen besteht, da es sich besser koordinieren lässt.
** Gut funktionierend heißt, ihr macht alle die Hausaufgaben zusammen. Nicht einer TechGI, einer TheGI, etc.
* '''immer''' die Hausaufgaben machen
* Mitschriften von Vorlesungen immer nachbereiten, sprich: erstens, alles nochmal durchgehen und prüfen, ob alles verstanden wurde. Und zweitens, nochmal ins Reine schreiben, was du aus Zeitmangeln nur hingekritzelt hast, sonst kannst du es später, wenn du für Klausuren lernst, nicht mehr lesen.
* Zwei Tutorien sind manchmal besser als ein Tutorium und eine schlechte Vorlesung (vor allem am Anfang)
* Es lohnt sich, zwischen zwei Veranstaltungen Freistunden zu haben, weil man dann Zeit für Hausaufgaben hat - außerdem haben da automatisch alle Gruppenmitglieder Zeit.
* Habt keine Scheu, eine neue Gruppe zu bilden, wenn es nicht klappt. Sprecht mit den Tutoren, das Wechseln geht fast immer
* Habt nicht den Anspruch, dass es im ersten Semester gleich mit allen Gruppen super klappen muss - sucht euch für das neue Semester im Zweifel neue Leute oder bildet mit den Leuten aus euren Gruppen in denen es klappt eine neue Gruppe.

== Prüfungen ==
* Wenn ihr auf Klausuren lernt, holt euch [[Klausurensammlung|alte Klausuren]] und rechnet die durch. Wichtig: Erst zu dritt durchrechnen, dann gegenseitig korrigieren und ERST DANN in die Musterlösung schauen. Nichts ist schlimmer als die Lösung zuerst anzuschauen, da man dann denkt: "Och, das kann ich ja...". Den Fehler macht zwar trotzdem jeder, aber steter Tropfen höhlt den Stein... :)
* Bitte achtet auf die StuPO. Egal was ein Sekretariat besser wissen möchte - die Fristen sind durch die StuPO festgelegt. Ein Beispiel: Zu einer Klausur (für PÄS gelten andere Regelungen) kann sich der Student bis zu 3 Werktage vor dem Prüfungstermin abmelden. Diese Frist ist in der StuPO §13 festgelegt und kann durch kein Sekretariat außer Kraft gesetzt werden. Spätere Abmeldungen führen automatisch zu: "Prüfungsleistung nicht bestanden". Ausnahme: Nachweis einer Krankmeldung.
* Auch wenn es andere machen: Das Schieben von Klausuren ist der Anfang vom Ende! Klar, Ausreden gibt es viele warum du es dieses Semester auf keinen Fall schaffen kannst, für die Klausur zu lernen, aber mal ganz ehrlich, wird es später besser werden...?

== Angebote der Uni und andere Services ==
* Als Student habt ihr nicht nur Vergünstigungen im täglichen Leben, sondern auch noch andere Möglichkeiten, kostenlos an sonst teure Dinge zu kommen:
** Über Kooperationen der [[Bibliothek|Uni-Bibliothek]] habt ihr Zugang zu vielen Online-Zeitschriften und IEEE/ACM-Datenbanken mit wissenschaftlichen Texten
** Die Fakultät 4 hat ein Programm mit Microsoft und ermöglicht Euch den [[MSDNAA|kostenlosen Download von Windows, Visual Studio und mehr]].
** Im [[Lötlabor]] und in [[Cafeterien | studentischen Cafes]] ([[Cafe Shila]], [[icafe]]) findet viel Leben statt, man kann Freunde treffen und Freizeit verbringen.
* [http://www.tu-sport.de/ Uni-Sport] hat ein riesiges Angebot. Es ist günstig, macht Spaß, hält fit und man lernt neue Leute kennen!
* Es gibt einen "[[Brötchenmann]]" der durch die Räume läuft und euch relativ günstig leckere Brötchen/Salate verkauft-

* Der Gründungsservice der TU vermittelt Hilfe/Erfahrung/Kontakte[[Gründungsservice TU Berlin | Gründungsservice TU Berlin]]

== Freitagsrunde ==
* Melde dich auf unserer [[Infoliste]] an, um immer über aktuelle Entwicklungen in der Freitagsrunde oder an der Uni informiert zu sein.
* Besuche uns bei unseren [[FR 5046|Treffen freitags]], und melde dich auf der [[Freitagsrunde:fopen|fopen-Diskussionsliste]] an, wo sich unsere wöchentlichen Protokolle finden.
* [[Mitmachen|Hilf uns]], wenn Du etwas hast, mit dem Du dich einbringen kannst!

== Beratungsstellen ==

Und schließlich gibt es noch diverse [[Beratungsstellen]] die auf die Uni verteilt sind.

== Arbeiten ==
* es gibt auch die Möglichkeit [[Arbeiten an der TU |an der TU zu arbeiten]]. Dies erspart einem meist größere Wege und ist eigentlich sehr gut bezahlt.
* Wer Arbeit sucht kann auf der [[Jobs]]-Wikiseite gucken

[[Kategorie:Einführungswoche]]
[[Kategorie: Uni-ABC]]
[[Kategorie: Fakultäts-ABC]]

Aktuelle Ereignisse

2024-02-28T20:10:37Z

Milan: Weiterleitungsziel von Termine nach Aktuelles geändert

#REDIRECT [[Aktuelles]]

Campus

2024-02-28T20:06:10Z

Milan: find super, dass ihr ne richtig nice karte im Git habt, die aber einfach nicht benutzt. Wenn die wer eingebettet kriegt, go, habs auf die Schnelle nicht hingekriegt.

Der '''Hauptcampus''' der TU Berlin befindet sich in Charlottenburg, rund um den Ernst-Reuter-Platz. Ein zweiter Campus liegt im Technologie- und Innovationspark Berlin im Bezirk Wedding. Darüber hinaus gibt es vereinzelt Standorte im Norden und Süden der Stadt.

== Karten ==
* [https://docs.freitagsrunde.org/E-Woche/2020/SoSe/Campus_Map/ Karte der Freitagsrunde]
* [https://www.tu.berlin/studieren/uni-leben/campusplan Hier finden sich Lagepläne aller Gebäude]
* [https://asta.tu-berlin.de/campusplan/ Alternativer Campusplan des AStA]
* Siehe auch: [[Liste von Hörsälen]]

[[Kategorie:Gebäude]]
[[Kategorie:Navigation]]
[[Kategorie:Uni-ABC]]

Vorlage:Vortrag

2024-02-27T18:49:17Z

Milan: hilfe

= {{{titel|{{ARTICLEPAGENAMEE}}}}} =
[[Kategorie:Meta:Löschen]]
Vortragende:
: {{{vortragende|Vortragende gesucht!}}}

Ort: '''{{{ort|''Folgt demnächst''}}}'''

=== Themen ===
{{{themen|''Folgt demnächst''}}}

=== Folien ===
{{{folien|''Folgt demnächst''}}}

=== Zusatzmaterialien ===
{{{zusatzmaterialien|''Folgt demnächst''}}}

==== Mitschnitte ====
{{{mitschnitte|''Folgt demnächst''}}}
 

[[Kategorie:CKurs]]

Vorlage:Tutorium

2024-02-27T18:48:57Z

Milan: loser artikel, kann weg

== {{{titel|{{ARTICLEPAGENAMEE}}}}} ==
[[Kategorie:Meta:Löschen]]

Tutoren/innen:
: {{{tutoren|Tutanten gesucht!}}}

=== Ort ===
{{{ort|
: '''Tel 106'''
: '''Tel 206'''}}}

=== Themen ===
{{{themen|''Folgt demnächst''}}}

=== Unterlagen ===
{{{unterlagen|''Folgt demnächst''}}}

=== Zusatzmaterialien ===
{{{zusatzmaterialien|''Folgt demnächst''}}}

==== Inhaltlich passende Mitschnitte ====
{{{mitschnitte|''Folgt demnächst''}}}
 

=== Anmerkungen für nächstes Jahr ===
{{{anmerkungen|}}}

[[Kategorie:CKurs]]

Campus

2024-02-27T18:36:38Z

Milan: Links aktualisiert, Alternativen Campusplan hinzugefügt

Der '''Hauptcampus''' der TU Berlin befindet sich in Charlottenburg, rund um den Ernst-Reuter-Platz. Ein zweiter Campus liegt im Technologie- und Innovationspark Berlin im Bezirk Wedding. Darüber hinaus gibt es vereinzelt Standorte im Norden und Süden der Stadt.

== Links ==
* [https://www.tu.berlin/studieren/uni-leben/campusplan Hier finden sich Lagepläne aller Gebäude]
* [https://asta.tu-berlin.de/campusplan/ Alternativer Campusplan des AStA]
* Siehe auch: [[Liste von Hörsälen]]

[[Kategorie:Gebäude]]
[[Kategorie:Navigation]]
[[Kategorie:Uni-ABC]]

TU Berlin

2024-02-27T18:34:18Z

Milan: altes Logo entfernt

{{stub}}
Die '''Technische Universität Berlin''' ist die größte Uni Berlins und eine der ältesten technischen Universitäten Deutschlands.

=== Abkürzungen ===
Da »Technische Universität Berlin« den meisten Leuten zu lang ist, wird es fast immer als TU, TUB oder TU Berlin abgekürzt.

=== Gebäudeplan ===
Eine Karte der Gebäude auf dem Campus der TU findet sich unter [[Campus]].

== Weblinks ==

* [http://www.tu-berlin.de/ Offizielle Homepage der TU Berlin]

[[Kategorie: Uni-ABC]]

Diskussion:TU Berlin

2024-02-27T18:33:45Z

Milan: Die Seite wurde geleert.

Diskussion:TU Berlin

2024-02-27T18:33:03Z

Milan: Die Seite wurde neu angelegt: „hilfe“

hilfe

Opal

2024-02-27T18:05:34Z

Milan: finde nicht, wie man Verweise im Reiter löscht, deshalb das Tag

{{historisch}}
[[Datei:Opal.jpg|miniatur]]

'''Opal''' ist eine [[WikiPedia:Funktionale Programmiersprache|funktionale Programmiersprache]], die Euch (unter anderem) in [[MPGI 1 (Bachelor)|MPGI 1]] begegnen wird. Sie wurde an der TU Berlin von Prof. [[Pepper]] entwickelt. Die [[Freitagsrunde]] bietet euch mehrere Ressourcen rund um das Thema Opal.

== [[Opal FAQ]] ==
In der [[Opal FAQ]] findet Ihr häufige Probleme, die bei der Benutzung von Opal aufreten, einschließlich ihrer Lösungen.

== [[Opalix]] ==
Wir haben für euch auch eine Linux-Distribution erstellt, bei der das lauffähige Opal gleich dabei ist. Ihr müsst also nichts installieren, einfach das Image auf einen [[Opalix#Opalix_USB_Abbild_herunterladen_und_selber_brennen|USB-Stick schreiben]] und davon booten. Opalix ist dann persistent auf den Stick installiert, das heißt, dass ihr mit Opalix arbeiten könnt, als würdet ihr ganz normal von eurer Festplatte starten. Ihr könnt Programme installieren und Dokumente speichern.

Im Raum der Kultfrunde (MAR 0.005) könnt ihr euch das Image auf einen USB-Stick laden (der sollte mindestens zwei GB Speicher haben, da das Image etwas 1,1GB groß ist). Der Stick wird vollständig überschrieben, da ein völlig anderes Dateisystem genutzt wird, der Stick sollte also leer sein oder keine wichtigen Daten enthalten.

[http://freitagsrunde.org/~aeichner/Opalix2013.iso Opalix-ISO 2013]

== [[Opal für Linux/Unix]] ==
Wenn Ihr nicht Opalix benutzen möchtet, könnt ihr [[Opal für Linux/Unix#Ubuntu|fertige Opal-Pakete für verschiedene Linux-Distributionen]] herunterladen oder [[Opal_für_Linux/Unix#Hinweis_zum_Selber-Kompilieren|aus Quellen kompilieren]].

Seit Version 2.4 wird auch [[Opal für Linux/Unix#MacOS X|MacOS X]] unterstützt.

== [[Opal Syntax-Highlighting]] ==
Eine Liste der Editoren, die [[Opal Syntax-Highlighting|Syntax-Highlighting für Opal]] unterstützen.

== Lehrveranstaltungen mit Opal ==
* [[MPGI 1 (Bachelor)]]
* [[Informatik 1]]
* [[PSS]]
* [[Compilerbau 1]]

== Weblinks ==

Mehr Informationen zu Opal und [[OCS]] findet Ihr hier:
* http://projects.uebb.tu-berlin.de/opal/

Die 10 Opalismen:
* http://web.archive.org/web/20050507105405/http://wwwwbs.cs.tu-berlin.de/user/riess/ns20/die_10_Opalismen.html

opal-examples:
* https://github.com/stefanschramm/opal-examples

[[Bibliotheca Opalica]]
*https://projects.uebb.tu-berlin.de/opal/dosfop/2.4/bibopalicaman/

== Fragen/Probleme ==

Bei Fragen/Problemen rund um Opal/Opalix könnt ihr euch an [mailto:opalix@freitagsrunde.org opalix@freitagsrunde.org] wenden.

[[Kategorie: Opal]]
[[Kategorie: Opalix]]
[[Kategorie: Fachbegriffe der Informatik]]
[[Kategorie: Fakultäts-ABC]]

Kategorie:Uni-ABC

2024-02-27T17:55:54Z

Milan: Aktuelles Wiki rausgehoben

Das '''Uni-ABC''' umfasst wichtige Begriffe, die uniweit für [[Studierende]] von Bedeutung sind.

'''Ihr findet die aktuelle Version davon in deutsch und in englisch unter [https://uniabc.freitagsrunde.org/ https://uniabc.freitagsrunde.org/].'''

In diesem Wiki finden sich hierzu noch die folgenden Artikel.
Siehe auch [[:Kategorie:Fakultäts-ABC|Fakultäts-ABC]] für spezifische Themen zur [[Fakultät IV]].

[[Kategorie:Studium]]

I-café

2024-02-27T17:54:19Z

Milan:

{{veraltet}}
Das i-café ist ein studentisch geführtes und verwaltetes Café, früher im [[Franklingebäude]]. Jetzt befindet es sich im [[Fraunhofergebäude]]. Wollt Ihr bequemer als in der Cafeteria sitzen, euch ein bisschen unterhalten, billiger trinken oder auch mal feiern, dann seid Ihr hier richtig. Sollte es Euch gefallen, könnt Ihr Euch überlegen, beim Thekendienst mitzumachen. Sprecht einfach einen der netten Menschen hinterm Tresen an - die beißen nicht und freuen sich über euer Interesse...

[[Bild:FR_i-cafe.png|Lageplan des i-café]]

[[Kategorie:Wichtige Orte]]

Cafe Shila

2024-02-27T17:47:17Z

Milan: Verweis auf ET-Ini gestrichen

Das '''Café Shila''' ist ein studentisch geführtes Café an der TU Berlin hinter dem Mathegebäude.

Generell ist man im Shila hilfsbereit, ebenso wie bei der Freitagsrunde. Also ebenso einfach fragen!

Ansonsten gilt das Shila als das beste Café der Uni. Wenn es nicht gerade schimmelt.

== Angebote==
* Mate
* Kaffee (0,4€)
* Bier
* Cola
* Tee (versch. Sorten)
* Wasser laut & leise
* Schokolade
* Instantnudeln

* man kann hier auch die örtliche Mikrowelle nutzen

== Siehe auch ==
* [[I-cafe]]

* [https://maps.app.goo.gl/puBafydEHK8SeE4k6 Google-Maps-Link]

[[Kategorie:Wichtige Orte]]
[[Kategorie:Fakultäts-ABC]]

Cafe Shila

2024-02-27T17:46:31Z

Milan: aktualisiert, nicht gültiges gestrichen

Das '''Café Shila''' ist ein studentisch geführtes Café an der TU Berlin hinter dem Mathegebäude.

Generell ist man im Shila hilfsbereit, ebenso wie bei der Freitagsrunde. Also ebenso einfach fragen!

Ansonsten gilt das Shila als das beste Café der Uni. Wenn es nicht gerade schimmelt.

== Angebote==
* Mate
* Kaffee (0,4€)
* Bier
* Cola
* Tee (versch. Sorten)
* Wasser laut & leise
* Schokolade
* Instantnudeln

* man kann hier auch die örtliche Mikrowelle nutzen

== Siehe auch ==
* [[ET-Ini]]
* [[I-cafe]]

* [https://maps.app.goo.gl/puBafydEHK8SeE4k6 Google-Maps-Link]

[[Kategorie:Wichtige Orte]]
[[Kategorie:Fakultäts-ABC]]