Konkatenative Programmierung mit Factor, Teil 3

9. August 2009 – 17:59 von Andreas

In diesem Teil der Factor-Einführungsreihe beschäftigen wir uns mit den Themen Currying, Kombinatoren und Closures.

1. Currying

Im vorherigen Beitrag wurden Quotations dargestellt, welche erst zum Zeitpunkt ihrer Ausführung ihren Daten-Stack abarbeiten. Es ist allerdings auch möglich bereits zur Definition der Quotation Parameter aus dem Stack in die Quotation zu bringen. Das Zauberwort heißt Currying.
Die Curry-Funktion nimmt eine Funktion entgegen und gibt wieder eine Funktion zurück.
Wenn
f: a X b -> c
und
curry(f)=g
dann gilt
g: a->(b->c)
f mappt also zwei Parameter a und b auf c.
g mappt einen Parameter a auf eine Funktion, die einen Parameter b auf c mappt.
curry mappt eine Funktion f auf eine Funktion g.
In Factor wird Currying mit Hilfe des Words curry, wie in Listing 1.1.

! Einmal curry angewendet bringt das erste
! Argument in die Quotation
1 2 [ ] curry
=> 1 [ 2 ]

! Zweimal curry angewendet würde am Ende
! beide Argumente in die Quotation bringen
1 2 [ ] curry curry
=> [ 1 2 ]

Listing 1.1 Currying in Factor

Factor bietet außer dem Word curry auch noch 2curry, 3curry und ncurry. Die Funktionsweise dieser Words erkennt man am besten anhand der Beispiele in Listing 1.2.

! bringt ein Element in die Quotation
1 [ ] curry
=> [ 1 ]

! bringt zwei Elemente in die Quotation
1 2 [ ] 2curry
=> [ 1 2 ]

! bringt drei Elemente in die Quotation
1 2 3 [ ] 3curry
=> [ 1 2 3 ]

! bringt n Elemente (hier 5) in die Quotation
1 2 3 4 5 [ ] 5 ncurry
=> [ 1 2 3 4 5 ]

Listing 1.2 Anwendung der curry-Words

Je nachdem, wie viele Elemente die Quotation auf dem Stack erwartet, können die entsprechenden curry-Words verwendet werden, um die Elemente direkt in die Quotation zu bringen. Dies kann auch bei den vorherigen Beispielen, wie in Listing 1.3 und 1.4 zu sehen, angewendet werden.

: get-add-and-sq-quot ( x y — quot )
[ + sq ] 2curry ;

: add1-to-result-of-quot ( quot — result )
call( — result ) 1 + ;

Listing 1.3 Verwendung von 2curry in einem Beispiel

2 4 get-add-and-sq-quot add1-to-result-of-quot
=> 37

Listing 1.4 Anwendung der neu definierten Words

In Listing 1.3 werden nun mit 2curry die beiden Stack-Elemente x und y direkt in die Quotation gegeben. Beim call der übergebenen Quotation in add1-to-result-of-quot müssen x und y nicht mehr auf dem Parameter-Stack liegen, da diese ja nun schon in der Quotation enthalten sind.

2. Kombinatoren

Kombinatoren sind spezielle Funktionen höherer Ordnung (Higher-Order Functions). Eine Funktion höherer Ordnung ist wiederum eine Funktion, die Funktionen als Argumente entgegennimmt und gegebenenfalls eine Funktion zurückgibt. In Factor gibt es u.a. drei wichtige Typen von Kombinatoren:
- Cleave Combinators: Diese Kombinatoren wenden mehrere Quotations auf einen einzelnen Wert an.
- Spread Combinators: Diese Kombinatoren wenden mehrere Quotations auf mehrere Werte an.
- Apply Combinators: Diese Kombinatoren wenden eine einzige Quotation auf mehrere Werte an.
Als Beispiel wird der Cleave Combinator bi verwendet, welcher zwei Quotations auf einen Wert anwendet. bi hat den Stack-Effekt: ( wert quot1 quot2 — ). Zuerst wendet bi die Quotation quot1 auf wert an. Danach wird quot2 auf wert angewendet. quot1 und quot2 haben beide denselben Parameter-Stack. Sie erwarten beide den Parameter wert auf dem Stack. Das Ergebnis der Quotations kann unterschiedlich sein und ist nicht vorgegeben. Unter bi-Dokumentation sind weitere Informationen zu bi zu finden.
In Listing 2.1 ist die Anwendung von bi zu sehen.

2 [ 1 + ] [ sq ] bi
=> 3
4

Listing 2.1 Verwendung des bi-Kombinators

In dem Code-Beispiel wird zuerst [ 1 + ] auf 2 angewendet, wodurch das Ergebnis 3 auf den Stack gelegt wird. Danach wird [ sq ] auf 2 angewendet und die Zahl 4 als zweites Ergebnis auf den Stack gelegt. Informationen zu weiteren Kombinatoren von Factor können aus der Factor-Dokumentation entnommen werden.

3. Closures

Eine Closure ist eine Funktion, die auf Variablen in ihrem Definitionskontext zugreifen kann. Ein kleines Beispiel hierfür ist unter closures-vs-eval zu finden. Factor bietet hierfür Locals. Sie implementieren einen lexikalischen Scope mit der Unterstützung für Closures. Ein neues Word wird dann nicht mit dem bereits bekannten Doppelpunkt : definiert, sondern mit einem doppelten Doppelpunkt ::. Die restliche Notation ist analog zu der eines normalen Words. Der große Unterschied ist, dass die Eingabewerte aber nicht direkt vom Stack geholt und verarbeitet werden, sondern an die Parameter namentlich gebunden werden. Bei folgender Definition sind x und y also Bindungsvariablen, welche die Eingangs-Stack-Werte an sich binden: :: add ( x y — result ). Innerhalb des Funktionsrumpfes müssen nun auch die Variablen namentlich referenziert werden, um auf deren gebundene Werte zugreifen zu können. Die Werte der Bindungen liegen hierbei auf einem versteckten Stack von Factor. Ein Beispiel hierzu kann aus Listing 3.1 entnommen werden. Die Verwendung dieser Words ist aber analog zu den bisher Behandelten.

:: add ( x y — result )
x y + ; ! Namentliche Referenzierung ist hier notwendig!

Listing 3.1 Verwendung von Locals

Durch Locals ist es möglich, in Quotations namentlich auf Bindungen zu referenzieren. Die Quotation behält dann Definitionskontext der Bindungen. In Listing 3.2 kann man dies an einem Beispiel sehen.

:: get-xyadd-quot ( x y — quot )
[ x y + ] ;

Listing 3.2 Verwendung von Locals

Konkatenative Programmierung mit Factor, Teil 2

29. Juli 2009 – 18:44 von Andreas

Nachdem wir uns im ersten Teil der Factor-Reihe mit dem grundlegenden Ausführungsmodell befasst haben, kommen wir nun zu den Words (Funktionen). Wir werden also sehen, wie wir eigene Words definieren und ein paar vordefinierte, sehr hilfreiche Words verwenden können. Zum Schluss werden wir uns dann noch anonyme Funktionen (diese werden in Factor als Quotations bezeichnet) anschauen.

1. Definieren von eigenen Words

Mit dem Schlüsselwort : ist es möglich eigene Words zu definieren. Ein Beispiel hierfür ist unter Listing 1.1 zu finden.

: add-and-sq ( x y — result )
+ sq ;

Listing 1.1 Definieren eigener Words

Wie in dem Beispiel zu sehen ist, wird die Definition durch ein : eingeleitet. Danach folgt der Bezeichner und der Stack-Effekt. Dieser zeigt an, was das Word zu Beginn auf dem Stack erwartet und welche Elemente am Ende der Verarbeitung wieder auf dem Stack liegen. Im Listing 1.1 werden zwei Elemente (x und y) vom Stack benötigt und am Ende ein Element (result) wieder auf den Stack gelegt. Hierbei zu beachten ist vor allem, dass man innerhalb des Funktionsrumpf nicht auf die Parameter x und y namentlich referenzieren kann. Es handelt sich nur um die Angabe, welche Effekte das definierte Word auf den Stack hat. Im Funktionsrumpf kann man nun mit den erwarteten Eingangswerten arbeiten. Im Beispiel wird wieder eine Addition durchgeführt und anschließend das Ergebnis mit sich selbst multipliziert. Abgeschlossen wird eine Word-Definition mit einem ; .

2. Shuffle-Words
Unter Shuffle-Words versteht man vordefinierte Words, welche einem helfen auf dem Stack zu arbeiten. Angenommen es sind drei Werte x y und z auf dem Stack. Zur nachfolgenden Verarbeitung werden diese allerdings in einer anderen Reihenfolge benötigt. Ein Shuffle-Word kann genau in dieser Situation helfen. Wollen wir hier z.B. y und z vertauschen, verwenden wir einfach das Shuffle-Word swap, welches folgenden Stack-Effekt hat: ( x y — y x ). Eine Übersicht über die existierenden Shuffle-Words sind in der Factor-Dokumentation zu finden.

3. Anonyme Funktionen
Anonyme Funktionen werden in Factor als Quotations bezeichnet. Diese werden durch zwei eckige Klammern ([, ]) definiert. Innerhalb der Klammern wird dann der Code geschrieben, welcher in der anonymen Funktion ausgeführt werden soll. Ein Beispiel ist unter Listing 3.1 zu finden.

[ + sq ]
=> [ + sq ]

Listing 3.1 Definieren einer Quotation

Im Listing 3.1 werden die im vorherigen Abschnitt verwendeten Words + und sq in einer Quotation verpackt. Die Quotation wird allerdings nicht sofort ausgeführt sondern mit den beiden Befehlen auf den Datenstack gelegt und kann dann zu einem späteren Zeitpunkt ausgeführt werden (auch verzögerte Ausführung genannt). Wollen wir die auf dem Stack liegende Quotation nun ausführen, können wir das Word call, wie in Listing 3.2, verwenden.

2 4 [ + sq ] call
=> 36

Listing 3.2 Ausführen einer Quotation

Wenn die Quotation ausgeführt wird müssen natürlich auch die benötigten Werte für die Befehle innerhalb der Quotation auf dem Stack liegen (in unserem Beispiel 4 und 5 für die Addition). Die Ausführung läuft also folgendermaßen ab: Zuerst wird die Quotation ausgeführt, so dass 2 4 + sq zur Ausführung bereitsteht. Nun werden 2 und 4 durch + addiert und danach durch sq weiterberechnet. Anschließend steht dann nur noch das Ergebnis auf dem Stack.
Durch Quotations gibt es eine Möglichkeit Code, wie normale Daten auf den Stack zu legen und verzögert auszuführen. Es können natürlich auch Words definiert werden, welche am Ende ihrer Ausführung eine Quotation auf den Stack legen. Ein Beispiel ist in Listing 3.3 und 3.4 zu finden.

: get-add-and-sq-quot ( — quot )
[ + sq ] ;

Listing 3.3 Arbeiten mit Quotations in eigenen Words

get-add-and-sq-quot
=> [ + sq ]

Listing 3.4 Setzen einer Quotation durch ein Word

Es können also Quotations über den Programmablauf hinweg an verschiedene Words weitergegeben und dann verzögert ausgeführt werden. Das Problem beim Word call ist, dass wenn man z.B. eine Quotation als Parameter an ein Word übergibt, an call nicht sieht welchen Stack-Effekt diese aufgerufene Quotation hat. Um dies (für den Compiler und auch den Entwickler) darstellen zu können, wird das Word call( verwendet. Mit call( kann der Stack-Effekt der Quotation, wie bei Listing 3.5 und 3.6 hinter die Klammer geschrieben werden.

: get-add-and-sq-quot ( — quot )
[ + sq ] ;

: add1-to-result-of-quot ( x y quot — result )
call( x y — result ) 1 + ;

Listing 3.5 Verwendung des Words call(

! Kommentare werden mit ! und einem Leerzeichen
! eingeleitet.
! rot ist ein shuffle Word und hat folgenden
! Stack-Effekt: rot ( x y z — y z x )
! Da add1-to-result-of-quot x y quot erwartet, aber quot
! x y auf dem Stack liegt muss der Stack mit rot passend
! umgebaut werden.

get-add-and-sq-quot 2 4 rot add1-to-result-of-quot
=> 37

Listing 3.6 Anwendung der definierten Words

In add1-to-result-of-quot wird in diesem Beispiel also die Quotation mit dem Stack-Effekt ( x y — result ) ausgeführt und dem Ergebnis wird dann noch die Zahl eins zuaddiert.

Einführung in die konkatenative Programmierung mit Factor

22. Juli 2009 – 14:58 von Andreas

Factor? Noch nie gehört? Dann wird es aber Zeit! Es handelt sich hierbei um eine multiparadigmatische (was für ein Zungenbrecher ;-), konkatenative/stackbasierte Programmiersprache, die aus einem sehr einfachen Kern besteht. Sie wurde 2003 von Slava Pestov ins Leben gerufen und erfreut sich seit dem immer größerer Beliebtheit. Aber warum schon wieder eine neue Programmiersprache lernen? Factor ist eine sehr faszinierende Programmiersprache, die einem ermöglicht Programme in einer unglaublichen Kürze (wovon Sprachen wie C# oder Java nur träumen können) zu schreiben. Außerdem bietet Factor sehr moderne Programmierkonzepte, Paradigmen und Möglichkeiten:

  • Objektorientierte Programmierung
  • Funktionale Programmierung
  • Metaprogrammierung
  • Es ist kein Zufall, dass der Name Factor sehr stark an Refactoring erinnert. Denn genau hier liegt eine große Stärke der Sprache (warum dies so ist wird im Rahmen folgender Blog-Beiträge klar)
  • Es ist möglich die Sprache selbst zu erweitern, um z.B. neue Konzepte einführen zu können (Stichwort Parsing Words)
  • Die Sprache eignet sich auch sehr gut zum Erstellen von domänenspeziefischen Sprachen

Ich hoffe, dass ich euch ein bisschen neugierig machen konnte und ihr nun Interess an dieser sehr modernen Programmiersprache bekommen habt. In diesem und folgenden Blog-Einträgen will ich euch ein wenig in die Sprache einführen und zeigen, was sie so besonders macht.

Eine stackbasierte Programmiersprache arbeitet, wie der Name schon sagt, grundlegend auf einem Stack. Der Stack wird dazu verwendet, jegliche Form von Daten (z.B. Funktionsargumente oder Rückgabewerte) zu speichern/abzulegen und später wieder abzurufen. Es werden also nicht wie z.B. in Java Variablen deklariert, diese dann später initialisiert und über den Programmverlauf hinweg in ihrem Gültigkeitsbereich namentlich referenziert und verwendet. In stackbasierten oder auch konkatenativen Sprachen werden Daten einfach durch eine Aneinanderreihung von Funktionen, die untereinander ihre Werte weitergeben, auf einem Stack bearbeitet und weitergereicht.

Beginnen möchte ich mit dem grundlegenden Ausführungsmodell der Sprache.

  1. Grundlegendes Ausführungsmodell

Bei Factor handelt es sich um eine stackbasierte Programmiersprache mit einer sehr einfachen Syntax. Ein Programm besteht im Wesentlichen aus Words und Literals. Ein Word ist wiederum eine einfache Funktion. Da die Words einfach hintereinander gehängt/konkateniert werden können, spricht man bei Factor auch von einer konkatentiven Sprache. Unter Literals versteht man Literale, wie z.B. Ganzzahlen, Gleikommazahlen, Zeichen, usw.. Hinter jedem Literal oder Word muss ein Leerzeichen (als Trennzeichen) folgen. Die Code-Zeile in Listing 1.1 verdeutlicht, wie Literals und Words verwendet werden. Bei den Code-Beispielen können Zeilen 1:1 in die Factor-Konsole kopiert und getestet werden. Das Symbol => sollen die aktuellen Werte auf dem Stack zeigen.

2 4 +
=> 6

Listing 1.1 Addieren von zwei Zahlen in Factor

Hier werden die beiden Literale 2 und 4 auf das Word + angewendet. Wenn man imperative Sprachen wie z.B. C# oder Java gewohnt ist, scheint einem diese Notation zuerst ungewohnt, da man in diesen Sprachen 2 + 4 geschrieben hätte. Denkt man aber an den Stack als interne Datenstruktur, wird einem klar, warum die Reihenfolge von Words und Literals so sein muss. Das Word + nimmt zwei Zahlen vom Datenstack, addiert diese und legt das Ergebnis wieder auf den Stack. Die beiden Parameter 2 und 4 müssen daher vor dem Aufruf von + auf dem Stack liegen, so dass + diese dann vom Stack nehmen kann. Durch dieses Ausführungsmodell ist es, wie in Listing 1.2 zu sehen, auch möglich, die Words einfach aneinanderzureihen.

2 4 + sq
=> 36

Listing 1.2 Konkatenation von Words

Da nach der Addition das Ergebnis 6 auf dem Stack liegt, kann das Word sq (multipliziert eine Zahl mit sich selbst) direkt diese Zahl wieder als Parameter vom Stack nehmen, die Multiplikation durchführen und das Ergebnis auf den Stack legen. Mathematisch gesehen, ist dieser Aneinanderreihung einfach eine Komposition von Funktionen.

So viel fürs erste! Das bisher erklärte hat noch nicht wirklich einen Wow-Effekt. Der wird aber hoffentlich noch kommen ;-). Hier ging es erstmal um das grundlegende Ausführungsmodell.

Hier noch ein paar Links zu Factor:
- http://factorcode.org/ Offizielle Factor-Seite (Hier ist u.a. auch der Download der Umgebung zu finden)
- http://docs.factorcode.org/ Factor-Dokumentation

Fortsetzung folgt…

SOA - Einführung und Praxis

27. Februar 2009 – 20:35 von Roy

Heute bin ich beim lesen der neuen Ausgabe des OBJEKTSpektrums auf folgenden Link gestoßen:

Informationsplattform SOA-Know-How.de
http://soa-know-how.de/index.php?id=7

Die Seite bietet allerhand Informationen rund um SOA. Neben einem SOA-Leitfaden auch etliche Referenzprojekte und Praxisbeispiele.

Praktisches Beispiel einer DSL

3. Februar 2009 – 18:57 von Roy

Auf der OOP in München hab ich Dennis getroffen. Wir haben uns über alle möglichen Themen Rund um die OOP unterhalten und sind bei dem Thema DSL (Domain Specific Language) hängen geblieben. Einige Vorträge auf der OOP behandelten dieses Thema mehr oder weniger oberflächlich. Andreas hat darüber ja auch schon mal geblogt. Mir fehlte einfach der große Zusammenhang zwischen warum entwickelt man eine DSL, wie entwickelt man sie, was benötigt man dazu und welche Vorteile bringt sie (oder kann sie bringen). Schlichtweg fehlte mir ein praktisches Beispiel das Dennis mir jetzt geliefert hat.

Von seinem Blog kann man sich seine sog. Mini Language runterladen mit der man geometrische Formen zeichnen kann. Die Domäne ist also klar. Das kleine Beispiel hat sehr viel zu meinem Verständnis beigetragen. Danke dafür!!! Seit dem ich mir das Programm genauer angeschaut und das Konzept dahinter zu verstehen glaube, sehe ich überall nur noch mögliche DSL’s. Es gibt schließlich genügend Domänen :)

Falls jemand noch weitere praktische Beispiele kennt, gebt mir Bescheid.

Zurück von der OOP 2009 (München)

1. Februar 2009 – 14:30 von Roy

Ich bin zurück von der diesjährigen OOP 2009, die in München stattfand. Und um es schon mal vorwegzunehmen, ich bin richtig begeistert. Viele interessante Vorträge und vor allem unterhaltsame KeyNotes von namhaften Sprechern bis hin zu einem angenehmen Rahmenprogramm lassen mich zu diesem Urteil kommen. Und nein, ich habe keine rosarote Brille auf. Zwei Vorträge habe ich wegen beginnender Kopfschmerzen auf Grund mangelnder Qualität des Inhalts sowie der Sprecher verlassen müssen. Ich konnte die gewonnene Zeit aber sinnvoll damit verbringen, mich mit einigen Ausstellern über interessante Themen, wie Scrum oder Testautomatisierung zu unterhalten.

Zusammenfassen würde ich die OOP mit eigenen Worten wie folgt: Wie entwickelt man Software. Das Vortragsspektrum handelte dieses Thema von “Wie entwerfe ich qualitativ hochwertige Architekturen” bis “Wie kann das Ganze nachhaltig dokumentiert werden” und “Wie gehe ich dabei vor” ab. Von Vorträgen über Soft Skills bis zur Anwendung von Design Patterns war alles dabei. Angesprochen durften sich dabei alle beteiligten Rollen eines Software-Projekts fühlen; vom Manager und Architekten bis zum Programmierer und Tester. Es war also für Jeden was dabei.

Meine persönlichen Highlights waren die beiden KeyNotes von Tom DeMarco und Horst Zuse (Sohn von Konrad Zuse). Ich fand es sehr interessant solche Leute mal live auf der Bühne sprechen zu hören. Beide KeyNotes waren sehr unterhaltsam. DeMarco sprach in seiner KeyNote über die negativen Auswirkungen von Prozessoptimierung und Produktivität. Leider kann ich mich nicht mehr an alle Einzelheiten seines Vortrags erinnern aber Sven Schneider hat das Ganze auf seinem Blog schön zusammengefasst. Nach der KeyNote hat DeMarco fleißig Autogramme verteilt, von denen ich mir gleich mal eines abgeholt habe. Die KeyNote von Prof. Dr. Horst Zuse fand ich sehr interessant da es hier ausnahmsweise mal weniger um aktuelle Trends und Entwicklungen ging sondern um den Ursprung des Computers und das Lebenswerk seines Vaters.

Alles in allem also eine gelungene Veranstaltung, die sich für mich persönlich auf jeden Fall gelohnt hat. Auch nächstes Jahr werde ich versuchen wieder dabei sein zu können. Auf der diesjährigen OOP habe ich genügend Material, Ideen und Anreize erhalten die mich sicher bis zur OOP 2010 beschäftigen werden. Wer weiterführende Informationen über die OOP sucht findet alles nötige auf www.oop2009.de.

Kurzes Review, Microsoft Technical Summit 2008

22. November 2008 – 13:33 von Andreas

Gestern Abend bin ich frisch vom diesjährigen MS Technical Summit 2008 aus Berlin zurückgekommen. Hier nun ein kleines Resume, wie ich diese Veranstaltung empfunden habe.
Eines der Highlights des Summits war sicher die Keynote (was ich nicht gedacht hätte). Patrick Baudisch und Steve Teixeira zeigten einen guten Mix aus Forschungsprojekten, kleinen Code-Demos und strategischen Infos zu den Themen “Mobile Anwendungen” (Patrick Baudisch) und “Parallel Computing” (Steve Teixeira). Patrick, der eine gewisse Zeit bei MS Research hinter sich hat gab den Zuhörern einen Einblick wie einige seiner Ideen entstanden bzw. sich über die Zeit entwickelt haben (ein wirklich hoher Unterhaltungs- und Coolness- Faktor ;-). Wer näheres zu neuen Bedienkonzepten für mobile Anwendungen wissen will sollte sich mal bei den Projekten von Patrick umschauen http://www.patrickbaudisch.com/projects/index.html. Steve Teixeira ist Product Unit Manager für das Parallel Development Tools Team und konnte uns einen guten Überblick über die neuen Möglichkeiten für .NET und Native Code (ja wirklich natives C++ ;- ) bzgl. der Entwicklung von Anwendungen, welche auf eine möglichst einfache und produktive Art und Weise mehrere CPU Cores nutzen können geben. Im Blog von Jens Peter Kleinau könnt ihr euch ein paar Live-Photos und weitere Infos aus der Präsentation holen.
Nach diesem super Einstieg ging es weiter zu den eigentlichen Vorträgen. Hierzu muss ich sagen, dass einige Vorträge wirklich meine Erwartungen erfüllt haben, andere wiederum doch sehr enttäuschend waren. Für meinen Geschmack wurde bei manchen Themen nicht tief genug in die Materie hineingegangen. Die Infos aus der Session “ASP.NET Features” waren z.B. sehr oberflächlich. Gut, man muss dazu sagen, dass es in Sessions von nur einer Stunde wirklich schwierig ist auch Hintergrundinformationen zu vermitteln. Vielleicht hätte man die Vortragszeit auf zwei Stunden erhöhen und daür andere Sessions weglassen sollen.
Naja, ich möchte aber nicht zu viel meckern. Im Gesamten war ich mit dem Summit doch sehr zufrieden. Ich habe viele neue Einrdücke und Infos zu Themen erhalten, die ich mir sicherlich näher anschauen werde. Außerdem hat die Firma telerik ein paar .NETte T-Shirts verteilt:

In diesem Sinn auf in den .NET-Kampf ;-)

Alle Zeilen einer Tabelle anzeigen

8. Oktober 2008 – 16:49 von Roy

Im Management Studio des SQL Servers 2008 können durch das Kontextmenü einer Tabelle nicht alle Zeilen der gewählten Tabelle zurückgegeben werden, was sehr nervig sein kann wenn man eine Tabelle mit mehr als 200 Zeilen hat.

Dieser Umstand lässt sich in den Optionen einfach ändern. In den Einstellungen der allgemeinen Skriptoptionen den Wert von 200 auf 0 setzen, wie in folgender Abbildung zu sehen ist.

scriptoptions_ssms

Damit werden immer alle Zeilen einer Tabelle angezeigt, wie man es aus dem Enterprise Manager und dem SSMS des SQL Servers 2005 kennt.

show_all_ssms

SSMS schneller starten

8. Oktober 2008 – 16:39 von Roy

Startet man das SQL Server Management Studio des SQL Servers 2008/2005 wird vor dem eigentlichen Start des Tools eine gewisse Zeit lang eine Splash-Screen angezeigt.

ssms_splash

Allerdings verzögert diese Splash-Screen den Start des SSMS nur unnötig und kann deaktiviert werden wenn man sich daran satt gesehen hat. Dazu legt man sich eine neue Verknüpfung der Datei

 

[SSMS Version 10]

C:\Programme\Microsoft SQL Server\90\Tools\Binn\VSShell\Common7\IDE\Ssms.exe

 

[SSMS Version 9]

C:\Programme\Microsoft SQL Server\90\Tools\Binn\VSShell\Common7\IDE\SqlWb.exe

an oder verwendet eine vorhandene Verknüpfung und fügt in der Textbox Ziel den Startparameter /nosplash an.

property_splash

Für die ganz Ungeduldigen startet das Management Studio dann schneller.

Lösung zur F#-Aufgabe, Teil 4

14. September 2008 – 17:38 von Andreas

Ein paar Wochen sind nun vergangen und ich möchte euch die Lösung auf meine kleine F#-Aufgabe nicht vorenthalten.

Hier nochmal die Aufgabenbeschreibung:
Schreibt eine Funktion “create_matrix”, welche als Paramater die Zeilen, Spalten und einen Initialwert enthält (also “let create_matrix(rows,cols,initvalue) = …” ). Die Funktion gibt eine Liste zurück, welche wiederum für jede Zeile der Matrix wiederum eine Liste enthält.
Wird die Funktion folgendermaßen aufgerufen: “create_matrix(3,4,0)” so sollte folgende Liste (welche die 3×4-Matrix repräsentiert) erstellt und zurückgegeben werden: [ [ 0; 0; 0; 0]; [ 0; 0; 0; 0]; [ 0; 0; 0; 0] ].
Außerdem wäre es schön wenn ihr noch eine Funktion printmatrix schreiben würdet, welche die Matrix formatiert auf der Konsole ausgibt:

  1. printmatrix(create_matrix(3,4,0))

Ausgabe:
Matrix:
[0; 0; 0; 0]
[0; 0; 0; 0]
[0; 0; 0; 0]

Hier nun die Lösung mit ein wenig Kommentar:

  1. (*
  2.  Erstellt eine Matrix als Liste,
  3.  welche wiederum Listen enthaelt.
  4.  Dabei ist jede Liste innerhalb der
  5.  "root"-Liste eine Zeile.
  6.  *)
  7. let create_matrix(rows,cols,initvalue) =
  8.     [for x in 1 .. rows ->
  9.         [ for y in 1 .. cols -> initvalue] ]
  10.  
  11. (*
  12.  Gibt eine mit create_matrix erstellte
  13.  Matrix lesbar auf die Konsole aus.
  14. *)
  15. let printmatrix (matrix) =
  16.     print_string "Matrix:"
  17.     List.iter(fun list ->
  18.        print_string "\n"
  19.        print_any list) matrix

Wenn euch noch etwas unklar erscheinen sollte, dann postet die Frage einfach als Kommentar:)!