Rapid Application Development, RAD

Schnelles Prototyping
(Rapid Application Development, RAD)
Prof. Dr. rer. nat. habil. Uwe Aßmann
Lehrstuhl Softwaretechnologie
Fakultät für Informatik
TU Dresden
Softwaretechnologie, © Prof. Uwe Aßmann
1
Obligatorische Literatur
►
►
Sebastian Mieth. Ein Vergleich zwischen Java und Pike. Kompetenzschein
Softwaretechnik, TU Dresden, Softwaretechnologie, 2004.
http://pike.ida.liu.se
Prof. U. Aßmann, Softwaretechnologie
2
2 Trends in der Softwareentwicklung
►
Rapid Application Development (RAD)
■
■
►
Zeit
pike
Mit Skriptsprachen
■
■
■
►
Schneller viel Code schreiben
Sehr schnell ein UML-Modell in ausführbaren
Code übersetzen
Perl (Larry Wall etc, www.perl.org)
Python (Guido van Rossum, www.python.org)
Pike (Frederik Hübinette et al., pike.ida.liu.se)
Java
Java
1.5
Zuverlässigkeit
Eigenschaften
■
■
■
■
■
■
Oft schwach oder ungetypt (Strings und integer werden unterschieden)
Interaktive Umgebungen
JIT compiler, die implizit gestartet werden
Gute Mustererkennung (string pattern machting) und Stringverarbeitung
Mächtige Operationen, die schnell zu schreiben sind und direkt aus Analyse- oder
Entwurfsmodellen codierbar sind
Grosse Bibliotheken erhältlich
Prof. U. Aßmann, Softwaretechnologie
3
Transformation auf Behälterklassen in Java (Wdh.)
Ersetzen von “*”-Assoziationen durch Behälterklassen
Bestellung
Bestellung
– kunde: String
– kunde: String
+ neuePosition(b: Bestellposition)
+ löschePosition(pos int)
+sonderpreis(pos: int, preis: int)
+ auftragssumme(): int
+ print()
+ neuePosition(b: Bestellposition)
+ löschePosition(pos int)
+sonderpreis(pos: int, preis: int)
+ auftragssumme(): int
+ print()
1
<<interface>>
Collection
1
{ordered}
*
Bestellposition
Bestellposition
– anzahl: String
– preis: int
– anzahl: String
– preis: int
+ einzelpreis(): int
+ einzelpreis(p: int)
+ positionspreis(): int
+ einzelpreis(): int
+ einzelpreis(p: int)
+ positionspreis(): int
für
*
1
für
*
*
1
Artikel
Artikel
– name: String
– preis: int
– name: String
– preis: int
+ preis(): int
1 {ordered}
+ preis(): intProf. U. Aßmann, Softwaretechnologie
4
Abbildung von UML-Assoziationen in der
Skriptsprache Pike
Ersetzen von “*”-Assoziationen durch Behälterklassen
Bestellung
Bestellung
– kunde: String
– kunde: String
+ neuePosition(b: Bestellposition)
+ löschePosition(pos int)
+sonderpreis(pos: int, preis: int)
+ auftragssumme(): int
+ print()
+ neuePosition(b: Bestellposition)
+ löschePosition(pos int)
+sonderpreis(pos: int, preis: int)
+ auftragssumme(): int
+ print()
1
array|multiset|
mapping
1
{ordered}
*
Bestellposition
Bestellposition
– anzahl: String
– preis: int
– anzahl: String
– preis: int
+ einzelpreis(): int
+ einzelpreis(p: int)
+ positionspreis(): int
+ einzelpreis(): int
+ einzelpreis(p: int)
+ positionspreis(): int
für
*
1
für
*
*
1
Artikel
Artikel
– name: String
– preis: int
– name: String
– preis: int
+ preis(): int
1 {ordered}
+ preis(): intProf. U. Aßmann, Softwaretechnologie
5
Generische Datentypen in Pike
►
Pike kennt generische Datentypen (array (arraylist), multiset (bag)). Beide
Collection-Datentypen können aber auch ungetypt verwendet werden
(mixed)
// This is pike, not Java
class Bestellung {
array(Bestellposition) positionen;
// generic
array positionen2;
// mixed
multiset(Bestellposition) positionen3; // generic
multiset positionen4;
// mixed
}
Bestellposition b1 = Bestellposition();
Bestellposition b2 = Bestellposition();
main() {
positionen = ({b1, b2});
// a typed array
positionen2 = ({b1, “A”, 3}); // a mixed array
positionen3 = ([b1, b2, b2]); // a typed multi-set (bag)
positionen4 = ([b1, b2, b2, ”A”, “A”]);
// a mixed multi-set (bag)
}
Prof. U. Aßmann, Softwaretechnologie
6
Mehr über Arrays in Pike
►
Mächtige Array-Operatoren, die sehr knappe Spezifikation von mächtigen
Algorithmen erlauben (gut für RAD)
// This is pike, not Java
array empty = ({});
// mixed, empty array
// An array of arrays of int
array(array(int)) p = ({ ({ 1, 3 }), ({ 2, 4, 3 })
});
array(int) a = ({ 1, 3 });
array(int) b = ({ 2, 4, 3 });
array
array
array
array
a_sum = a+b;
// ({ 1, 3, 2, 4, 3 })
a_difference = a-b; // ({ 1 })
a_intersection = a&b;// ({ 3 })
a_division = b/2.0; // ({ ({2,4}),({3}) }) Erzeugung von 2-d Arrays
Prof. U. Aßmann, Softwaretechnologie
7
Mappings (Assoziative Arrays) als allgegenwärtige
Datenstruktur
►
Pike hat assoziative Arrays eingebaut (mappings, in Java: Map)
■
►
Sehr sinnvoll, da mappings als explizit repräsentierte Funktionen in sehr vielen
Anwendungen vorkommen
Ein mapping ist ein array von (key, value) pairs
■
Zufügen mit +=, Entfernen mit -=
// This is pike, not Java
mapping empty = ([]);
// mixed, empty mapping
mapping(string:int) DresdenPhoneBook =
([ “Assmann” : 072349879, “Miller” : 08784994 ]);
mapping(string:int) GelsenkirchenPhoneBook = ([ ... ]);
mapping(string:mapping(string:int)= GermanPhoneBooks =
([ “Dresden” : DresdenPhoneBook,
“Gelsenkirchen”: GelsenkirchenPhoneBook, ... ]);
int assmann_phone = GermanPhoneBooks[“Dresden”][“Assmann”];
// Korregiere Assmanns Nummer
DresdenPhoneBook -= ({ “Assmann”:072349879 });
GelsenkirchenPhoneBook += ({ “Assmann”:048889879 });
Prof. U. Aßmann, Softwaretechnologie
8
Pike hat Mehrfachvererbung
►
Mehrfachvererbungen aus UML können direkt in Pike eingetippt werden
Nationality
German
// This is pike, not Java
class Elsaesser {
inherit Francais;
inherit German;
void eat () {
// super call auf Klasse Francais
Francais::mange();
};
void talk () {
// super call auf Klasse German
German::sprechen();
};
}
Francais
Elsaesser
Prof. U. Aßmann, Softwaretechnologie
9
String-Verarbeitung in Pike
►
►
Die wahre Stärke zeigt das Array-Konzept bei der String-Verarbeitung
Anwendungsgebiete der Stringverarbeitung:
■
■
■
►
Web-Programmierung (template processing von html-Schablonen)
Textverarbeitung
Suchanwendungen in Datenbasen
Strings sind ähnlich zu Arrays
■
Operatoren sum, intersect, division u.v.m.
// This is pike
string translateToWindows(string
// divide String by „/“
array(string) directories
// concatenate again with
return „\\“+directories *
}
path) {
= path / ”/”;
„\\“
“\\”;
translateToWindows(“/home/ua1/local/papers”);
Prof. U. Aßmann, Softwaretechnologie
10
String-Verarbeitung in Pike
►
►
Die map – Funktion wendet eine Funktion auf alle Elemente eines arrays an
Der * Operator distributiert ein Zeichen über ein Array von strings
// This is pike
string countPath(string path) {
return (array(string)) map(path / “/”, sizeof)
// ex.: ({ 4, 3, 5, 6 })
* “,”;
// ex.: “4,3,5,6”
}
countPath(“/home/ua1/local/papers”);
Prof. U. Aßmann, Softwaretechnologie
11
String-Verarbeitung: Splicing
►
Splice-Operator wendet eine Operation auf alle Elemente eines Arrays an
(ähnlich zu map)
// This is pike
array(string) currencies = ({ “Euro”, “Dollar”, “Yen”, “Pound” });
ausgabe(4.32, @currencies);
// 4.32 Euro
4.32 Dollar
4.32 Yen
4.32 Pound
ausgabe(4.32, “Euro”, “Dollar”, “Yen”, “Pound”);
// the same output
array(float) exchangeRates = ({ 1.32, 1, 4, 1.6 });
int money = 33;
float calc (float rate, int i) { return i*rate; }
array(float) moneys = map(exchangeRates, calc, money);
// accumulate moneys by + operator
float|int sum = +(0,@moneys);
Prof. U. Aßmann, Softwaretechnologie
12
Vorteil von Pike: Skalisierbare Typisierung
►
Man kann einen Pike Prototyp ohne Typisierung beginnen und die Typen
später hinzufügen
■
■
►
►
Um die Programmiersicherheit zu erhöhen
Um die Effizienz zu erhöhen
Ausserdem kann man Java aufrufen und schrittweise die Anwendung in Java
umwandeln
Das ist einmalig für eine Skriptsprache und hervorragend für RAD
Untypisierter Pike Prototyp
Typisierter Pike Prototyp
Prof. U. Aßmann, Softwaretechnologie
13
Abbildungsschritte
►
►
Der Platz von Skriptsprachen ist in der schnellen Prototypentwicklung
Pike kann zum Prototyping (RAD) verwendet werden
■
■
►
Einfache 1:1-Übersetzung von UML-Assoziationen und Mehrfachvererbung
Falls nicht schnell genug, bilde man das UML-Modell schrittweise auf Java ab.
Das ist aufwendiger, bringt aber mehr Effizienz und stärkere Typsicherheit.
Es ist sogar möglich, vom untypisierten Analysemodell aus zu beginnen
Analysemodell in UML
Entwurfsmodell in UML
Untypisierter Pike Prototyp
Typisierter Pike Prototyp
Java Produkt
Prof. U. Aßmann, Softwaretechnologie
14
Vergleich von Skriptsprachen: Pike vs Perl vs Python
►
Pike hat einen Übersetzer, der schnellen Code erzeugt. Pike ist die
momentan schnellste Skriptsprache (pike.ida.liu.se)
■
■
►
Python ist voll typisiert, hat aber keine Mehrfachvererbung
■
►
Skalierbare Typisierung
Ideal zur Abbildung von UML-Modellen
Schwierige Transformation von UML-Diagrammen
Perl hat Mehrfachvererbung, ist aber untypisiert
■
■
Gute Musterverarbeitung für Strings
Grosse Bibliothek
Prof. U. Aßmann, Softwaretechnologie
15
Andere Vorteile
►
►
►
►
►
►
Einfache Programmierung von GUI durch guten Anschluss von GTK (Gnu
Widget TookKit), analog zu AWT/Swing
Java kann aus Pike aufgerufen werden
Interaktive Umgebung “hilfe”
Einfache Installation auf Windows und Linux
Gute Unterstützung von XML
Gute Vorbereitung für Web-Programmierung
■
►
Roxen-Webserver in Pike programmiert
Aktive open-source community, die auf Fragen reagiert: probieren Sie es
aus!
Prof. U. Aßmann, Softwaretechnologie
16
End
►
http://pike.ida.liu.se
Prof. U. Aßmann, Softwaretechnologie
17