Scala (eBook)

Objekt-funktionale Programmierung

Oliver Braun (Autor)

eBook Download: PDF

2010 | 1. Auflage
330 Seiten
Carl Hanser Fachbuchverlag
978-3-446-42622-1 (ISBN)

Infos

Sie sind neugierig auf Scala, die neue, universale Programmiersprache, die Objektorientierung und funktionale Programmierung vereint? Sie wollen diese Sprache kennen lernen und erfahren, welche Vorzüge sie hat? Dann sind Sie hier richtig.
Oliver Braun führt Sie detailliert in die Sprache und ihre Syntax ein und stellt die Arbeitsumgebung für die Programmierung von Scala und die Ausführung des Codes vor. Er geht auf die für die Praxis wichtigen Themen Dokumentation und Testen ein und macht Sie mit den wichtigsten Bibliotheken und Frameworks vertraut. Besonders stark ist Scala im Bereich der nebenläufigen Programmierung, daher ist auch diesem Thema ein eigenes Kapitel gewidmet.
Insgesamt erhalten Sie einen umfassenden Überblick, welche Vorzüge Scala in der Praxis tatsächlich hat und eignen sich die Sprache anhand der vielen nachvollziehbaren Beispiele rasch an.

Autor

Prof. Dr. Oliver Braun ist Professor für Programmierung und verteilte Systeme an der Fachhochschule Schmalkalden. Zu seinen Schwerpunkten zählt die Funktionale Programmierung. Neben seiner Hochschultätigkeit berät er Firmen zu gesamtheitlichen IuK-Konzepten.

Inhalt

Inhaltsverzeichnis 8
Vorwort 12
1 Einführung 14
1.1 Was Führungskräfte über Scala wissen sollten 16
1.2 Java-Scala-Integration 17
1.3 Über dieses Buch 18
1.4 Typographische und sonstige Konventionen 19
2 Einrichten der Arbeitsumgebung 22
2.1 Die Scala-Shell und die Kommandozeile 22
2.1.1 Der Scala-Interpreter 24
2.1.2 Die Scala-(De-)Compiler 26
2.1.3 Der Dokumentationsgenerator 29
2.2 Buildtools 30
2.2.1 Das Maven-Scala-Plugin 30
2.2.2 Simple Build Tool 32
2.3 IDE-Support 35
2.3.1 Eclipse 35
2.3.2 NetBeans 36
2.3.3 IntelliJ IDEA 37
3 Grundlagen 40
3.1 Ein kleines bisschen Syntax 40
3.2 Imperative Programmierung 52
3.3 Ein ausführbares Programm 55
3.4 Annotations 57
4 Reine Objektorientierung 60
4.1 Klassen und Objekte 60
4.1.1 Felder und Methoden 60
4.1.2 Was Klassen sonst noch enthalten können 73
4.1.3 Konstruktoren 75
4.1.4 Enumerations 78
4.1.5 Vererbung und Subtyping 80
4.1.6 Abstrakte Klassen 86
4.2 Codeorganisation 91
4.2.1 Packages 91
4.2.2 Package Objects 92
4.2.3 Importe 93
4.3 Traits 95
4.3.1 Rich Interfaces 96
4.3.2 Stapelbare Modifikationen 101
4.4 Implicits und Rich-Wrapper 108
5 Funktionales Programmieren 114
5.1 Lazy Evaluation 115
5.2 Funktionen und Rekursionen 117
5.3 Higher-Order-Functions 121
5.4 Case-Klassen und Pattern Matching 127
5.4.1 Case-Klassen 132
5.4.2 Versiegelte Klassen 135
5.4.3 Partielle Funktionen 137
5.4.4 Variablennamen für (Teil-)Pattern 139
5.4.5 Exception Handling 139
5.4.6 Extraktoren 141
5.4.7 Pattern Matching mit regulären Ausdrücken 143
5.5 Currysierung und eigene Kontrollstrukturen 145
5.6 For-Expressions 154
5.7 Typsystem 160
5.7.1 Standardtypen 160
5.7.2 Parametrischer Polymorphismus und Varianz 161
5.7.3 Upper und Lower Bounds 164
5.7.4 Views und View Bounds 167
5.7.5 Context Bounds 168
5.7.6 Arrays und @specialized 168
5.7.7 Generalized Type Constraints 171
5.7.8 Self-Type-Annotation 173
5.7.9 Strukturelle und existenzielle Typen 175
6 Die Scala-Standardbibliothek 178
6.1 Überblick und das Predef-Objekt 178
6.2 Das Collection-Framework 183
6.3 Scala und XML 189
6.4 Parser kombinieren 193
6.5 Ein kleines bisschen GUI 200
7 Actors – Concurrency und Multicore-Programmierung 206
7.1 Ein Thread ist ein Actor 207
7.2 Empfangen und Reagieren 209
7.3 Dämonen und Reaktoren 220
7.4 Scheduler 222
7.5 Remote Actors 224
8 Softwarequalität – Dokumentieren und Testen 228
8.1 Scaladoc 229
8.2 ScalaCheck 234
8.2.1 Grundlagen 234
8.2.2 Generatoren 237
8.2.3 Automatisiertes Testen mit Sbt 242
8.3 ScalaTest 245
8.3.1 ScalaTest und JUnit 246
8.3.2 ScalaTest und TestNG 248
8.3.3 ScalaTest und BDD 249
8.3.4 Funktionale, Integrations- und Akzeptanztests 251
8.3.5 Die FunSuite 253
8.4 Specs 254
8.4.1 Eine Specs-Spezifikation 255
8.4.2 Matchers 257
8.4.3 Mocks mit Mockito 261
8.4.4 Literate Specifications 262
9 Webprogrammierung mit Lift 266
9.1 Quickstart mit Lift 267
9.2 Bootstrapping 270
9.3 Rendering – Templates und Snippets 275
9.4 Benutzerverwaltung und SiteMap 277
9.5 Persistenz 279
9.6 Implementierung der Snippets 282
10 Leichtgewichtige Webprogrammierung mit Scalatra 292
10.1 Quickstart mit Scalatra 292
10.2 Der Final-Grade-Calculator 294
11 Akka – Actors und Software Transactional Memory 300
11.1 Quickstart mit Akka 301
11.2 Der MovieStore 302
11.3 User- und Session-Management 306
11.4 Software Transactional Memory 310
11.5 Client und Service 313
Schlusswort 318
Literaturverzeichnis 320
Stichwortverzeichnis 324

Textauszug

"Kapitel 7 Actors – Concurrency und Multicore-Programmierung (S. 193-194)

Nebenläufige Programmierung insbesondere unter Nutzung mehrerer Cores wird immer mehr zur Standardaufgabe für Softwareentwickler. Das liegt daran, dass die Prozessoren nicht mehr schneller werden, sondern dass sich in einem Prozessor immer mehr Kerne befinden. Ein Prozessor mit sehr wenigen Kernen kann in der Regel durch Betriebssystemprozesse noch ganz ordentlich ausgenutzt werden. Nun können z.B. zwei Prozesse, die sonst abwechselnd rechnen durften, parallel arbeiten.

Werden es aber immer mehr Kerne, wird es essenziell notwendig, die Programme selbst in mehrere Prozesse oder Threads aufzuteilen. Nachdem Scala auf der Java Virtual Machine oder auf einer .NET-Runtime ausgeführt wird, ist natürlich alles aus Java bzw. .NET verfügbar, um nebenläufig (engl. concurrent) zu programmieren. Scala bietet aber noch eine weitere, sehr elegante Abstraktionsmöglichkeit, die auf einem mathematischen Modell von nebenläufi- ger Programmierung basiert: die Actors1.

Es gibt Implementierungen des Actor-Modells in einigen Programmiersprachen bis hin zu actorbasierten, general purpose Programmiersprachen wie z.B. ActorScript2. Die Scala-Implementierung lehnt sich von der Syntax stark an die Actor- Implementierung in der funktionalen Programmiersprache Erlang3 an. Actors sind ganz nach der Scala-Philosophie nicht im Sprachkern, sondern als Library im Package scala.actors verfügbar.

Die Grundidee des Actor-Modells ist, dass ein Actor mit anderen Actors nur über Messages kommuniziert. Wird einem Actor eine Message gesendet, landet diese in seiner Mailbox und bleibt dort, bis der Actor sie herausnimmt. Das heißt also, die Kommunikation ist grundsätzlich asynchron4. In diesem Kapitel geben wir Ihnen eine Einführung in die Welt der Scala-Actors. Wir beginnen in Abschnitt 7.1 damit, den Zusammenhang zwischen Actors und Threads zu erläutern. Wie ein Actor Messages empfangen und darauf reagieren kann, wird in Abschnitt 7.2 dargestellt. Besondere Aktoren, nämlich Reaktoren und Dämonen, sind Gegenstand von Abschnitt 7.3. Für Aktoren wird ein Scheduling benötigt. Informationen darüber finden Sie in Abschnitt 7.4. Das Kapitel schließt mit einem Blick auf Remote Actors (siehe Abschnitt 7.5)."

Produkt-Details

• Erscheint lt. Verlag: 1.1.2010
• Verlagsort: München
• Sprache: deutsch
• Themenwelt: Informatik ► Programmiersprachen / -werkzeuge ► Scala
• Schlagworte: Programmieren • Programmiersprache • Scala
• ISBN-10: 3-446-42622-1 / 3446426221
• ISBN-13: 978-3-446-42622-1 / 9783446426221