FreitagsrundenWiki - Benutzerbeiträge [de]

StuPO 90

2012-02-23T19:26:01Z

91.65.91.154: Auslaufen des Diploms

Die alte [[Studien- und Prüfungsordnung]] für den [[Diplom]]-Studiengang [[Informatik_(Studiengang)|Informatik]].

Zum Auslaufen der Diplomstudiengänge: [[Diplom/Frist]]

== Festlegungen ==
Die StuPO 90 teilt den Diplomstudiengang Informatik in zwei Teile:
* [[Grundstudium Informatik|Grundstudium]],
* [[Hauptstudium Informatik|Hauptstudium]].

== Nachlesen ==
* Studienordnung: http://docs.freitagsrunde.org/StuPO/StuO90.xhtml
* Prüfungsordnung: http://docs.freitagsrunde.org/StuPO/PO90.xhtml

== Andere StuPOs ==
Die StuPO 90 löste die [[Historische Prüfungsordnungen|Prüfungsordnungen A und B]] ab und wird inzwischen durch die neue [[StuPO Informatik]] ersetzt.

[[Kategorie: Fakultäts-ABC]]
[[Kategorie: Hochschulpolitik]]

Beratung

2012-02-14T23:54:27Z

91.65.91.154: Für die Suche im wiki

#REDIRECT [[Beratungsstellen]]

Javakurs 2010

2012-02-11T10:44:45Z

91.65.91.154: /* Ansprechpartner */

__NOTOC__

Auch dieses Jahres bietet die Freitagsrunde wieder einen Javakurs an!

Der Kurs findet vom 22.03.2010 bis einschließlich dem 25.03.2010 statt. 
Er richtet sich vor allem an Programmieranfänger, dennoch ist wirklich jeder herzlich willkommen der an Java interessiert ist.

Die Vorlesungen finden in Raum H2032 statt. 
Die offenen Übungen finden voraussichtlich in den Räumen TEL106 und TEL206 statt.

Der Kurs ist kostenlos. Aufgrund der immensen Nachfrage müssen wir die Anmeldung leider schließen.

== ==

<center>
{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
!Zeit
!Mo 22.03.2010
!Di 23.03.2010
!Mi 24.03.2010
!Do 25.03.2010
|- bgcolor="#E8E8E8"
|10:15-11:15
|bgcolor="#E8E8E8" |[[Javakurs 2010/Vortrag01 | Hello World]]
|bgcolor="#E8E8E8" |[[Javakurs 2010/Vortrag03 | Methoden]]
|bgcolor="#E8E8E8" |[[Javakurs 2010/Vortrag04 | Von der Aufgabe zum Code]]
|bgcolor="#E8E8E8" |[[Javakurs 2010/Vortrag06 | Vererbung]]
|- bgcolor="#F5F5F5"
|11:30-13:15
|Übung
|Übung
|Übung
|Übung
|- bgcolor="#FFFFFF"
|13:15-14:15
|Mittagspause
|Mittagspause
|Mittagspause
|Mittagspause
|- bgcolor="#E8E8E8"
|14:15-15:15
|[[Javakurs 2010/Vortrag02 | Schleifen und Felder]]
| bgcolor="#F5F5F5" rowspan=2 | Übung
|[[Javakurs 2010/Vortrag05 | Objekte und Kapselung]]
| bgcolor="#F5F5F5" rowspan=2 |Übung
|- bgcolor="#F5F5F5"
|15:30-17:30
| Übung
| Übung
|- bgcolor="#F5F5F5"

|}

'''[[Javakurs/Übungsaufgaben | --> Zu den Übungsaufgaben <-- ]]'''
</center>

== ==

== Warum teilnehmen? ==
Der Javakurs richtet sich an Programmieranfänger, die gerne Java lernen möchten. Wir haben uns zum Ziel gesetzt, möglichst gut verständliche und vor allem motivierende Lehre zu machen weil wir glauben, dass die Uni-Lehre manchmal zu langweilig ist und deshalb viele Studenten unnötigerweise Probleme haben. Lernen sollte Spass machen, nicht anstrengen. Folglich dient der Kurs auch nicht der direkten Vorbereitung auf Tests oder Klausuren.

Hauptsächlich hoffen wir damit den Teilnehmern von MPGI2 einen Kickstart für ihre Vorlesung zu geben, weil es je nach Dozent und Zuhörer manchmal zu schnell und manchmal zu langsam geht. Allerdings steht der Kurs jedem offen!

Wenn du also einfach gerne Java lernen möchtest, dann bist du herzlich eingeladen!

Der Kurs beruht ursprünglich auf der Initiative einiger StudentInnen und wissenschaftlicher Mitarbeiter. Er ist aus der Erfahrung entstanden, dass viele Informatiker in den Übungsaufgaben des 2. Semesters nicht unbedingt Probleme mit dem Stoff des Semesters selbst haben, sich jedoch sehr beim Erlernen der Sprache Java quälen. Die Situation hat sich seitdem zwar etwas geändert, aber vielen, gerade Studenten aus Informatik-fremden Studiengängen ist immer noch die Sprache selbst und nicht die Algorithmen eine Hürde.

Der Kurs wird wie im letzten Jahr komplett von engagierten StudentInnen geplant und durchgeführt. Insgesamt stehen euch in den Übungen zwölf TutorInnen mit Rat und Tat zur Seite, im Schnitt also einer für fünf bis zehn Studentierende. Aus den Reihen der TutorInnen rekrutieren sich auch unsere Vortragenden in den Vorlesungen. Inzwischen haben wir einiges an Erfahrung sammeln können, überarbeiten aber jedes Jahr die Vorträge neu und unterziehen sie einem Peer-Review Prozess. Wir hoffen, dass wir damit einen möglichst hohe Qualität bieten können.

Der Kurs kann in der Kürze der Zeit bei weitem nicht alle Aspekte von Java beleuchten, hierfür sind weiterführende Lehrveranstaltungen und das Lehrpersonal der Uni da. Er stellt jedoch eine gute Starthilfe dar und hilft vor allem StudentInnen denen der Umgang mit Programmiersprachen noch ein wenig fremd ist.

'''Es gibt für diesen Kurs keinerlei Scheine oder sonstige Anrechnung.'''

Es gibt auch keinerlei Anwesenheitspflicht. Dementsprechend entspannt ist allerdings auch die Atmosphäre. :)

== Teilnahmevoraussetzungen ==
Der Javakurs ist für absolute Programmieranfänger konzipiert. Wir setzen keinerlei Programmierkenntnisse voraus. Was wir allerdings voraussetzen sind rudimentäre Kentnisse wie man einen Computer bedient. Wir bringen euch nicht bei wie ihr eine Datei öffnet oder einen Browser bedient.

Die zweite Voraussetzung ist eine Möglichkeit bzw. ein Account um in den Übungsräumen zu arbeiten. Die Übungen finden in den Rechnerräumen des IRB statt. In diese Rechner kann man sich mit einem TubIT- oder CS-Account einloggen. Wenn du noch keinen TubIT oder CS-Account hast bist du vermutlich auch nicht Student an der TU Berlin. Dann ist die einfachste Lösung für Dich deinen eigenen Laptop mitzubringen.

== Anmeldung ==
<strike>Um Anmeldung unter
[http://anmeldung.freitagsrunde.org http://anmeldung.freitagsrunde.org]
wird zur besseren Planbarkeit gebeten.</strike>

Auf Grund der immensen Nachfrage mussten wir die Anmeldung leider schließen. 

== Termine & Räume ==
Der Javakurs findet vom Montag, den 22.03.2010 bis einschließlich Donnerstag, den 25.03.2010 statt. 
Die Vorlesungen finden im H2032 statt, die Übungen im TEL106 und TEL206.

Steckdosen sind jeweils links und rechts im Raum. Bitte bringt ein paar Mehrfachsteckdosen mit, andere freuen sich ;)

== Inhalte ==

=== Vorlesungen ===

Eine Übersicht über die Inhalte der Vorlesungen folgt in Kürze.

=== offene Übungen ===

Der praktische Teil des Kurses orientiert sich vor allem daran was ihr selbst ausprobieren wollt. 
Ihr bestimmt selbst in welchem Schwierigkeitsgrad ihr lernen wollt und wie hoch euer Arbeitspensum ist.
Die folgenden Übungsaufgaben sind als Vorschläge zu verstehen aus denen ihr auswählen könnt, was und vor allem wie viel davon ihr versuchen wollt.

<center>'''[[Javakurs/Übungsaufgaben | --> Zu den Übungsaufgaben <-- ]]'''</center>



== Links ==
* [[Javakurs 2010/Tutorenportal]]
* [[Javakurs 2010/Feedback]]
* [[Javakurs2008| Seiten des Javakurses 2008]]
* [[Javakurs2009| Seiten des Javakurses 2009]]
* [[Javakurs/Übungsaufgaben|Übungsaufgaben]]

[[Kategorie: Veranstaltungen der Freitagsrunde]]

Drucker

2012-02-11T10:27:23Z

91.65.91.154: wikiformatting suckx

= Drucken an der TU =
== Bei der tuBIT ==

* Schwarz-Weiß DIN A4: EN 004, MA 270 oder H 5150b
* Farbig DIN A4: EN 004 (Drucker EN004Color auswählen)
* im MA 270 kann man außerdem scannen

* Preise:
** prepaid, Druckguthaben wird von Mensakarte "übertragen"
** Schwarz-Weiß einseitig/doppelseitig: 5 ct
** farbig: nach Farbanteil zwischen 7 ct und 60 ct [http://www.tubit.tu-berlin.de/menue/dienste/weitere_dienste/drucken_kopieren_scannen_brennen/tubit_-_drucken_und_kopieren/]
* Druckguthaben aufladen:
# Ins EN 004 oder MA 270 gehen und den Rechner zum Aufladen finden (meist im Eingangsbereich)
# Mensakarte dort einstecken
# Mit tuBIT-Zugangsdaten einloggen
# Guthaben von Mensakarte "übertragen" (zwischen einigen Cent und einigen Euro)
* Drucken:
** Vom tuBIT-Rechnerpool aus, Drucker sind dort eingerichtet
** Vom eigenen Rechner aus, Einrichtung: [http://www.tubit.tu-berlin.de/menue/dienste/weitere_dienste/drucken_kopieren_scannen_brennen/tubit_-_drucken_und_kopieren/ Tubit-Dokumentation]
** PDF-Direktdruck vom Campusportal aus [http://www.tubit.tu-berlin.de/menue/dienste/weitere_dienste/drucken_kopieren_scannen_brennen/einrichtung_der_printcampus-drucker/ Tubit-Dokumentation]

== Im Unix-Pool ==

* Ort: MA 241
* Schwarz-weiß und farbig, DIN A4
* kostenlos
* Voraussetzung: Unixpool-Account (z.B. durch Mathe-Lehrveranstaltung)
* Dokumentation: [http://www-pool.math.tu-berlin.de/public/druck-howto/index.xhtml# Unixpool-FAQ]

== Im CIP-Pool (+ Plotten) ==

* Ort: EB 431 [http://www.cip29.tu-berlin.de/index.php?index]
* Schwarz-Weiß und farbig
* DIN A4, A3
* Plotter 36'' und 42'' (zB für Poster)
* eigener Account muss bei dortigen Tutoren beantragt werden (wird aber auch Nicht-FakVI-Mitgliedern problemlos gegeben)
* Preise richten sich nach Format, Papierqualität u.ä. [http://www.cip29.tu-berlin.de/index.php?preise]

== Im TEL108 ==
* nur mit Omni- bzw. Mensacard
* Anleitungen sind zu finden unter [http://www.eecs.tu-berlin.de/irb/v-menu/leitfaden/drucken_im_fakultaetsnetz/parameter/maxhilfe/]

= Drucken in der Freitagsrunde =

== Im Freitagsrundenraum ==

* Bitte sparsam benutzen (z.B. nur für einzelne Seiten)
* per IPP (Internet Printing Protocol) auf stone unter dem Namen frunde freigegeben
* benutzbar z.B. aus dem Freitagsrundennetz heraus (10.23.42.0)

=== Einrichtung unter Ubuntu (GNOME) ===

# System -> Systemverwaltung -> Drucker
# Hinzufügen / Neu
# Netzwerkdrucker sollte automatisch erkannt werden (wenn man im Freitagsrundennetz ist)

=== Einrichtung per CUPS (unter Linux) ===

# Im Browser verbinden mit localhost:631
# "Verwaltung"
# "Drucker hinzufügen"
# ggf. auf "Weiter", wenn nicht automatisch erkannt
# unter "Andere Netzwerkdrucker:" Internet-Druckerprotokoll (ipp) auswählen
# als URI eintragen: ipp://10.23.42.1:631/printers/HP_LaserJet_4L_LPT_1
# Daten angeben:
* Name: HP-LaserJet-4L
* Beschreibung: HP LaserJet 4L
* Ort: Ueber Stone
* Marke: HP
* Treiber: HP LaserJet 4L - CUPS+Gutenprint v5.2.6 (en)
* Standardeinstellungen: Voreinstellungen sind okay

== Mittels Druckerkarte ==

* Standort: FR 5098
* Druckerkarte (am Anker) und PIN benötigt (im Zweifelsfall jemanden fragen)

=== Einrichtung unter Ubuntu (GNOME) ===

# System/Systemverwaltung/Drucken
# Hinzufügen oder Neu
# Geräte-URI eingeben: lpd://130.149.17.68/oce
# Wähle Treiber
## OCE
## VarioPrint 2060 (empfohlen)
# Installierbare Optionen (so lassen)
# Beschreibe Drucker (Ort eintragen: FR 5098)
# Anwenden

Wenn man nun zum Drucker geht findet man im Menü unter seinem lokalen Nutzernamen den Druckjob.

=== Über einen Uniserver per Konsole drucken ===

==== manuell ====
# Datei per scp auf einen [[SSH#SSH_f.C3.BCr_den_Zugriff_auf_das_Fakult.C3.A4tsnetz|Uniserver]] laden
# ssh auf den Uniserver
# $ lpr -Pfr5098 <Dateiname>

==== mittels Skript ====
mit folgendem Skript kann durch einen Befehl mit Datei als Parameter am Drucker im FR 5098 gedruckt werden.
* Skript abspeichern und ausführbar machen. (chmod u+x DATEI)
* 'KENNUNG' im Skript durch eigene TUBit-Kennung ersetzen.
* Zur bequemeren Nutzung alias (z.B.: printpdf ) einrichten.
<pre><nowiki>
#!/bin/bash

if [ 1 -ne $# ]; then
echo -e "ERROR: missing parameter\nusage: $0 PRINTFILE"
exit 1
fi

printfile="$1"
login="KENNUNG"
printer="fr5098"

if [ -f "$printfile" ]; then
echo "sending $printfile to printer $printer"
cat "$printfile" | ssh -l "$login" furor.cs.tu-berlin.de "lpr -P$printer"
else
echo -e "ERROR: file not found \'$printfile\'"
exit
fi
</nowiki></pre>

Drucker

2012-02-11T10:25:41Z

91.65.91.154: das script kann so nicht funktioniert haben - vemrutlich lag die Druckdatei noch zufällig im Home des Nutzers.

= Drucken an der TU =
== Bei der tuBIT ==

* Schwarz-Weiß DIN A4: EN 004, MA 270 oder H 5150b
* Farbig DIN A4: EN 004 (Drucker EN004Color auswählen)
* im MA 270 kann man außerdem scannen

* Preise:
** prepaid, Druckguthaben wird von Mensakarte "übertragen"
** Schwarz-Weiß einseitig/doppelseitig: 5 ct
** farbig: nach Farbanteil zwischen 7 ct und 60 ct [http://www.tubit.tu-berlin.de/menue/dienste/weitere_dienste/drucken_kopieren_scannen_brennen/tubit_-_drucken_und_kopieren/]
* Druckguthaben aufladen:
# Ins EN 004 oder MA 270 gehen und den Rechner zum Aufladen finden (meist im Eingangsbereich)
# Mensakarte dort einstecken
# Mit tuBIT-Zugangsdaten einloggen
# Guthaben von Mensakarte "übertragen" (zwischen einigen Cent und einigen Euro)
* Drucken:
** Vom tuBIT-Rechnerpool aus, Drucker sind dort eingerichtet
** Vom eigenen Rechner aus, Einrichtung: [http://www.tubit.tu-berlin.de/menue/dienste/weitere_dienste/drucken_kopieren_scannen_brennen/tubit_-_drucken_und_kopieren/ Tubit-Dokumentation]
** PDF-Direktdruck vom Campusportal aus [http://www.tubit.tu-berlin.de/menue/dienste/weitere_dienste/drucken_kopieren_scannen_brennen/einrichtung_der_printcampus-drucker/ Tubit-Dokumentation]

== Im Unix-Pool ==

* Ort: MA 241
* Schwarz-weiß und farbig, DIN A4
* kostenlos
* Voraussetzung: Unixpool-Account (z.B. durch Mathe-Lehrveranstaltung)
* Dokumentation: [http://www-pool.math.tu-berlin.de/public/druck-howto/index.xhtml# Unixpool-FAQ]

== Im CIP-Pool (+ Plotten) ==

* Ort: EB 431 [http://www.cip29.tu-berlin.de/index.php?index]
* Schwarz-Weiß und farbig
* DIN A4, A3
* Plotter 36'' und 42'' (zB für Poster)
* eigener Account muss bei dortigen Tutoren beantragt werden (wird aber auch Nicht-FakVI-Mitgliedern problemlos gegeben)
* Preise richten sich nach Format, Papierqualität u.ä. [http://www.cip29.tu-berlin.de/index.php?preise]

== Im TEL108 ==
* nur mit Omni- bzw. Mensacard
* Anleitungen sind zu finden unter [http://www.eecs.tu-berlin.de/irb/v-menu/leitfaden/drucken_im_fakultaetsnetz/parameter/maxhilfe/]

= Drucken in der Freitagsrunde =

== Im Freitagsrundenraum ==

* Bitte sparsam benutzen (z.B. nur für einzelne Seiten)
* per IPP (Internet Printing Protocol) auf stone unter dem Namen frunde freigegeben
* benutzbar z.B. aus dem Freitagsrundennetz heraus (10.23.42.0)

=== Einrichtung unter Ubuntu (GNOME) ===

# System -> Systemverwaltung -> Drucker
# Hinzufügen / Neu
# Netzwerkdrucker sollte automatisch erkannt werden (wenn man im Freitagsrundennetz ist)

=== Einrichtung per CUPS (unter Linux) ===

# Im Browser verbinden mit localhost:631
# "Verwaltung"
# "Drucker hinzufügen"
# ggf. auf "Weiter", wenn nicht automatisch erkannt
# unter "Andere Netzwerkdrucker:" Internet-Druckerprotokoll (ipp) auswählen
# als URI eintragen: ipp://10.23.42.1:631/printers/HP_LaserJet_4L_LPT_1
# Daten angeben:
* Name: HP-LaserJet-4L
* Beschreibung: HP LaserJet 4L
* Ort: Ueber Stone
* Marke: HP
* Treiber: HP LaserJet 4L - CUPS+Gutenprint v5.2.6 (en)
* Standardeinstellungen: Voreinstellungen sind okay

== Mittels Druckerkarte ==

* Standort: FR 5098
* Druckerkarte (am Anker) und PIN benötigt (im Zweifelsfall jemanden fragen)

=== Einrichtung unter Ubuntu (GNOME) ===

# System/Systemverwaltung/Drucken
# Hinzufügen oder Neu
# Geräte-URI eingeben: lpd://130.149.17.68/oce
# Wähle Treiber
## OCE
## VarioPrint 2060 (empfohlen)
# Installierbare Optionen (so lassen)
# Beschreibe Drucker (Ort eintragen: FR 5098)
# Anwenden

Wenn man nun zum Drucker geht findet man im Menü unter seinem lokalen Nutzernamen den Druckjob.

=== Über einen Uniserver per Konsole drucken ===

==== manuell ====
# Datei per scp auf einen [[SSH#SSH_f.C3.BCr_den_Zugriff_auf_das_Fakult.C3.A4tsnetz|Uniserver]] laden
# ssh auf den Uniserver
# $ lpr -Pfr5098 <Dateiname>

==== mittels Skript ====
mit folgendem Skript kann durch einen Befehl mit Datei als Parameter am Drucker im FR 5098 gedruckt werden.
* Skript abspeichern und ausführbar machen. (chmod u+x DATEI)
* 'KENNUNG' im Skript durch eigene TUBit-Kennung ersetzen.
* Zur bequemeren Nutzung alias (z.B.: printpdf ) einrichten.
<nowiki>

#!/bin/bash

if [ 1 -ne $# ]; then
echo -e "ERROR: missing parameter\nusage: $0 PRINTFILE"
exit 1
fi

printfile="$1"
login="KENNUNG"
printer="fr5098"

if [ -f "$printfile" ]; then
echo "sending $printfile to printer $printer"
cat "$printfile" | ssh -l "$login" furor.cs.tu-berlin.de "lpr -P$printer"
else
echo -e "ERROR: file not found \'$printfile\'"
exit
fi

</nowiki>

Javakurs/Übungsaufgaben/Palindrome/Musterloesung

2012-02-05T18:31:51Z

91.65.91.154: preformatted text not working?!

<pre>
<nowiki>

//@Author: S.M.B. 234
//@Version: 1.0

import java.util.Scanner;

public class Palindrome {
String eingabe;
char[] wort, wortInvert;

public boolean check(String temp) {
// ermöglicht auch die Eingabe von Tabulator und Leerzeichen und schließt diese von der Überprüfung aus
temp = temp.replaceAll(" ", "").replaceAll(" ", "");
this.eingabe = temp.toLowerCase();
this.wort = eingabe.toCharArray();
wortInvert = new char[wort.length];

for (int i = 0; i < (wort.length); i++) {
char letter = wort[i];
wortInvert[(wort.length-1-i)] = letter;
}
for(int i = 0; i<wort.length; i++){
if (wortInvert[i] != wort[i]) {
System.out.println(temp + " ist kein Palindrom");
return false;
}
}
System.out.println(temp + " ist ein Palindrom");
return true;
}

public static void main(String[] args) {
System.out.print("Willkommen beim Palindrom-Vergleicher\nGeben Sie das zu ueberpruefende Wort ein:");
Scanner in = new Scanner(System.in);
Palindrome pal = new Palindrome();
String temp = in.nextLine();
pal.check(temp);
}
}
</nowiki>
</pre>

Javakurs/Übungsaufgaben/Palindrome/Musterloesung

2012-02-05T18:30:03Z

91.65.91.154: nowiki

//@Author: S.M.B. 234
//@Version: 1.0
<nowiki>
import java.util.Scanner;

public class Palindrome {
String eingabe;
char[] wort, wortInvert;

public boolean check(String temp) {
// ermöglicht auch die Eingabe von Tabulator und Leerzeichen und schließt diese von der Überprüfung aus
temp = temp.replaceAll(" ", "").replaceAll(" ", "");
this.eingabe = temp.toLowerCase();
this.wort = eingabe.toCharArray();
wortInvert = new char[wort.length];

for (int i = 0; i < (wort.length); i++) {
char letter = wort[i];
wortInvert[(wort.length-1-i)] = letter;
}
for(int i = 0; i<wort.length; i++){
if (wortInvert[i] != wort[i]) {
System.out.println(temp + " ist kein Palindrom");
return false;
}
}
System.out.println(temp + " ist ein Palindrom");
return true;
}

public static void main(String[] args) {
System.out.print("Willkommen beim Palindrom-Vergleicher\nGeben Sie das zu ueberpruefende Wort ein:");
Scanner in = new Scanner(System.in);
Palindrome pal = new Palindrome();
String temp = in.nextLine();
pal.check(temp);
}
}
</nowiki>

Opal FAQ

2012-01-28T14:17:58Z

91.65.91.154: typos

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.

==Benutzung des Interpreters oasys==

===Starten von oasys, Ausführen von Programmen===
oasys lässt sich von der Shell 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 i.A. oasys in dem Verzeichnis starten, in dem die Dateien gespeichert sind.
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 oasys-Interpreter.
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.
<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.

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 FunktionMitVielenArgument("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.

WICHTIG: Sequenzen in dieser Form hin zuschreiben ist _böse_!!! Vor allem sorgt das für viel Verwirrung und verbirgt den wahren Charakter einer Sequenz!! Siehe dazu auch Beitrag Nummer 4. :)

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. :)

=== Konstruktion von Listen ===
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.

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.

=== 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 ==

=== WHERE funktioniert 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!

=== Opal funktioniert nicht mit Zahlen über 32? ===

Wenn man in [[Opal]] direkt Zahlen über 32 eingeben möchte, muß man das so hinschreiben:

<pre>
"zahl"!
</pre>

Wobei 'Zahl' irgendeine Zahl sein kann. Wichtig sind die Anführungszeichen und das Ausrufungszeichen dahinter.

=== Eigene Backtick-Funktion (`) wird nicht benutzt ===

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

=== 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.

=== Präfix, Infix und Postfixnotation===
...oder wie man Minuszeichen hassen lernt.

Erhält man solche 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]].

=== Fehler in Zeile 1 ===

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 1.3-1.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 _1_ Statt. Das ist die Eingabe-Zeile in der Shell. :))
(" ERROR [at 1.3-1.4]:")

== 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 Listings-Package für TeX/LaTeX. Doch weil die Einarbeitung etwas Zeit braucht, gibt es unter [http://web.archive.org/web/20070206172953/http://user.cs.tu-berlin.de/~pdmef/opal/inf-latex.pdf] eine kurze Anleitung mit allem, was man so braucht, um schnell zu guten Ergebnissen zu kommen.

[[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]].