Operno

Operno
Paradigmen:	objektorientiert, funktional, reflexion
Erscheinungsjahr:	2008
Entwickler:	Josef Sniatecki
Aktuelle Version:	5.40  (1. Dezember 2009)
Typisierung:	dynamisch
Beeinflusst von:	Python, JavaScript, Ruby
Betriebssystem:	Windows
Lizenz:	GPL

Operno ist eine objektorientierte, dynamische und funktionale Programmiersprache, die von Josef Sniatecki (*14. April 1993) entwickelt wurde und einer stetigen Weiterentwicklung unterliegt. Die Sprache wird durch einen Interpreter analysiert und ausgeführt. Zur Analyse gehört die lexikalische Analyse und die Optimierung durch einen internen Präprozessor.

Zu den Sprachelementen gehört OOP, zur Laufzeit modifizierbare Klassen, dynamisch erweiterbare Listen (Containerklasse), vektorielle Operationen für nicht überladene Operatoren, Präprozessor für Makros und Symbole, Kontrollstrukturen (if, switch, while) und Iterationsschleifen (for, repeat).

Operno ist ein Open-Source-Projekt und steht unter der GNU General Public License. Derzeit besitzt die Software eine deutsche Dokumentation, eine integrierte Entwicklungsumgebung und eine interaktive Konsole für die direkte Ausführung von Anweisung.

Geschichte

Die erste Version (1.00) von Operno wurde am 30. August 2008 zum ersten Mal publiziert. Der Interpreter zerlegte einen Quellcode in eine Liste von Tokens und hat diese direkt ausgeführt. Die Syntax lehnte sich nach der Polnischen Notation (Präfixnotation). Somit wurde beispielsweise eine Addition von zwei Zahlen nach dem Schema +: num1, num2 ausgeführt.

Am 27. September 2008 erschien die Version 2.00. Operno verwendete die Infix-Notation, die Quellcodes wesentlich lesbarer machte. Dabei wurde jede Anweisung durch ein Semikolon beendet. Zudem wurde auch das objektorientierte Sprachparadigma konzipiert, wodurch Funktionen, Gruppen, Klassen und Variablen als Objekte behandelt wurden.

Die Version 3.00 wurde am 24. Dezember 2008 veröffentlicht und hat das funkionale Programmieren verbessert, indem Kontrollstrukturen Werte zurück geben konnten. Änderungen bezüglich zur Syntax gab es kaum.

Operno 4.00 wurde nie publiziert, da die Programmstruktur dieser Version nicht genug zum erweitern geeignet war. Kurz darauf wurde die folgende Version entwickelt:

Die aktuelle Hauptversion 5.00 wurde am 3. April 2009 veröffentlicht und unterstützt nun alle weiteren Paradigmen, die schon erwähnt wurden. Die aktuelle Nebenversion ist 5.40.

Objekte

Jedes Objekt kann eines von drei Typen annehmen:

• Variable
• Funktion
• Gruppe

Objekte werden in Operno zur Laufzeit definiert, wodurch Objekte löschbar und wieder neu definierbar sind. Dabei kann auch ein Projekt, dass Operno als Dynamic Link Library verwendet, auf Attribute (z.B. der Name) von Objekten zugreifen und diese überschreiben.

Variable

Eine Variable kann jeden klassifizierten Wert speichern und diesen zur Laufzeit wiederverwenden und modifizieren. Die Klasse des Wertes kann über Methoden verfügen, die durch die jeweilige Variable aufgerufen werden können. Ähnlich wie in Ruby, unterscheidet Operno nicht zwischen den Klassen von Werten, sondern zwischen den dazugehörigen Methoden. Die Typisierung erfolgt zur Laufzeit, wodurch man von einer dynamischen Typisierung spricht.

Variants

Eine Variable kann von der Klasse variant sein. Dies ist eine unbestimmte Klasse, wodurch eine Variable vom Typ variant jeden Wert zugewiesen bekommen kann, ohne ein Type-Casting vorzunehmen.

Im folgenden Beispiel sind beide Parameter/Variablen a und b vom Typ variant, da keine Klassen angegeben werden:

sum(a, b){
  return a + b
}

out sum(10, 1) 'Gibt "11" aus
out sum("A", "BC") 'Gibt "ABC" aus

Funktion

Funktionen können in Operno mehrere Parameter erhalten und diese durch einen Block von Anweisungen verarbeiten. Der Rückgabewert kann in seiner Klasse bestimmt und auch unbestimmt sein.

Aufruf

Der Aufruf einer Funktion erfolgt durch das Erwähnen des Funktionsnamens. Werden Parameter verlangt, so gibt man eine Klammer mit Parametern nach dem Funktionsaufruf an:

put hello world(){
  out "Hello world!"
}

sum(a, b) = a + b

put hello world 'Gibt "Hello world!" aus
out sum(1, 10) 'Gibt 11 aus

Currying

Wird keine Parameterliste beim Aufruf angegeben, trotz dem Verlangen von Parametern, so werden überflüssige Parameter der aktuellen Funktion weitergegeben:

put two values(a, b){
  out a
  out b
}
put four values(){
  put two values 'Die ersten zwei Parameter weitergeben
  out "--"
  put two values 'Die letzten zwei Parameter weitergeben
}

put four values(1, 2, 3, 4)

Die Ausgabe:

1
2
--
3
4

Multi-Calling

Das sog. Multi-Calling ist ein mehrfacher Aufruf durch das Aneinanderhängen von mehreren Parameterlisten. Die Ergebnisse dieser Aufrufe werden mittels einer Liste übergeben:

sum(a, b) = a + b

out sum(1, 2)(8, 2)("A", "BC") 'Gibt "[3, 10, ABC]" aus

Gruppe

Eine Gruppe besitzt mehrere Kindobjekte (engl. child objects), die ebenso jeden Typ eines Objekts annehmen können. In Operno werden Klassen durch Gruppen konstruiert, indem die Kindobjekte einer Gruppe auch als Klassenmethoden verwendbar sind.

Diese Gruppen lassen sich mit Namensräumen vergleichen, wobei zu beachten ist, dass Gruppen in Operno zur Laufzeit bestehen, für vektorielle Operationen verwendet werden dürfen und auch als Klassen verwendet werden.

Die Unterobjekte können auch durch einen zur Laufzeit ausgewerteten String angesprochen werden - ähnlich wie bei JavaScript.

Syntax

Die Syntax basiert auf der Infix-Notation. Anweisungen werden immer mit einem Zeilenumbruch, oder einem Semikolon beendet. Zusätzlich kann man durch Operatoren und sonstigen Symbolen am Zeilenende eine Zeilenverbindung erzwingen.

Beispiel:

out 5 + 4 + 3 +
        2 + 1

Schlüsselwörter und Zeichen besitzen oftmals Symbole. Beispielsweise kann man eine Typisierung durch eine Punktnotation, oder durch ein as angeben.

Namensgebung

Namen von Objekten können Sonderzeichen und Leerzeichen beinhalten. Dabei werden Leerzeichen nach dem Parsen entfernt, indem die Namen in die Lower-Camel-Case-Form umgewandelt werden:

'Zwei gleiche Variablen mit Sonderzeichen:
meine größe = 1.84
meineGröße += 0.1

Funktionales Programmieren

Die Kontrollstrukturen if und switch können ebenso wie die Iterationsschleifen for und repeat Werte zurückgeben. Somit können diese Skriptsteuerungen innerhalb einer Anweisung Ergebnisse zurückliefern.

Beispiel (x bekommt einen Wert von der Kontrollstruktur if zugewiesen):

b = 1
x = if(b == 0)(
  "zero"
)else if(b == 1)(
  "one"
)else(b == 2)(
  "two"
)

Objektorieniertes Programmieren

Jeder Wert besitzt in Operno eine Klasse, die Instanzen und Klassenmethoden besitzt. Instanzen können durch ein Backslash ("\") angesprochen und Klassenmethoden durch einen Doppelpunkt aufgerufen werden. Zusätzlich besitzt jede Klasse Methoden, die automatisch zu bestimmten Ereignissen (z.B. der Konstruktor) aufgerufen werden.

Beispiel:

person{
  _new(){
    this def name.string, age.integer
  }
  _def(){
    this pop
  }
  _form(){
    return "name: #(name)
            age: #(age)"
  }
}

myself.person("Josef", 16)
out myself 'Gibt "name: Josef
           ' age: 16" aus

out "Hello world":u case 'Ergibt "HELLO WORLD"

Präprozessor

Da Operno einen rekursiven Parser besitzt, kann vor der Ausführung der Präprozessor Anweisungen verarbeiten, um einen Code zu optimieren. Somit ist z.B. Ein Makro eine Funktion, die Zeichenketten erhält und einen Code als Zeichenkette zurückgibt. Neben Makros können auch Symbole definiert werden.

Der Präprozessor interpretiert auch Kontrollstrukturen, wodurch zwischen Code-Abschnitten vor der Ausführung gewählt werden kann.

Quellen

• Operno auf SourceForge (deutsch)

Weblinks

• Homepage des Entwicklers Josef Sniatecki (deutsch)
• Projekt-Seite auf SourceForge (engl.)