Scala Profis

Scala Profis

By Benjamin Hagemeister, Sven WiegandTechnology
Download on the App Store

Scala Profis episodes

  • SP12/17: Die große Jahresend-Show

    Scala 2.12.4

    Scala 2.12.4 wurde am 20. Oktober freigegeben.

    Änderungen:

    • Weitere 5–10% Verbesserung in den Compile-Time benchmarks gegenüber 2.12.3
    • Java‑9–Unterstützung verbessert
    • Links
      • Scala 2.12.4
      • Reasonable Scala

        Reasonable Scala ist ein neuer Scala-Compiler der von Eugene Burmako und seinem Team bei Twitter entwickelt wird.

        Es handelt sich dabei nicht um einen Fork vom Lightbend Scala-Compiler, sondern um eine komplette Neu-Implementierung die nur ein Ziel hat: Möglichst schnell zu kompilieren. Die Idee besteht offenbar darin zu identifizieren wie die Performance verbessert werden kann, damit diese Erkenntnisse dann in andere Scala-Compiler einfließen können.

        In den ersten Performance-Messungen ist der rsc deutlich schneller als der Lightbend Scala-Compiler. Allerdings sind momentan auch noch nicht alle Scala-Features entwickelt, so dass die Ergebnisse nicht vergleichbar sind.

        Links
        • Reasonable Scala
        • Compiler Performance
        • Scala vs. Kotlin in der Praxis

          Sven hatte die ein kleines Scala-Projekt nach Kotlin zu überführen und konnte so Erfahrungen aus der Praxis sammeln und eine differenzierte Bewertung vornehmen.

          Das vermisse ich
          • Pattern Matching
          • Pattern Matching
          • Pattern Matching
          • Scala collections: List mit head und tail in Verbindung mit Pattern Matching und Rekursion
          • Echte immutable Collections
          • Partial Functions inklusive collect
          • match an Infix-Position im Vergleich zu when-Expression in Kotlin
          • Implizites Type-Widening für byte, etc.
          • Tuples
          • Implicits
          • Das finde ich besser
            • kein new-Operator
            • Benannte Parameter für Lambda-Deklarationen (z.B. type EventCallback = (event: Event) -> Boolean)
            • Top-Level-Functions
            • Extension Functions für Monkey Patching
            • Properties
            • Markdown für Dokumentation
            • IDE-Support
            • Interoperabilität mit Java. z.B.
              • Getter werden zu Properties (das get am Anfang des Methodennamens enfällt)
              • Kotlin-Klassen gut in Java zu nutzen
              • Funktionen ohne Parameter haben immer Klammern. Außer Property-getter
              • Klare Regelung für () vs. {}
              • Bezeichnung data class vs. case class
              • Variance-Bezeichner in and out klarer als + und -
              • Gradle als Standard-Build-System
              • Neutral
                • Option vs ?
                • Null-/Cast-Branch-Analyse
                • _ vs it
                • Das finde ich schlecht
                  • Usability Immutable Collections
                  • Fazit

                    Ich würde Kotlin einsetzen, wenn es darum geht ein bestehendes Java-Projekt zu modernisieren oder in einem neuen Projekt mit einem Entwicklungs-Team, dass sich nicht für Scala begeistern kann.

                    Ansonsten ist Scala weiterhin die mächtigere und für meinen Geschmack schönere Sprache. Daher würde ich sie in Neuprojekten weiterhin bevorzugen.

                    Ideal wäre es wenn Scala 3 mit einigen der oben genannten Ungereimtheiten aufräumen würde.

                    So, what’s wrong with SBT?

                    Li Haoyi hat über SBT gebloggt und sieht einige Probleme. Dabei konzentriert er sich auf interne Probleme, die in erster Linie relevant für Plug-In Entwickler sind und Anwender nicht direkt betreffen.

                    In seinem Fazit stellt er fest, dass Tooling eines der größten Probleme in der Scala-Community ist und damit auch eine große Hürde für Einsteiger ist.

                    In seinem Artikel verweist er an zwei Stellen auf Bazel einem in Python geschriebenen Build-Tool, dass auch für andere Sprachen verwendet werden kann, für das es aber bisher keinen Scala-Support gibt. Andere Build-Tools wie CBT oder Gradle werden nicht erwähnt obwohl auch die vieles richtig machen, was SBT falsch macht.

                    Zusätzlich hat er auf Twitter (sieht hier und hier) nachgefragt wer Interesse daran hat an einem neuen Build-Tool für Scala mit zu arbeiten. Dem zweiten Tweet zufolge gibt es auch schon einen Plan und einen Prototypen. Merkwürdigerweise findet das bisher aber offenbar komplett hinter verschlossenen Türen statt. Es gibt keine Web-Seite und auch keine öffentliche Diskussion dazu.

                    Mir persönlich wäre es lieber wenn es dazu erst mal eine Diskussion gäbe, am besten unter der Kontrolle vom Scala-Center. Bevor man anfängt was neues zu entwickeln sollte man gucken ob man nicht z.B. CBT weiter ausbauen kann oder ein anderes Build-Tool wie Gradle oder Bazel um guten Scala-Support erweitern kann. Gradle hätte für mich den großen Vorteil, dass viele Java-Entwickler Gradle bereits kennen und damit Scala einsetzen können ohne sich an ein neues Build-Tool gewöhnen zu müssen.

                    Links
                    • Haoyi’s Programming Blog
                    • Bazel
                    • Gradle
                    • CBT
                    • Resümee 2017
                      Svens Resümee

                      Insgesamt empfinde ich 2017 als ein ruhiges Scala-Jahr.

                      Die aus meiner Sicht wichtigsten Events/Erkenntnisse waren folgende:

                      • dotty wird nun mehr oder weniger als Scala 3.0 gesehen
                      • Fokussierung auf Multi-Plattform-Entwicklung mit Scala Native und Scala.js. Für letzteres schätze ich die Wahrscheinlichkeit einer größeren Bedeutung im Vergleich zu Konkurrenten wie TypeScript als gering ein.
                      • Der Kampf um Android ist verloren.
                      • Ein Scala 3, das alte Zöpfe und Ungereimtheiten beseitigt scheint noch weit entfernt.
                      • Benjamins Resümee

                        Ich würde das zwar nie offen zugeben, aber Sven hat Recht: 2017 war ein ruhiges Scala-Jahr.

                        Es haben sich aber immerhin drei meiner vier Wünsche erfüllt:

                        • SBT 1.0 ist draußen
                        • Wir konnten auf Scala 2.12 umstellen.
                        • Unser Team ist vollständig.
                        • Ansonsten ist für mich noch das Engagement des Scala-Centers bei den Macros wichtig.

                          Wünsche 2018
                          Svens Wünsche
                          • Eine klarere Roadmap für Scala 3 und was wir davon erwarten können. Diese Aussicht könnte für Entscheidungsträger interessant sein, ob bei neuen Projekten auf Scala oder weniger komplexe Alternativen wie Kotlin gesetzt wird.
                          • Unterstützung einer vollwertigen Alternative zu SBT durch das ScalaCenter
                          • Benjamins Wünsche
                            • def Macros auf Basis von Scalameta und zwar nicht nur als Prototyp, sondern so, dass auch ein einfacher Scala-Entwickler sie nutzen kann. Am besten gleich mit ein bisschen Dokumentation.
                            • Bessere Unterstützung von Macros in IntelliJ IDEA.
                            • Ein schneller Scala-Compiler.
                            • Gib uns Dein Feedback als Kommentar auf unserer Web-Site, via Twitter oder Google+.

                              Kapitel
                              1. Intro (00:00:00.000)
                              2. Alles wird anders (00:01:02.189)
                              3. Scala 2.12.4 (00:02:03.000)
                              4. Reasonable Scala (00:03:46.307)
                              5. Scala vs. Kotlin in der Praxis (00:07:42.253)
                              6. So, what’s wrong with SBT? (00:50:45.752)
                              7. Resümee 2017 (01:04:40.771)
                              8. Wünsche für 2018 (01:13:00.787)
                              9. Outro (01:17:30.696)
                              10. Lizenz


                                Scala Profis von Benjamin Hagemeister & Sven Wiegand ist lizenziert unter einer Creative Commons Namensnennung — Keine Bearbeitungen 4.0 International Lizenz.

                                Über diese Lizenz hinausgehende Erlaubnisse kannst Du unter http://scalaprofis.de erhalten.

                                Titelsong basierend auf Wish You Were Here von THE.MADPIX.PROJECT lizensiert unter Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0).

                                1 hr 19 min
                              11. SP10/17: Wir leben noch

                                Scala 2.12.3 released

                                Interessanteste Änderung ist eine — laut eigenen Aussagen — drastisch verbesserte Performance:

                                • Insbesondere der inkrementelle Compiler Zinc (wird von SBT und diversen anderen Build-Tools verwendet) wurde verbessert um möglichst wenig Code neu zu compilieren.
                                • Aber auch am Compiler selbst wurden diverse kleine Performance-Optimierungen vorgenommen, die sich erheblich aufaddieren können. Bei verschiedenen Projekten sank die Dauer für einen Full-Build auf 66% bis 85% gegenüber 2.11.11. Besonders profitieren kleinere Projekte.
                                • Der Blog-Post Towards a faster Scala compiler beschreibt alle Details.
                                • Um sicherzustellen, dass sich die Performance nicht verschlechtert werden nach jeder Änderung am Compiler automatische Performance-Tests ausgeführt.
                                • Links
                                  • Scala 2.12.3 released
                                  • Towards a faster Scala compiler
                                  • SBT 1.0.0 is da

                                    Version 1.0.0 und inzwischen sogar 1.0.1 bzw. 1.0.2 ist verfügbar.

                                    Highlights:

                                    • basiert auf Scala 2.12, es ist also kein 2.10 Support mehr bei Scala Plugins notwendig
                                    • Zinc 1 mit verbesserter Performance bei der inkrementellen Compilierung
                                    • paralleler Download von Artefakten
                                    • Library Management API (erleichtert einen Wechsel von Ivy auf ein anderes System in der Zukunft)
                                    • ab SBT 1.0.0 wird Semantic Versioning verwendet
                                    • SBT 1.0.0 ist weder Source- noch Binär-Kompatibel mit 0.13., es gibt eine Anleitung für die Migration
                                    • Links
                                      • Ankündigung
                                      • Release-Notes
                                      • Migration von 0.13.x
                                      • Migration Status
                                      • Java 9 wurde released

                                        Nach mehrfacher Verschiebung wurde im September Java 9 released.

                                        Änderungen, die potential für uns als Scala-Entwickler interessant sind:

                                        • Modul-System (neues Tool jlink)
                                        • Neues Versions-Schema major.minor.security.patch. Wobei minor für bug fixes gilt und major für funktionale Updates.
                                        • Multi-Release JARs
                                        • G1 als Standard-Garbage-Collector. Kann angeblich besser mit großen Heaps (> 4GB) umgehen.
                                        • Update der Process API ermöglicht Zugriff auf die System-ID von Prozessen und diversen weiteren System-Eigenschaften. Ermöglicht die Überwachung und das Beenden von Prozessen.
                                        • Stackwalk-API zum Zugriff auf Informationen zum aktuellen Stack.
                                        • Unterstützung diverser ECMAScript 6 Features in Nashorn. z.B. let, const, Iteratoren und for ... of, Map, Set und einiges mehr.
                                        • HiDPI-Unterstützung für Windows und Linux
                                        • UTF‑8 Properties-Dateien
                                        • …
                                        • Links
                                          • Java 9 Release now available
                                          • Java Platform, Standard Edition What’s New in Oracle JDK 9 (vollständige Liste der Neuerungen)
                                          • Countdown to Java 9 Release Date (Diverse News rund um Java 9)
                                          • scalameta/scalamacros

                                            Der Fokus von Scalameta hat sich verändert. Das Projekt wurde ursprünglich gestartet um Macros zu vereinfachen. Inzwischen wurden die Macros in ein eigenes Projekt ausgelagert.

                                            Scalameta ist inzwischen allgemeiner angelegt, also Basis für Entwickler-Tools verschiedener Art, wie z.B.

                                            • Scalafmt
                                            • Scalafix
                                            • AST Explorer
                                            • Scalamacros

                                              Zu Scalamacros findet man auf Github Beispiele für Macro-Annotations und def Macros, allerdings bisher wenig Dokumentation.

                                              Roadmap

                                              Inzwischen beteiligt das Scala Center sich bei der Implementierung (siehe SCP-014) und es gibt eine Planung für die nächsten Schritte:

                                              • Scala 2.12: Weitere Schritte über Compiler-Plugin
                                              • Dotty: Integration in den Compiler
                                              • Support für IntelliJ IDEA
                                              • Scala 2.13: Immer noch über Compiler-Plugin und Feature-Flags
                                              • Scala 2.14: Macros sollen nicht mehr experimentell sein und scala.reflect wird deprecated
                                              • Links
                                                • Release Notes
                                                • Scalamacros
                                                • scalameta/paradise
                                                • SCP-014
                                                • Roadmap towards non-experimental Macros
                                                • Scala AST im Browser untersuchen
                                                  • AST explorer ist eine Web-Site mit der sich die Abstract Syntax Trees für beliebigen Code verschiedener Programmiersprachen analysieren lassen.
                                                  • Gabriele Petronella hat unter Einsatz von Scalameta und Scala.js Scala-Unterstützung für den AST explorer implementiert, so dass Scala jetzt in der Liste der unterstützten Sprachen auftaucht.
                                                  • Fazit

                                                    Wer mit Scala Macros experimentiert, dem kann der AST explorer die Arbeit deutlich vereinfachen.

                                                    Links
                                                    • Exploring Scala AST in your browser – buildo blog
                                                    • AST explorer
                                                    • Catch bugs with Scalafix v0.5 | The Scala Programming Language

                                                      Scalafix kann nicht nur Code verändern sondern auch als Linter verwendet werden. Ein Blog Beitrag von Ólafur Páll Geirsson zeigt wie einfach es ist eigene Regeln für den Linter zu schreiben — zumindest wenn man sich ein bisschen mit Quasiquotes und Scalameta auskennt.

                                                      Links
                                                      • Catch bugs with Scalafix v0.5 | The Scala Programming Language
                                                      • Scalafix Dokumentation
                                                      • Scala.js vs TypeScript

                                                        Sven hat Scala.js angepriesen. In letzter Zeit hat er sich mit TypeScript beschäftigt. Hier sein Vergleich:

                                                        Vorzüge von Scala.js
                                                        • Scala halt
                                                        • Kompakte Syntax (einzeilige case-Klassen)
                                                        • Typ-Klassen
                                                        • Declaration-Side Variance
                                                        • Implicits
                                                        • Shared Client-Server-Projekte (auf Scala-Basis)
                                                        • Neutral
                                                          • Mit Facebook’s immutable.js existiert eine gute Implementierung von immutable Collections.
                                                          • Out-of-the-box automatische Tests mit Coverage-Analyse
                                                          • Mächtiges Typ-System mit mächtiger Typ-Interference.
                                                          • Vorzüge von TypeScript
                                                            • Durchgängiges structural typing passt besser zum dynamischen Character von JavaScript. Außerdem ermöglicht es die schlanke Instanziierung von Interfaces mittels JavaScripts Object-Syntax.
                                                            • Typ-Konstrukte, die so bei Scala nicht möglich sind:
                                                              • Union Types (A | B, string | number) passen gut JavaScript.
                                                              • Intersection-Types (A & B) ermöglichen interessante Typisierungs-Lösungen, die mit Scala so nicht möglich sind.
                                                              • Mit [mapped types] lassen sich leicht neue Typen auf Basis existierender erstellen (Partial, Readonly)
                                                              • Zero Script-Size Overhead
                                                              • Zero Runtime-Overhead
                                                              • Unterstützung von TSX
                                                              • Mächtiger Standard-Linter
                                                              • Declaration-Files für die meisten, selbst wenig populäre JavaScript-Libraries
                                                              • Tooling (IDE-Support, Debugging, Integration mit webpack und Co)
                                                              • Turn-around-Zeiten
                                                              • Popularität
                                                              • Vorläufiges Fazit

                                                                Stand heute ist der Einsatz von Scala.js als JavaScript-Ersatz nur mit großen Kompromissen möglich:

                                                                • Fassaden für JavaScript-Bibliotheken müssen manuell erstellt werden
                                                                • Die generierten Bundles haben einen erheblichen Overhead
                                                                • Das Debugging in Chrome ist aufgrund unpräziser Source-Maps und starker Optimierungen (fehlende Variablen) kaum brauchbar
                                                                • Vor allem das Tooling kommt nicht annähernd and das von TypeScript heran. So müssen Templates häufig als Strings abgebildet werden wodurch viele Fehler erst zur Laufzeit auftreten.
                                                                • Play 2.6.0 released

                                                                  Ende Juni wurde Play 2.6.0 freigegeben. Über die Änderungen sprachen wir in Episode SP02/17 im Detail. Die wichtigsten Änderungen sind:

                                                                  • Unterstützung für Scala 2.12
                                                                  • Akka HTTP ersetzt Netty
                                                                  • Experimenteller Support für HTTP/2
                                                                  • Links
                                                                    • Play 2.6.0 released
                                                                    • Scastie hat das Beta-Stadium verlassen

                                                                      Scastie ist eine vom Scala Center Team betriebene interaktive Web-Seite, die es Dir ermöglicht Scala-Code im Browser auszuprobieren, auf den Servern zu speichern und zu teilen (ähnlich wie bei JSFiddle & Co.).

                                                                      Gegenüber der Beta-Version wurde folgendes geändert:

                                                                      • Die Oberfläche wurde komplett aufgeräumt.
                                                                      • Neben den Standard-Scala-Versionen, dem Dotty und dem Typelevel-Compiler steht nun auch Scala.js als Target bereit.
                                                                      • Weiterhin vorhandene Features:

                                                                        • Über eine interaktive Suche kannst Du sämtliche im scaladex geführte Bibliotheken mit einem Klick hinzufügen und ausprobieren.
                                                                        • Wenn das immer noch nicht reicht kannst Du direkt das SBT-Script beeinflussen und so zum Beispiel beliebige Dependencies hinzufügen
                                                                        • Links
                                                                          • Scastie
                                                                          • Scastie is out of beta and available to everybody! | The Scala Programming Language
                                                                          • Underscore Books

                                                                            Frei verfügbare eBooks rund um Scala.

                                                                            Derzeit verfügbar:

                                                                            • Essential Scala
                                                                            • Essential Play
                                                                            • Advanced Scala with Cats
                                                                            • Essential Slick
                                                                            • Creative Scala
                                                                            • The Type Astronout’s Guide to Shapeless
                                                                            • The Lift Cookbook
                                                                            • Links
                                                                              • Underscore Books
                                                                              • 47deg/sbt-microsites

                                                                                Von der Projektseite:

                                                                                sbt-microsites is an SBT plugin that facilitates the creation of fancy microsites for your projects, with minimal tweaks.

                                                                                What is a microsite?

                                                                                A microsite is an instance of Jekyll, ready to publish a static web page for your new library. Some of the benefits of having these auto-generated web pages are:

                                                                                • You can write documentation easily in markdown format.
                                                                                • Templates, layouts, styles, and other resources will be able through the plugin at compile time.
                                                                                • You don’t have to deal with the styling.
                                                                                • Links
                                                                                  • 47deg/sbt-microsites
                                                                                  • Gib uns Dein Feedback als Kommentar auf unserer Web-Site, via Twitter oder Google+.

                                                                                    Kapitel
                                                                                    1. Intro (00:00:00.000)
                                                                                    2. Scala 2.12.3 (00:01:49.037)
                                                                                    3. SBT 1.0.0 (00:04:19.678)
                                                                                    4. Java 9 (00:09:47.661)
                                                                                    5. scalameta/scalamacros (00:28:24.547)
                                                                                    6. AST explorer (00:39:39.765)
                                                                                    7. ScalaFix als Linter (00:44:08.035)
                                                                                    8. Scala.js vs. TypeScript (00:47:45.592)
                                                                                    9. Play 2.6 released (01:16:03.907)
                                                                                    10. Scastie hat das Beta-Stadium verlassen (01:19:02.552)
                                                                                    11. Underscore Books (01:21:21.037)
                                                                                    12. sbt-microsites (01:22:25.880)
                                                                                    13. Outro (01:23:46.787)
                                                                                    14. Lizenz


                                                                                      Scala Profis von Benjamin Hagemeister & Sven Wiegand ist lizenziert unter einer Creative Commons Namensnennung — Keine Bearbeitungen 4.0 International Lizenz.

                                                                                      Über diese Lizenz hinausgehende Erlaubnisse kannst Du unter http://scalaprofis.de erhalten.

                                                                                      Titelsong basierend auf Wish You Were Here von THE.MADPIX.PROJECT lizensiert unter Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0).

                                                                                      1 hr 25 min
                                                                                    15. SP05/17: scala.meta und mehr

                                                                                      Drei neue Scala-Releases

                                                                                      Am 18. April wurden gleich [drei Releases angekündigt]((http://www.scala-lang.org/news/releases-1Q17.html).

                                                                                      • Scala 2.11.11: Letztes Release der 2.11er Reihe. Bugfixes. (Hinweis: 2.11.9 und 2.11.10 hat es nicht gegeben)
                                                                                      • Scala 2.12.2: Bringt neben diversen Fixes mit »Trailing Commas« (SIP-27) den ersten Proposal gemäß des überarbeiteten Scala Improvement Process‹.
                                                                                      • Scala 2.13.0‑M1: Basis für Modularisierung und Collection-Überarbeitung.
                                                                                      • Links
                                                                                        • Three new releases and more GitHub goodness!
                                                                                        • 4. Meeting des Scala Centers (Q1 2017)
                                                                                          Scala Center Aktivitäten
                                                                                          • Scastie:
                                                                                            • Wird als nützlich für Einsteiger und für die Community zum Teilen von Code-Schnippseln eingestuft.
                                                                                            • Bleibt in der Beta-Phase, bis Scala Center ausreichende Server-Ressourcen sichergestellt hat.
                                                                                            • 47 Degrees hat sich bereiterklärt bei der Bereitstellung eines brauchbaren UIs zu unterstützen.
                                                                                            • Zinc: Von den aktuellen Arbeiten werden sbt 1.0 und andere Build-Tools profitieren.
                                                                                            • Scalafix: Es besteht die Hoffnung, dass mehr und mehr Libraries Scalafix zur Migration auf neue Versionen einsetzen.
                                                                                            • Websites:
                                                                                              • 47 Degrees hat mehrere umfangreiche Pull-Requests zur Scala-Website gestellt, die hoffentlich bald gemergt werden.
                                                                                              • Ein externer Contractor arbeitet an den »Getting Started«- und »Language Tour«-Seiten.
                                                                                              • Scala.js:
                                                                                                • Scala.js ist stark am wachsen
                                                                                                • scalajs-bundler gewinnt ebenfalls an Interesse
                                                                                                • Scala Native: Läuft auf kleiner Flamme, bis Neueinstellung bereitsteht.
                                                                                                • Scaladex: Eine UI-Überarbeitung ist geplant, da das UI inzwischen etwas unaufgeräumt wirkt.
                                                                                                • Sonstiges
                                                                                                  • Community Builds: Arbeitet an einem Proposal zur Durchführung regelmäßiger Builds SBT-basierter Open-Source-Projekte um die Rückwärtskompatibilität von Neuentwicklungen im Scala-Compiler sicherzustellen.
                                                                                                  • Links
                                                                                                    • Minutes of the 4th meeting of the Scala Center, Q1 2017
                                                                                                    • JNI mit ScalaNative
                                                                                                      Links
                                                                                                      • JNA
                                                                                                      • JNI vs. JNA
                                                                                                      • Capturing Packets with Scala Native and libpcap
                                                                                                      • Was ist scala.meta?

                                                                                                        scala.meta ist ein Meta-Programming Toolkit für Scala. scala.meta wurde komplett neu implementiert und soll scala.reflect ersetzen.

                                                                                                        Aktuell ist die Version 1.7 vom 11. April 2017. Geplant ist eigentlich ein Major Release (1.8, 1.9) am 10. von jedem Monat, eigentlich müsste es also schon die Version 1.8 geben.

                                                                                                        scala.meta wird z.B. von scalafmt und von scalafix verwendet.

                                                                                                        Features
                                                                                                        • Parsing inkl. Format und Kommentaren
                                                                                                        • Unterstützt verschiedene Dialekte (Scala 2.11, 2.12 und Dotty)
                                                                                                        • Quasiquotes
                                                                                                        • Macro-Annotations
                                                                                                        • Verfügbar für
                                                                                                          • Scala 2.11
                                                                                                          • Scala 2.12
                                                                                                          • Scala.js
                                                                                                          • Was bringt die Zukunft?
                                                                                                            • Semantische API
                                                                                                            • Inline Macros
                                                                                                            • Support für
                                                                                                              • Scala 2.10
                                                                                                              • Scala Native
                                                                                                              • Dokumentation

                                                                                                                Wie üblich gibt es leider bisher relativ wenig Dokumentation. Am hilfreichsten ist momentan ein Tutorial von Ólafur Pall Geirsson (A Whirlwind Tour of scala.meta).

                                                                                                                Für Fragen kann man den scala.meta Gitter channel oder natürlich stackoverflow verwenden.

                                                                                                                Beispiele findet man im Projekt Elysium auf GitHub.

                                                                                                                Was ist besser?

                                                                                                                scala.meta ist in der Verwendung deutlich einfacher als scala.reflect.

                                                                                                                Für eine Macro-Annotation muss man eine Klasse von scala.annotation.StaticAnnotation und eine apply Methode implementieren, die dann für das Element (Objekt, Klasse, Methode, …) aufgerufen wird, an das die Annotation geschrieben wird:

                                                                                                                class MyAnnotation extends scala.annotation.StaticAnnotation {
                                                                                                                inline def apply(defn: Any): Any = meta {
                                                                                                                defn match {
                                                                                                                case obj: Defn.Object => ...
                                                                                                                case cls: Defn.Class => ...
                                                                                                                case _ => abort("@MyAnnotation is only allowed for classes and objects.")
                                                                                                                }
                                                                                                                }
                                                                                                                }

                                                                                                                Über das abort(...) Statement erzeugt man einen compile Fehler.

                                                                                                                Die AST-Objekte die man bekommt sind deutlich verständlicher, als bei scala.reflect.

                                                                                                                Hier ein Beispiel aus Li Haoyis Sourcecode Bibliothek(Aus der Datei SourceContext.scala:

                                                                                                                object Util{
                                                                                                                ...
                                                                                                                def getName(c: Compat.Context)(s: c.Symbol) = s.name.decoded.toString.trim
                                                                                                                }

                                                                                                                Die Funktion getName gibt den Namen von einem übergebenen Symbol zurück.

                                                                                                                Analog hier der Code um in der Annotation von oben zum Beispiel an den Namen einer Klasse zu kommen:

                                                                                                                class MyAnnotation extends scala.annotation.StaticAnnotation {
                                                                                                                inline def apply(defn: Any): Any = meta {
                                                                                                                defn match {
                                                                                                                case obj: Defn.Object => ...
                                                                                                                case cls: Defn.Class =>
                                                                                                                val className = cls.name.value
                                                                                                                ...
                                                                                                                case _ => abort("@MyAnnotation is only allowed for classes and objects.")
                                                                                                                }
                                                                                                                }
                                                                                                                }

                                                                                                                Die übergebenen AST-Objekte sind case Klassen. Wenn man etwas verändern will kann man per copy(...) ein neues, angepasstes Objekt erzeugen und das dann zurück geben.

                                                                                                                scala.meta und IntelliJ IDEA
                                                                                                                Verwenden von Macro-Annotations

                                                                                                                Macro-Annotation können in IDEA relativ problemlos verwendet werden. IDEA erkennt wenn ein Annotation an einer Stelle einen Compile-Fehler auslöst und zeigt den Code dann auch als Fehlerhaft an.

                                                                                                                Neben der Annotation wird ein Symbol angezeigt über die das Macro ›ausgeführt‹ werden kann. IDEA ersetzt dann den vorhanden Code durch den, den das Macro generiert.

                                                                                                                Das alles funktioniert allerdings nicht sonderlich gut für Macros die im gleichen IDEA Projekt entwickelt werden. Änderungen am Macro die neue Compile-Fehler erzeugen oder aktuelle Compile-Fehler beheben erkennt IDEA in der Regel nicht, womit dann unter Umständen korrekter Code als fehlerhaft angezeigt wird oder umgekehrt.

                                                                                                                Debugging

                                                                                                                Am einfachsten lässt sich ein Macro debuggen über Remote-Debugging.

                                                                                                                Das hat bei Benjamin aber nicht immer zuverlässig funktioniert. Von Zeit zu Zeit wurde die Remote-Debugging-Session beendet und manchmal hat IDEA nicht an einem Break-Point angehalten.

                                                                                                                Links
                                                                                                                • scala.meta
                                                                                                                • Changelog
                                                                                                                • Quasiquotes
                                                                                                                • Semantic Tooling at Twitter
                                                                                                                • Macro Paradise
                                                                                                                • scalafmt
                                                                                                                • scalafix
                                                                                                                • Meta-based def macros are coming
                                                                                                                • A Whirlwind Tour of scala.meta
                                                                                                                • scala.meta Gitter channel
                                                                                                                • stackoverflow
                                                                                                                • Elysium
                                                                                                                • Debug Scala compiler plugin in IntelliJ IDEA
                                                                                                                • Akka Typed

                                                                                                                  Wer einen Eindruck von »Akka Typed« erhalten will kann sich die Blog-Reihe auf dem Akka-Blog anschauen, die bisher aus drei Artikeln besteht:

                                                                                                                  • Akka Typed: Hello World in the new API
                                                                                                                  • Akka Typed: Coexistence
                                                                                                                  • Akka Typed: Mutable vs. Immutable
                                                                                                                  • Alpakka

                                                                                                                    Alpakka ist ein von Lightbend initiiertes Sammelsurium von Akka-Stream-Connectoren, Integrations-Patterns und Daten-Transformationen für Integrations Use-Cases.

                                                                                                                    Ziel von Lightbend ist es mit Alpakka eine moderne Alternative zu Apache Camel zu schaffen.

                                                                                                                    Hier eine Liste der aktuell verfügbaren Komponenten.

                                                                                                                    Connectoren
                                                                                                                    • AMQP Connector
                                                                                                                    • AWS DynamoDB Connector
                                                                                                                    • AWS Lambda Connector
                                                                                                                    • AWS S3 Connector
                                                                                                                    • AWS SNS Connector
                                                                                                                    • AWS SQS Connector
                                                                                                                    • Cassandra Connector
                                                                                                                    • File Connectors
                                                                                                                    • FTP Connector
                                                                                                                    • Google Cloud Pub/Sub
                                                                                                                    • HBbase connector
                                                                                                                    • IronMq Connector
                                                                                                                    • JMS Connector
                                                                                                                    • MQTT Connector
                                                                                                                    • Server-sent Events (SSE) Connector
                                                                                                                    • Externe Connectoren
                                                                                                                      • HTTP Client
                                                                                                                      • File IO
                                                                                                                      • Kafka
                                                                                                                      • TCP
                                                                                                                      • Azure
                                                                                                                      • Eventuate
                                                                                                                      • FS2
                                                                                                                      • Camel
                                                                                                                      • MongoDB
                                                                                                                      • Daten-Transformationen
                                                                                                                        • Parsing Lines
                                                                                                                        • Comma-Separated Values — CSV
                                                                                                                        • RecordIO Framing
                                                                                                                        • Links
                                                                                                                          • Alpakka
                                                                                                                          • Ankündigung von Alpakka (23.08.2016)
                                                                                                                          • scalajs-bundler

                                                                                                                            scalajs-bundler ermöglicht es NPM-Dependencies in scala.js via SBT anzubinden.

                                                                                                                            Bisherige Lösungen
                                                                                                                            • JS-Files ins Projekt kopieren und via ProvidedJS einbinden
                                                                                                                            • WebJars
                                                                                                                            • scalajs-bundler nutzen

                                                                                                                              Nachdem hinzufügen des SBT Plugins (und der lokalen Installation von NPM) können NPM-Dependencies einfach eingebunden werden:

                                                                                                                              npmDependencies in Compile += "snabbdom" -> "0.5.3"

                                                                                                                              Für sbt-web steht ebenfalls eine Variante des scalajs-bundlers bereit.

                                                                                                                              Links
                                                                                                                              • scalajs-bundler
                                                                                                                              • Kotlin/Native

                                                                                                                                JetBrains hat eine Tech Preview für Kotlin/Native heraus gebracht. Genau wie Scala Native setzt Kotlin/Native auf LLVM um Kotlin-Code in nativ ausführbare Executables für verschiedene Plattformen zu übersetzen.

                                                                                                                                Links
                                                                                                                                • Kotlin/Native Tech Preview: Kotlin without a VM
                                                                                                                                • Android Announces Support for Kotlin

                                                                                                                                  Auf der diesjährigen Google I/O hat Google Kotlin als offiziell unterstützte Programmiersprache für Android beworben.

                                                                                                                                  Links
                                                                                                                                  • Android Announces Support for Kotlin
                                                                                                                                  • Gib uns Dein Feedback als Kommentar auf unserer Web-Site, via Twitter oder Google+.

                                                                                                                                    Kapitel
                                                                                                                                    1. Intro (00:00:00.000)
                                                                                                                                    2. Drei neue Scala-Releases (00:01:48.888)
                                                                                                                                    3. 4. Meeting des Scala Centers (00:06:22.317)
                                                                                                                                    4. JNI mit ScalaNative (00:17:59.832)
                                                                                                                                    5. Scala.meta (00:22:35.128)
                                                                                                                                    6. Akka Typed (00:55:24.621)
                                                                                                                                    7. Alpakka (00:59:54.456)
                                                                                                                                    8. scalajs-bundler (01:04:17.336)
                                                                                                                                    9. Kotlin/Native (01:10:14.808)
                                                                                                                                    10. Anrdoid Announces Support for Kotlin (01:11:46.168)
                                                                                                                                    11. Outro (01:19:36.600)
                                                                                                                                    12. Lizenz


                                                                                                                                      Scala Profis von Benjamin Hagemeister & Sven Wiegand ist lizenziert unter einer Creative Commons Namensnennung — Keine Bearbeitungen 4.0 International Lizenz.

                                                                                                                                      Über diese Lizenz hinausgehende Erlaubnisse kannst Du unter http://scalaprofis.de erhalten.

                                                                                                                                      Titelsong basierend auf Wish You Were Here von THE.MADPIX.PROJECT lizensiert unter Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0).

                                                                                                                                      1 hr 21 min
                                                                                                                                    13. SP03/17: Scala 2.13

                                                                                                                                      Wir suchen einen Scala-Entwickler

                                                                                                                                      Willst Du Scala endlich auch beruflich einsetzen? Dann komm zu uns. Für unser Berliner Team bei der Beta System IAM Software AG suchen wir einen Scala-Entwickler bzw. eine Scala-Entwicklerin. In einem sechsköpfigen Scrum-Team entwickelst Du unsere neue Web-Basierte IAM-Suite, vollständig in Scala.

                                                                                                                                      Auch als Quereinsteiger aus der Java-Welt bist Du herzlich willkommen.

                                                                                                                                      Bewirb Dich jetzt (gib bei der Bewerbung mit an, dass Du über die Scala Profis auf die Stelle aufmerksam geworden bist).

                                                                                                                                      Feedback zur letzten Episode
                                                                                                                                      1. Boris hat ganz richtig angemerkt, dass HTTP 1 natürlich auch schon binäre Inhalte übertragen kann ohne diese Base64-encoden zu müssen.
                                                                                                                                      2. Benjamin hat uns informiert, dass Java-Enums entgegen unserer Aussage eine natürliche Ordnung haben.
                                                                                                                                      3. Nachtrag zu SP02/17 und Contextual

                                                                                                                                        In Episode SP02/17 hatte Benjamin bemängelt, dass der Contextual String-Interpolator ein Any anstelle des gewünschten Typs zurückgibt und großspurig angekündigt dafür einen Pull-Request zu stellen.

                                                                                                                                        Igor Mielientev war da schneller. Sein Pull-Request ist auch schon gemergt, allerdings gibt es noch kein neues Release in dem die Änderung enthalten ist.

                                                                                                                                        Introducing the Scala Platform Process

                                                                                                                                        Der Scala Platform Process soll die Implementierung, Pflege und Verwaltung von Modulen für die Scala Platform vereinfachen.

                                                                                                                                        Zur Erinnerung: Scala soll weiter modularisiert werden. Die Standard Library soll nur die wichtigsten Komponenten enthalten, wie zum Beispiel die Collections. Alles was soll in extra Bibliotheken ausgelagert werden, wie das bei 2.11 zum Beispiel schon mit der XML Bibliothek passiert ist.

                                                                                                                                        Der Scala Platform Process bietet:

                                                                                                                                        • Infrastruktur
                                                                                                                                          • SBT Plugin
                                                                                                                                          • CI
                                                                                                                                          • Release Manager
                                                                                                                                          • Richtlinien
                                                                                                                                            • für den Release-Prozess
                                                                                                                                            • für ›Mitarbeiter‹
                                                                                                                                            • Links
                                                                                                                                              • Introducint the Scala platform process
                                                                                                                                              • Scala Platform
                                                                                                                                              • Platform Policies
                                                                                                                                              • SBT Plugin
                                                                                                                                              • CI-Integration
                                                                                                                                              • Scala 2.13 Roadmap

                                                                                                                                                Lightbend hat seine Pläne für die Scala-Roadmap 2017 inklusive eines Ausblicks auf Scala 2.13 veröffentlicht.

                                                                                                                                                Scala 2.13

                                                                                                                                                Scala 2.13 wird sich auf folgende Themen fokussieren:

                                                                                                                                                • Compiler-Performance
                                                                                                                                                • Vereinfachung der Collections: siehe unten
                                                                                                                                                • Modularisierung der Standard-Library:
                                                                                                                                                  • Reduzierung auf die Collection-Typen und andere Standard-Typen wie Option, TupleN, Either und Try
                                                                                                                                                  • Andere Features werden in unabhängige Libraries ausgelagert, die eingebunden werden müssen und einen eigenständigen Release-Zyklus haben werden
                                                                                                                                                  • Benutzerfreundlichkeit. Derzeit umfasst das folgende Punkte:
                                                                                                                                                    • Konfigurierbares Error-Reporting: Z.B. Warnungen ignorieren oder zu Fehlern anheben
                                                                                                                                                    • Scalafix für automatische Migration
                                                                                                                                                    • Vereinheitlichung des SBT- und Scala-Launchers: Automatische Updates der Kommandozeilen-Tools und einheitliche Ein-/Ausgaben
                                                                                                                                                    • Verbesserte REPL: Z.B. Syntax Highlighting, Möglichkeiten zur Einbettung in Worksheets, Verbessertes Editieren für mehrzeilige Eingaben, etc.
                                                                                                                                                    • An der Sprache wird sich in 2.13 also nichts ändern.

                                                                                                                                                      Zeitplan
                                                                                                                                                      • Im Vergleich zu 2.12 soll der Release-Zyklus verkürzt werden.
                                                                                                                                                      • Vierteljährliche Milestones für 2.13 in 2017
                                                                                                                                                      • Erster Release-Candidate Ende Q1 2018
                                                                                                                                                      • 2.12 erhält in 2017 regelmäßige Minor-Releases
                                                                                                                                                      • 2.11 erhält in Q1 2017 mit 2.11.9 sein letztes Release
                                                                                                                                                      • Link
                                                                                                                                                        • Scala 2.13 roadmap
                                                                                                                                                        • Scala 2.13 Collections Rework

                                                                                                                                                          Die Scala Collections sind zwar gut, sind aber durchaus auch ein bisschen überladen und zum Teil schwer zu verwenden und schwer zu implementieren.

                                                                                                                                                          Sie sollen deshalb für 2.13 mit den folgenden Zielen neu implementiert werden:

                                                                                                                                                          • Einfacher zu verwenden (viele Operationen ohne CanBuildFrom, vereinfachte Hierarchie)
                                                                                                                                                          • Einfacher zu implementieren
                                                                                                                                                          • Schneller
                                                                                                                                                          • Soweit möglich kompatibel zu 2.12. Inkompatibilitäten sollten sich mit ScalaFix automatisch beheben lassen.
                                                                                                                                                          • Links
                                                                                                                                                            • Scala 2.13 Collections Rework
                                                                                                                                                            • ScalaFix
                                                                                                                                                            • Scala auf Platz 11 im RedMonk-Ranking

                                                                                                                                                              Im (verspäteten) Januar-Ergebnis des halbjährlich erscheinenden RadMonk-Programmiersprachen-Rankings konnte Scala gegenüber dem letzten Ergebnis drei Plätze gut machen und liegt jetzt, gleich auf mit Swift, auf Platz 11.

                                                                                                                                                              Die RedMonk-Analysten werten StackOverflow und GitHub aus, um einzuschätzen, wie stark welche Programmiersprachen in der Zukunft eingesetzt werden.

                                                                                                                                                              Hier die ersten zehn Plätze:

                                                                                                                                                              1. JavaScript
                                                                                                                                                              2. Java
                                                                                                                                                              3. Python
                                                                                                                                                              4. PHP
                                                                                                                                                              5. C#
                                                                                                                                                              6. C++
                                                                                                                                                              7. CSS
                                                                                                                                                              8. Ruby
                                                                                                                                                              9. C
                                                                                                                                                              10. Objective‑C
                                                                                                                                                              11. Link
                                                                                                                                                                • The RedMonk Programming Language Rankings: January 2017
                                                                                                                                                                • Scala.js 0.6.15
                                                                                                                                                                  • Vorbereitung auf Scala.js 1.0.0
                                                                                                                                                                  • Neue Annotation @JSExportStatic um statische Members auf Scala.js-defined Classes zu definieren
                                                                                                                                                                  • @JSExportTopLevel kann jetzt auch auf Feldern und Top-Level Klassen/Objekten genutzt werden.
                                                                                                                                                                  • Unterstützung für ECMAScript 2015 symbols und Iterables/Iterators.
                                                                                                                                                                  • Bestehender Code erfordert einiges an Migrationsaufwand, der mittels scalafix teilweise automatisch durchgeführt werden kann.

                                                                                                                                                                    Links
                                                                                                                                                                    • Announcing Scala.js 0.6.15
                                                                                                                                                                    • Scala Native v0.1 is here!

                                                                                                                                                                      Scala Native v0.1 ist verfügbar.

                                                                                                                                                                      Features
                                                                                                                                                                      • Vollständiger Scala Support mit ein paar unerheblichen sematischen Unterschieden
                                                                                                                                                                      • Einfache Interoperabilität mit Nativem Code
                                                                                                                                                                      • Support für existierende Scala IDEs
                                                                                                                                                                      • Integration mit SBT
                                                                                                                                                                      • Cross-publishing für JVM, JS und Native
                                                                                                                                                                      • Support für einen Teil der JDK core library
                                                                                                                                                                      • Support für einen Teil der C Standard Library
                                                                                                                                                                      • Links
                                                                                                                                                                        • Scala Native v0.1 is here
                                                                                                                                                                        • Scala Native Homepage
                                                                                                                                                                        • Scala Native Issues
                                                                                                                                                                        • Android: Java 8 (und Scala)

                                                                                                                                                                          Google hat sich entschieden die Jack-Toolchain (höre Episode SP004) zu verwerfen und Java 8 Features stattdessen direkt via javac und dx zu unterstützen. Laut eigener Aussage wollen sie damit erreichen, dass bestehende Tools, die auf dem Java-Bytecode-Format aufsetzen, auch im Android-Umfeld funktionieren.

                                                                                                                                                                          Im März 2016 hatte Google angekündigt Java 8 Features über den neuen Jack-Compiler zu unterstützen, der keine .class-Dateien mehr, sondern .jack-Dateien generiert, die direkt DEX-Code enthalten sollten.

                                                                                                                                                                          Mit der neuen Marschrichtung könnte Scala 2.12 für Android wieder realistisch werden.

                                                                                                                                                                          Link
                                                                                                                                                                          • Future of Java 8 Language Feature Support on Android
                                                                                                                                                                          • Java: Project Amber

                                                                                                                                                                            Biran Goetz, Java Language Architect by Oracle, hat Project Amber angekündigt. Ziel ist es kleinere, produktive Sprach-Features zu evaluieren.

                                                                                                                                                                            • Typ-Inferenz für lokale Variablen (var url = new URL(...))
                                                                                                                                                                            • Generische Enums
                                                                                                                                                                            • Lambda Leftovers: Ignorieren von Lambda-Parametern via Unterstrich
                                                                                                                                                                            • Data Classes:
                                                                                                                                                                            • public class User(String firstName, String lastName, DateTime birthday) { }

                                                                                                                                                                            • Pattern Matching

                                                                                                                                                                              String formatted = switch (constant) {
                                                                                                                                                                              case Integer i -> String.format("int %d", i);
                                                                                                                                                                              case Byte b: //...
                                                                                                                                                                              case Long l: // ...
                                                                                                                                                                              // ...
                                                                                                                                                                              default: formatted = "unknown"
                                                                                                                                                                              }

                                                                                                                                                                              Verfügbarkeit: Vielleicht 2020?

                                                                                                                                                                              Links
                                                                                                                                                                              • Project Amber
                                                                                                                                                                              • How Project Amber Will Revolutionize Java
                                                                                                                                                                              • Kotlin 1.1
                                                                                                                                                                                1. JavaScript: Zur Verfügung stehen alle Sprach- und Library-Konstrukte, nicht aber das JDK.
                                                                                                                                                                                2. Coroutines:
                                                                                                                                                                                  • Library-Feature
                                                                                                                                                                                  • Leichtgewichtige, unterbrechbare/fortsetzbare Threads
                                                                                                                                                                                  • Aufrufer kann asynchron auf das Ergebnis warten
                                                                                                                                                                                  • Mit yield kann ein Ergebnis eines Streams zurückgegeben werden
                                                                                                                                                                                  • Experimentell
                                                                                                                                                                                  • Sprach-Features
                                                                                                                                                                                    • Type aliases
                                                                                                                                                                                    • Destructuring für Lambda-Argumente
                                                                                                                                                                                    • Underscores für ungenutzte Lambda-Parameter
                                                                                                                                                                                    • Delegated Property Syntax für lokale Variablen: lazy
                                                                                                                                                                                    • Kann jetzt Java 8 Bytecode generieren
                                                                                                                                                                                    • Link
                                                                                                                                                                                      • What’s new in Kotlin 1.1
                                                                                                                                                                                      • Gib uns Dein Feedback als Kommentar auf unserer Web-Site, via Twitter oder Google+.

                                                                                                                                                                                        Kapitel
                                                                                                                                                                                        1. Intro (00:00:00.000)
                                                                                                                                                                                        2. Wir suchen einen Scala-Entwickler (00:01:10.787)
                                                                                                                                                                                        3. Feedback zur letzten Episode (00:01:41.731)
                                                                                                                                                                                        4. Nachtrag zu Contextual (00:03:52.877)
                                                                                                                                                                                        5. Introducing the Scala Platform Process (00:05:02.296)
                                                                                                                                                                                        6. Scala 2.13 Roadmap (00:09:00.131)
                                                                                                                                                                                        7. Scala auf Platz 11 im RedMonk Ranking (00:22:26.595)
                                                                                                                                                                                        8. Scala.js 0.6.15 (00:26:33.059)
                                                                                                                                                                                        9. Scala Native 0.1 (00:31:17.848)
                                                                                                                                                                                        10. Android: Java 8 (und Scala) (00:38:06.232)
                                                                                                                                                                                        11. Java: Project Amber (00:41:37.187)
                                                                                                                                                                                        12. Kotlin 1.1 (00:49:47.747)
                                                                                                                                                                                        13. Outro (00:55:41.261)
                                                                                                                                                                                        14. Lizenz


                                                                                                                                                                                          Scala Profis von Benjamin Hagemeister & Sven Wiegand ist lizenziert unter einer Creative Commons Namensnennung — Keine Bearbeitungen 4.0 International Lizenz.

                                                                                                                                                                                          Über diese Lizenz hinausgehende Erlaubnisse kannst Du unter http://scalaprofis.de erhalten.

                                                                                                                                                                                          Titelsong basierend auf Wish You Were Here von THE.MADPIX.PROJECT lizensiert unter Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0).

                                                                                                                                                                                          57 min
                                                                                                                                                                                        15. SP02/17: Dies und Das

                                                                                                                                                                                          Feedback zur letzten Episode

                                                                                                                                                                                          Paul hat geschrieben.

                                                                                                                                                                                          Seine Highlights 2016:

                                                                                                                                                                                          • Unser Podcast (vielen Dank!)
                                                                                                                                                                                          • Hat endlich Zeit und Muße gefunden Scala-Anwendungen im funktionalen Stil zu schreiben.
                                                                                                                                                                                          • Seine Wünsche für 2017:

                                                                                                                                                                                            • Schneller Scala Compiler. Wird nie kommen. Aber man darf doch träumen.
                                                                                                                                                                                            • Ich verstehe endlich was Monoiden und Kleislis sind und finde heraus ob Monoiden wirklich als Monaden zur Kategorie der Endofunktoren gehören… danach haue ich in den Sack und lerne Clojure. So wie ich es eigentlich vor hatte. ?
                                                                                                                                                                                            • Java9 kommt. Pünktlich. Mit Graal und Truffle. Ruby, Scala und Java laufen somit konfliktfrei auf der JVM. Überall glückliche, produktive Menschen.
                                                                                                                                                                                            • Weltfrieden
                                                                                                                                                                                            • Scala Center Advisory Board and SIP-Meeting-Results Dezember 2016
                                                                                                                                                                                              Scala Center Advisory Board
                                                                                                                                                                                              Neue Mitglieder

                                                                                                                                                                                              Das Scala Center Advisory Board hat zwei neue Mitglieder:

                                                                                                                                                                                              • James Belsey von Morgan Stanley
                                                                                                                                                                                              • Lars Hupel von Typelevel als zusätzlicher Vertreter der Community
                                                                                                                                                                                              • Meeting vom 13. Dezember 2016

                                                                                                                                                                                                Folgende Empfehlungen wurden beschlossen:

                                                                                                                                                                                                1. Redesign und Neu-Implementierung der Scala Collections für Scala 2.13 auf Basis der Implementierung für Dotty
                                                                                                                                                                                                2. Fortsetzung der Verwaltung der Webseiten scala-lang.org, docs.scala-lang.org und scala.epfl.ch
                                                                                                                                                                                                3. SCP-009
                                                                                                                                                                                                4. SIP-Meeting vom 25. Oktober 2016

                                                                                                                                                                                                  SIP-27 (trailing commans) wurde nach ein paar letzten Änderungen akzeptiert.

                                                                                                                                                                                                  Für SIP-20 (improved lazy val initialization) gibt es eine Implementierung für Dotty und es wird jemand gesucht, der sich um eine Implementierung für scalac kümmert.

                                                                                                                                                                                                  Links
                                                                                                                                                                                                  • Scala Center Advisory Board and SIP-Meeting Results
                                                                                                                                                                                                  • SCP-007: Collaborative redesign and implementation of Scala 2.13’s collections library
                                                                                                                                                                                                  • SCP-008: Maintain scala-lang, docs.scala-lang, scala.epfl.ch websites
                                                                                                                                                                                                  • SCP-009: Improve user experience for builds that use only direct dependencies
                                                                                                                                                                                                  • SIP-27 — Trailing Commas
                                                                                                                                                                                                  • SIP-20 — Improved Lazy Vals Initialization
                                                                                                                                                                                                  • Scastie

                                                                                                                                                                                                    Scastie ist eine vom Scala Center Team betriebene interaktive Web-Seite, die es Dir ermöglicht Scala-Code im Browser auszuprobieren, auf den Servern zu speichern und zu teilen (ähnlich wie bei JSFiddle & Co. — wenn auch noch nicht so komfortabel).

                                                                                                                                                                                                    Ursprünglich wurde Scastie von Aleh Aleshka als kollaborative Plattform zum Reproduzieren von Fehlern im Scala-Compiler erstellt. Seit neuestem steht das Ergebnis jedem interessierten als Beta-Version zur Verfügung (Login via Github).

                                                                                                                                                                                                    Dein Code wird zu den Scala-Center-Servern geschickt, dort mittels SBT compiliert und ausgeführt und der Output zurück zum Server gestreamt.

                                                                                                                                                                                                    Cool dabei:

                                                                                                                                                                                                    • Mit einem Click kannst Du das Scala-Target wählen. Zur Auswahl stehen nicht nur die verschiedenen Scala-Versionsn (2.10, 2.11 und 2.12) inklusive aller releasten Sub-Funktionen, sondern auch Dotty und der Typelevel-Scala-Compiler.
                                                                                                                                                                                                    • Über eine interaktive Suche kannst Du sämtliche im scaladex geführte Bibliotheken mit einem Klick hinzufügen und ausprobieren.
                                                                                                                                                                                                    • Wenn das immer noch nicht reicht kannst Du direkt das SBT-Script beeinflussen und so zum Beispiel beliebige Dependencies hinzufügen
                                                                                                                                                                                                    • Links
                                                                                                                                                                                                      • Scastie
                                                                                                                                                                                                      • Introducing Scastie — an interactive Playground for Scala
                                                                                                                                                                                                      • Scala Days 2017

                                                                                                                                                                                                        Die Agenda für die Scala Days 2017 in Kopenhagen ist online.

                                                                                                                                                                                                        Es gibt gleich zwei Vorträge aus der Berliner Scala Community:

                                                                                                                                                                                                        Daniel Jentsch hält einen Vortrag über eine ScalaTest Erweiterung zum testen von Abfrageketten mit Futures und externen Systemen.

                                                                                                                                                                                                        Oleg Ilyenko stellt seine GraphQL Implementierung Sangria vor.

                                                                                                                                                                                                        Links
                                                                                                                                                                                                        • Scala Days 2017
                                                                                                                                                                                                        • GraphQL — a type system for your API
                                                                                                                                                                                                        • Sangria
                                                                                                                                                                                                        • When all abstraction is lost
                                                                                                                                                                                                        • Let by-name implicit parameters have lazy semantics

                                                                                                                                                                                                          Es gibt in Scala bisher keine impliziten lazy Parameter. Das kann im Zusammenhang mit generischer Programmierung zu Problemen führen, die Shapeless mit dem Lazy Pseudo-Typ umgeht (mit Macro-Magie dahinter).

                                                                                                                                                                                                          Zur Vereinfachung gibt es in dotty jetzt die Möglichkeit implizite ›by-name‹ Parameter zu verwenden (def fun(implicit a => String)).

                                                                                                                                                                                                          Links
                                                                                                                                                                                                          • First class lazy values tie implicit recursive knots
                                                                                                                                                                                                          • Let by-name implicit parameters have lazy semantics
                                                                                                                                                                                                          • Play 2.6 M1

                                                                                                                                                                                                            Das Play-Team hat den ersten Milestone des 2.6.0‑Releases der Allgemeinheit zum Testen zur Verfügung gestellt. Geplantes Release-Datum ist gemäß dem Roadmap-Dokument März bis April 2017.

                                                                                                                                                                                                            Neuheiten
                                                                                                                                                                                                            • Keine Notwendigkeit mehr eine statische Application (Play.current) zur Verfügung zu stellen. Ziel ist es, dass mehrere Applications parallel ausgeführt und getestet werden können ohne sich gegenseitig zu beeinflussen. In diesem Zuge wurden diverse bisher globale Objekte auf Dependency-Injection verschoben (z.B. Action, BodyParser)
                                                                                                                                                                                                            • Unterstützung für Scala 2.12
                                                                                                                                                                                                            • Akka HTTP wird jetzt standardmäßig als HTTP-Server genutzt. Auf Wunsch kann weiterhin Netty (in Version 4.1) genutzt werden.
                                                                                                                                                                                                            • Typsichere Request-Attribute
                                                                                                                                                                                                            • Folgende Libraries wurden als eigenständige Bibliotheken mit unabhängigen Release-Zyklus aus Play herausgelöst:
                                                                                                                                                                                                              • play-json (Unterstützt auch ScalaJS!)
                                                                                                                                                                                                              • play-ws
                                                                                                                                                                                                              • play-iteratees
                                                                                                                                                                                                              • Folgende Funktionalitäten wurden ebenfalls als Module herausgelöst, bleiben aber an Play und dessen Release-Zyklus gekoppelt:
                                                                                                                                                                                                                • Guice-Support (play-guice)
                                                                                                                                                                                                                • Java Forms (play-java-forms)
                                                                                                                                                                                                                • Fehlende 2.6 Features

                                                                                                                                                                                                                  Gemäß dem Roadmap-Dokument sind die folgenden weiteren Features für Play 2.6 geplant, derzeit aber noch nicht verfügbar:

                                                                                                                                                                                                                  • Typsichere Variante bekannter Request-Header
                                                                                                                                                                                                                  • Unterstützung von HTTP/2
                                                                                                                                                                                                                  • Aussicht auf Play 3

                                                                                                                                                                                                                    In dem Roadmap-Dokument findet sich auch ein Ausblick auf Play 3 (ETA Januar 2018)

                                                                                                                                                                                                                    Links
                                                                                                                                                                                                                    • Play 2.6.0‑M1 released!
                                                                                                                                                                                                                    • Play Roadmap-Dokument
                                                                                                                                                                                                                    • Contextual

                                                                                                                                                                                                                      John Pretty hat die erste Version von Contextual vorgestellt. Mit Contextual kann man sich einfach einen String-Interpolator implementieren, der schon beim kompilieren überprüft ob ein gegebener String bestimmte Bedingungen erfüllt.

                                                                                                                                                                                                                      Das folgende Beispiel von der Homepage zeigt einen einfachen String-Interpolator für URLs (wobei die Funktion checkValidUrl(...) noch irgendwo anders implementiert werden muss):

                                                                                                                                                                                                                      import contextual._
                                                                                                                                                                                                                      case class Url(url: String)
                                                                                                                                                                                                                      object UrlInterpolator extends Interpolator {
                                                                                                                                                                                                                      def contextualize(interpolation: StaticInterpolation) = {
                                                                                                                                                                                                                      val lit@Literal(_, urlString) = interpolation.parts.head
                                                                                                                                                                                                                      if(!checkValidUrl(urlString))
                                                                                                                                                                                                                      interpolation.abort(lit, 0, "not a valid URL")
                                                                                                                                                                                                                      Nil
                                                                                                                                                                                                                      }
                                                                                                                                                                                                                      def evaluate(interpolation: RuntimeInterpolation): Url =
                                                                                                                                                                                                                      Url(interpolation.literals.head)
                                                                                                                                                                                                                      }
                                                                                                                                                                                                                      implicit class UrlStringContext(sc: StringContext) {
                                                                                                                                                                                                                      val url = Prefix(UrlInterpolator, sc)
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                      Mit diesem Interpolator führt dann z.B. url"foobar" zu einem Compiler-Fehler, wäheren url"http://co.ntextu.al" ohne Fehler compiliert.

                                                                                                                                                                                                                      Links
                                                                                                                                                                                                                      • Contextual
                                                                                                                                                                                                                      • Scala Enumerations

                                                                                                                                                                                                                        Es gibt verschiedene Möglichkeiten Enumerations in Scala umzusetzen. Pedro Rijo einen lesenswerten Artikel geschrieben in dem er die verschiedenen Möglichkeiten mit Ihren Vor- und Nachteilen beleuchtet. In einem zweiten Artikel bezieht er auch Java Enumerations in die Betrachtung mit ein.

                                                                                                                                                                                                                        scala.Enumerations
                                                                                                                                                                                                                        object Gender extends Enumeration {
                                                                                                                                                                                                                        val Female, Male = Value
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                        Features:

                                                                                                                                                                                                                        • (De)Serialisierung
                                                                                                                                                                                                                        • (Anpassbare) String-Representation
                                                                                                                                                                                                                        • Auflistung der verfügbaren Werte- Sortierung
                                                                                                                                                                                                                        • Sortierung
                                                                                                                                                                                                                        • Probleme:

                                                                                                                                                                                                                          • Unterschiedliche Enumerations haben den selben Typ (nach Type-Erasure)
                                                                                                                                                                                                                          • Kein Matching-Check auf Vollständigkeit zur Compile-Zeit
                                                                                                                                                                                                                          • Sealed case objects
                                                                                                                                                                                                                            sealed trait Gender
                                                                                                                                                                                                                            case object Female
                                                                                                                                                                                                                            case object Male

                                                                                                                                                                                                                            Features:

                                                                                                                                                                                                                            • Löst die beiden Probleme von scala.Enumeration
                                                                                                                                                                                                                            • Möglichkeit zusätzliche vals hinzuzufügen
                                                                                                                                                                                                                            • Probleme:

                                                                                                                                                                                                                              • Keine automatische Lösung um alle Werte zu erhalten
                                                                                                                                                                                                                              • Keine Standard-(De)Serialisierung
                                                                                                                                                                                                                              • Keine Standard-Sortierung
                                                                                                                                                                                                                              • Library itemized

                                                                                                                                                                                                                                itemized erzeugt mit Hilfe von Macros sealed Trait-Hierarchien:

                                                                                                                                                                                                                                @enum trait Gender {
                                                                                                                                                                                                                                object Female
                                                                                                                                                                                                                                object Male
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                Features:

                                                                                                                                                                                                                                • Auflistung aller möglichen Werte
                                                                                                                                                                                                                                • Standard (De)Serialisierung
                                                                                                                                                                                                                                • Probleme:

                                                                                                                                                                                                                                  • Keine Möglichkeit zusätzliche Eigenschaften hinzuzufügen
                                                                                                                                                                                                                                  • Unterstützt zwar indizierte Werte, aber keine Standard-Sortierung
                                                                                                                                                                                                                                  • Library enumeratum
                                                                                                                                                                                                                                    sealed trait Gender extends EnumEntry
                                                                                                                                                                                                                                    object Gender extends Enum[Gender] {
                                                                                                                                                                                                                                    val values = findValues
                                                                                                                                                                                                                                    case object Female extends Gender
                                                                                                                                                                                                                                    case object Male extends Gender
                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                    Features:

                                                                                                                                                                                                                                    • Prüfung auf Vollständigkeit von Matches
                                                                                                                                                                                                                                    • Auflistung der verfügbaren Werte
                                                                                                                                                                                                                                    • Standard (De)Serialisierung
                                                                                                                                                                                                                                    • Möglichkeit zusätzliche Werte hinzuzufügen
                                                                                                                                                                                                                                    • Nachteile:

                                                                                                                                                                                                                                      • Sortierung ist möglich erfordert aber eine manuelle Implementierung des Ordered-Traits
                                                                                                                                                                                                                                      • Java Enumerations

                                                                                                                                                                                                                                        Der Artikel von Pedro führte zu einer interessanten Diskussion auf Reddit, der unter anderem die klassischen Java-Enumerations als Alternative vorschlugen.

                                                                                                                                                                                                                                        public enum Gender {
                                                                                                                                                                                                                                        Female, Male
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                        Features:

                                                                                                                                                                                                                                        • Prüfung auf Vollständigkeit von Matches
                                                                                                                                                                                                                                        • Auflistung der verfügbaren Werte
                                                                                                                                                                                                                                        • Standard (De)Serialisierung
                                                                                                                                                                                                                                        • Keine Type-Erasure
                                                                                                                                                                                                                                        • Möglichkeit zusätzliche Werte hinzuzufügen
                                                                                                                                                                                                                                        • Kein Overhead bei der Ausführung auf der JVM
                                                                                                                                                                                                                                        • Nachteile:

                                                                                                                                                                                                                                          • Keine automatische Standard-Sortierung
                                                                                                                                                                                                                                          • Die Enumeration muss in Java-Code definiert werden. Ggf. eingeschränkte Typ-Nutzung.
                                                                                                                                                                                                                                          • Fazit

                                                                                                                                                                                                                                            scala.Enumeration taugt für die meisten Fälle. Wenn das nicht reicht scheint die Library enumeratum eine interessante Alternative zu sein.

                                                                                                                                                                                                                                            Links
                                                                                                                                                                                                                                            • Scala Enumerations
                                                                                                                                                                                                                                            • Java Enumerations in Scala
                                                                                                                                                                                                                                            • Gib uns Dein Feedback als Kommentar auf unserer Web-Site, via Twitter oder Google+.

                                                                                                                                                                                                                                              Kapitel
                                                                                                                                                                                                                                              1. Intro (00:00:00.000)
                                                                                                                                                                                                                                              2. Einleitung (00:00:37.165)
                                                                                                                                                                                                                                              3. Hörerfeedback (00:01:44.035)
                                                                                                                                                                                                                                              4. Scala Center Advisory Board and SIP-Meeting-Results Dezember 2016 (00:04:57.379)
                                                                                                                                                                                                                                              5. Scastie (00:10:45.389)
                                                                                                                                                                                                                                              6. ScalaDays 2017 (00:16:48.664)
                                                                                                                                                                                                                                              7. Let by-name implicit parameters have lazy semantics (00:19:21.880)
                                                                                                                                                                                                                                              8. Play 2.6 M1 (00:21:37.229)
                                                                                                                                                                                                                                              9. Contextual (00:41:04.259)
                                                                                                                                                                                                                                              10. Scala Enumerations (00:48:02.989)
                                                                                                                                                                                                                                              11. Outro (01:01:02.352)
                                                                                                                                                                                                                                              12. Lizenz


                                                                                                                                                                                                                                                Scala Profis von Benjamin Hagemeister & Sven Wiegand ist lizenziert unter einer Creative Commons Namensnennung — Keine Bearbeitungen 4.0 International Lizenz.

                                                                                                                                                                                                                                                Über diese Lizenz hinausgehende Erlaubnisse kannst Du unter http://scalaprofis.de erhalten.

                                                                                                                                                                                                                                                Titelsong basierend auf Wish You Were Here von THE.MADPIX.PROJECT lizensiert unter Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0).

                                                                                                                                                                                                                                                1 hr 4 min
                                                                                                                                                                                                                                              13. SP12/16: Scala 2.12 und Jahresrückblick

                                                                                                                                                                                                                                                Wir suchen einen Scala-Entwickler

                                                                                                                                                                                                                                                Willst Du Scala endlich auch beruflich einsetzen? Dann komm zu uns. Für unser Berliner Team bei der Beta System IAM Software AG suchen wir einen Scala-Entwickler bzw. eine Scala-Entwicklerin. In einem sechsköpfigen Scrum-Team entwickelst Du unsere neue Web-Basierte IAM-Suite, vollständig in Scala.

                                                                                                                                                                                                                                                Auch als Quereinsteiger aus der Java-Welt bist Du herzlich willkommen.

                                                                                                                                                                                                                                                Bewirb Dich jetzt (gib bei der Bewerbung mit an, dass Du über die Scala Profis auf die Stelle aufmerksam geworden bist).

                                                                                                                                                                                                                                                Scala 2.12.0

                                                                                                                                                                                                                                                Seit 3. November ist Scala 2.12 verfügbar!

                                                                                                                                                                                                                                                Haupt-Features

                                                                                                                                                                                                                                                Der Scala-Compiler wurde komplett überarbeitet um — wo möglich — die neuen Java 8 Features zu nutzen:

                                                                                                                                                                                                                                                • Traits compilieren zu Interfaces mit Default-Methoden. Das verbessert die Binär-Kompatibilität und die Interoperabilität mit Java.
                                                                                                                                                                                                                                                • Scala und Java 8 Interoperabilität für funktionalen Code wurde verbessert, da Methoden, die Funktionen übergeben bekommen nun aus beiden Sprachen mit Lambda-Ausdrücken aufgerufen werden können. Die FunctionN-Klassen in Scalas standard-Library sind nun als SAMs implementiert. Somit werden keine .class-Dateien mehr für Lambdas generiert — stattdessen wird invokedynamic genutzt. Dadurch reduziert sich die Größe der JAR-Dateien teils drastisch. Zum Beispiel hat sich das ScalaTest 3.0.0 JAR von 9,9 auf 6,7 MB reduziert.
                                                                                                                                                                                                                                                • Außerdem bietet das Release einen leistungsstarken neuen Optimierer.

                                                                                                                                                                                                                                                  Neue Sprach-Features
                                                                                                                                                                                                                                                  • Traits werden zu Interfaces compiliert
                                                                                                                                                                                                                                                  • Lambda-Syntax für SAM-Typen
                                                                                                                                                                                                                                                  • Java-8-Style Byte-Code für Lambdas
                                                                                                                                                                                                                                                  • Neue Abbildung und neuer Locking-Scope für lokale lazy vals
                                                                                                                                                                                                                                                  • Bessere Typ-Inference für Lambda-Parameter und überschriebene vals in Scala.js
                                                                                                                                                                                                                                                  • Überarbeiteter Look-&-Feel für ScalaDoc (siehe Scala-Standard-Library API-Doku als Beispiel)
                                                                                                                                                                                                                                                  • ScalaDoc kann benutzt werden um Java zu dokumentieren
                                                                                                                                                                                                                                                  • Verbesserung der REPL (Farben)
                                                                                                                                                                                                                                                  • Verbesserungen der Standard-Library
                                                                                                                                                                                                                                                    • Either unterstützt jetzt map, flatMap, contains, toOption und weitere Funktionen.
                                                                                                                                                                                                                                                    • scala.concurrent.Future wurde überarbeitet. Die Anpassungen werden in einer Blog-Post-Reihe von Viktor Klang beschrieben:
                                                                                                                                                                                                                                                      • flatten
                                                                                                                                                                                                                                                      • zipWith
                                                                                                                                                                                                                                                      • transform
                                                                                                                                                                                                                                                      • transformWith
                                                                                                                                                                                                                                                      • Deprecation of onSuccess und onFailure
                                                                                                                                                                                                                                                      • unit und never
                                                                                                                                                                                                                                                      • Überarbeitung des Java 8 compatibility module for Scala.
                                                                                                                                                                                                                                                      • Fragen & Antworten
                                                                                                                                                                                                                                                        Wie sieht es mit der Kompatibilität zu Scala 2.11 aus?

                                                                                                                                                                                                                                                        2.11 und 2.12 sind Source-Code-kompatibel, wie gewohnt aber nicht binärkompatibel.

                                                                                                                                                                                                                                                        Sollte ich Scala 2.12 jetzt schon nutzen?

                                                                                                                                                                                                                                                        Die Liste der Libraries, die Scala 2.12 unterstützt wächst stetig. Sollten Deine eingesetzten Libraries bereits unterstützt werden steht einem Wechsel aus unserer Sicht nichts im Wege.

                                                                                                                                                                                                                                                        Was, wenn meine Kunden derzeit noch die JVM 7 einsetzen?

                                                                                                                                                                                                                                                        Oracle stellt bereits seit April 2015 keine Updates mehr für Java 7 bereit. Dementsprechend solltest Du Deinen Kunden dringend einen Wechsel auf Java 8 empfehlen womit der Weg für Scala 2.12 geebnet ist.

                                                                                                                                                                                                                                                        Wie sieht es mit Android aus?

                                                                                                                                                                                                                                                        Leider schlecht! Android arbeitet weiterhin auf Basis von Java 7 und wird den von Scala 2.12 benötigten Funktionsumfang auf absehbare Zeit auch nicht unterstützen. Wenn Du also Android-Anwendungen in Scala schreibst musst Du bei Scala 2.11 bleiben.

                                                                                                                                                                                                                                                        Wie geht es mit den alten Scala-Versionen weiter?

                                                                                                                                                                                                                                                        Das letzte Release für Scala 2.11 (2.11.9) wird für Mitte Dezember erwartet.

                                                                                                                                                                                                                                                        Links
                                                                                                                                                                                                                                                        • http://www.scala-lang.org/news/2.12.0
                                                                                                                                                                                                                                                        • SBT 0.13.13

                                                                                                                                                                                                                                                          SBT 0.13.13 ist seit dem 28. Oktober verfügbar, angekündigt als ›Technology Preview‹ für die Version 1.0.

                                                                                                                                                                                                                                                          In der Version 0.13.13 wurden verschiedene Funktionen wie z.B. die DSL aus der Version 0.12 (<<=, <+=, …) als deprecated markiert. Diese Funktionen wird es in der Version 1.0 nicht mehr geben.

                                                                                                                                                                                                                                                          Die für mich interessanteste Änderung ist das new Kommando. Wenn man den Launcher der Version 0.13.13 verwendet (also nicht nur in project/build.properties die Version auf 0.13.13 setzt) kann man über sbt new ein neues Projekt erzeugen.

                                                                                                                                                                                                                                                          Giter8 lädt die Templates über ein beliebiges Git-Repository. Man kann damit leicht eigene Templates z.B. auf GitHub veröffentlichen. Zusätzlich ist es möglich eigene Resolver für Templates zu implementieren.

                                                                                                                                                                                                                                                          Links
                                                                                                                                                                                                                                                          • Ankündigung
                                                                                                                                                                                                                                                          • sbt new and Templates
                                                                                                                                                                                                                                                          • Giter8
                                                                                                                                                                                                                                                          • Pull-Request: Abschaffung des 22 Parameter-Limits für Funktionen

                                                                                                                                                                                                                                                            Martin Odersky hat einen Pull-Request, der Funktionen mit mehr als 22 Parametern unterstützt. Realisiert wird das ganze, in dem Funktionen mit mehr Parametern intern auf einen Typ FunctionXXL gemappt werden, der einen Array von Objekten annimmt.

                                                                                                                                                                                                                                                            Der Pull-Request befindet sich aktuell im Code-Review.

                                                                                                                                                                                                                                                            Links
                                                                                                                                                                                                                                                            • Issue #1758: Drop function 22 limit
                                                                                                                                                                                                                                                            • Scala.js 0.6.13
                                                                                                                                                                                                                                                              Änderungen der Standard-Interpreter

                                                                                                                                                                                                                                                              Bisherige Standards:

                                                                                                                                                                                                                                                              • Rhino
                                                                                                                                                                                                                                                              • Node.js wenn scalaJSUseRhino in Global := false
                                                                                                                                                                                                                                                              • PhantomJS wenn scalaJSUseRhino in Global := false und jsDependencies += RuntimeDOM
                                                                                                                                                                                                                                                              • Neue Standards:

                                                                                                                                                                                                                                                                • Node.js
                                                                                                                                                                                                                                                                • Node.js + jsdom wenn jsDependencies += RuntimeDOM
                                                                                                                                                                                                                                                                • Node.js und jsdom müssen getrennt installiert werden.

                                                                                                                                                                                                                                                                  Umgang mit CommonJS-Modulen

                                                                                                                                                                                                                                                                  CommonJS-Module werden von Node.js und diversen Bundlern genutzt

                                                                                                                                                                                                                                                                  Scala.js-Projekte können jetzt CommonJS-Module bereitstellen (scalaJSModuleKinde := ModuleKind.CommonJSModule) wodurch Objekte und mit @JSExport annotierte Klassen über das Modul angeboten werden.

                                                                                                                                                                                                                                                                  Über @JSImport Scaladoc können Module importiert werden. Das entspricht einem ECMAScript 2015 Import, wird von Scala aber in ein CommonJS require umgewandelt.

                                                                                                                                                                                                                                                                  Wichtig: @JSImport ist nicht kompatibel mit jsDependencies, statt dessen musst Du Deine JavaScript-Dependencies selbstständig pflegen (z.B. via npm).

                                                                                                                                                                                                                                                                  Links
                                                                                                                                                                                                                                                                  • Announcing Scala.js 0.6.13
                                                                                                                                                                                                                                                                  • Unsere Highlights 2016
                                                                                                                                                                                                                                                                    Svens Highlights
                                                                                                                                                                                                                                                                    • Scala 2.12 released
                                                                                                                                                                                                                                                                    • Dotty (SP002)
                                                                                                                                                                                                                                                                    • Kotlin 1.0 (SP003)
                                                                                                                                                                                                                                                                    • Gründung des Scala Centers (SP004)
                                                                                                                                                                                                                                                                    • ScalaJS wird erwachsen (SP05/16)
                                                                                                                                                                                                                                                                    • Benjamins Highlights
                                                                                                                                                                                                                                                                      • Scala 2.12 released
                                                                                                                                                                                                                                                                      • Gründung des Scala Centers (SP004)
                                                                                                                                                                                                                                                                      • Spielereien mit Macros (SP005)
                                                                                                                                                                                                                                                                      • ScalaDays in Berlin (SP006)
                                                                                                                                                                                                                                                                      • Umstellung auf SBT (SP05/16)
                                                                                                                                                                                                                                                                      • Unsere Wünsche für 2017
                                                                                                                                                                                                                                                                        Svens Wünsche
                                                                                                                                                                                                                                                                        • Breite Unterstützung von Scala 2.12
                                                                                                                                                                                                                                                                        • Scala 3 auf Basis von Dotty mit schnellerem und zuverlässigerem Compiler
                                                                                                                                                                                                                                                                        • Benjamins Wünsche
                                                                                                                                                                                                                                                                          • Scala 3 auf Basis von Dotty mit schnellerem und noch schnellerem Compiler
                                                                                                                                                                                                                                                                          • SBT 1.0
                                                                                                                                                                                                                                                                          • Umstellung auf Scala 2.12
                                                                                                                                                                                                                                                                          • Ein neuer Kollege oder eine neue Kollegin
                                                                                                                                                                                                                                                                          • Gib uns Dein Feedback als Kommentar auf unserer Web-Site, via Twitter oder Google+.

                                                                                                                                                                                                                                                                            Kapitel
                                                                                                                                                                                                                                                                            1. Intro (00:00:00.000)
                                                                                                                                                                                                                                                                            2. Eine offene Scala-Stelle (00:01:30.371)
                                                                                                                                                                                                                                                                            3. Scala 2.12 (00:01:55.523)
                                                                                                                                                                                                                                                                            4. SBT 0.13.13 (00:27:36.899)
                                                                                                                                                                                                                                                                            5. Abschaffung des 22 Parameter-Limits für Funktionen (00:32:28.129)
                                                                                                                                                                                                                                                                            6. Scala.js 0.6.13 (00:35:41.528)
                                                                                                                                                                                                                                                                            7. Unsere Highlights in 2016 (00:39:11.629)
                                                                                                                                                                                                                                                                            8. Unsere Wünsche für 2017 (00:51:58.829)
                                                                                                                                                                                                                                                                            9. Outro (00:58:39.475)
                                                                                                                                                                                                                                                                            10. Lizenz


                                                                                                                                                                                                                                                                              Scala Profis von Benjamin Hagemeister & Sven Wiegand ist lizenziert unter einer Creative Commons Namensnennung — Keine Bearbeitungen 4.0 International Lizenz.

                                                                                                                                                                                                                                                                              Über diese Lizenz hinausgehende Erlaubnisse kannst Du unter http://scalaprofis.de erhalten.

                                                                                                                                                                                                                                                                              Titelsong basierend auf Wish You Were Here von THE.MADPIX.PROJECT lizensiert unter Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0).

                                                                                                                                                                                                                                                                              1 hr 2 min
                                                                                                                                                                                                                                                                            11. SP10/16: Ich weiß was Du letzten Sommer getan hast

                                                                                                                                                                                                                                                                              Wir suchen einen Scala-Entwickler

                                                                                                                                                                                                                                                                              Willst Du Scala endlich auch beruflich einsetzen? Dann komm zu uns. Für unser Berliner Team bei der Beta System IAM Software AG suchen wir einen Scala-Entwickler bzw. eine Scala-Entwicklerin. In einem sechsköpfigen Scrum-Team entwickelst Du unsere neue Web-Basierte IAM-Suite, vollständig in Scala.

                                                                                                                                                                                                                                                                              Auch als Quereinsteiger aus der Java-Welt bist Du herzlich willkommen.

                                                                                                                                                                                                                                                                              Bewirb Dich jetzt (gib bei der Bewerbung mit an, dass Du über die Scala Profis auf die Stelle aufmerksam geworden bist).

                                                                                                                                                                                                                                                                              Scala 2.12-RC1 verfügbar

                                                                                                                                                                                                                                                                              Der gemäß ursprünglicher Planung für Ende Mai vorgesehene Release Candidate 1 wurde nun am 6. September 2016 released.

                                                                                                                                                                                                                                                                              Im Zentrum von Scala 2.12 steht die bessere Integration mit Java 8. Das bedeutet auch, dass mit Scala 2.12 gebaute Anwendungen eine Java 8 VM voraussetzen.

                                                                                                                                                                                                                                                                              Ein Release-Termin für 2.12.0 ist uns aktuell nicht bekannt.

                                                                                                                                                                                                                                                                              Links
                                                                                                                                                                                                                                                                              • Scala 2.12-RC1 is now available
                                                                                                                                                                                                                                                                              • The Scala Center Advisory Board
                                                                                                                                                                                                                                                                                Über das Advisory Board
                                                                                                                                                                                                                                                                                • Spricht Empfehlungen an das Scala Center aus, woran es arbeiten soll.
                                                                                                                                                                                                                                                                                • Es ist die Aufgabe des Scala Centers, diese Empfehlungen zu bearbeiten.
                                                                                                                                                                                                                                                                                • Das Board hat sieben abstimmende Mitglieder:
                                                                                                                                                                                                                                                                                  • Vertreter der sechs (wenn ich das richtig verstehe inzwischen 9) Sponsoren: Artima, 47 Degrees, IBM, Lightbend, Nitro, SAP, Tapad, Twitter, Verizone
                                                                                                                                                                                                                                                                                  • Bill Venners als Vertreter der Community
                                                                                                                                                                                                                                                                                  • Heather Mills als »Executive Director« des Scala Centers, um über die Aktivitäten des Scala Centers zu berichten
                                                                                                                                                                                                                                                                                  • Martin Odersky als technischer Berater des Boards
                                                                                                                                                                                                                                                                                  • Das Board trifft sich viermal im Jahr
                                                                                                                                                                                                                                                                                  • Wie funktioniert das Board
                                                                                                                                                                                                                                                                                    • Ziel jedes Meetings ist es Empfehlungen auszusprechen, woran das Scala Center in den nächsten drei Monaten arbeiten soll
                                                                                                                                                                                                                                                                                    • Entscheidend ist, dass die Empfehlungen des Boards nicht bindend sind
                                                                                                                                                                                                                                                                                    • Heather und Martin sitzen im Board, um das Board über die Machbarkeit/Sinnhaftigkeit von Empfehlungen vorab zu beraten
                                                                                                                                                                                                                                                                                    • Jedes der sieben Board-Mitglieder kann Vorschläge einreichen
                                                                                                                                                                                                                                                                                    • Die sieben Mitglieder können über die Vorschläge abstimmen um so daraus Empfehlungen für das Scala Center zu generieren.
                                                                                                                                                                                                                                                                                    • Die Vorschläge und Protokolle der Meetings werden im Github repository veröffentlicht.
                                                                                                                                                                                                                                                                                    • Erstes Meeting vom 9. Mai 2016

                                                                                                                                                                                                                                                                                      Dort wurden vier Empfehlungen ausgesprochen:

                                                                                                                                                                                                                                                                                      1. Klärung des Scala-Führungs-Prozesses inklusive des SIP/SLIP-Prozesses
                                                                                                                                                                                                                                                                                      2. Definition eines Migrationspfades von Scala 2.x nach Dotty
                                                                                                                                                                                                                                                                                      3. Schaffung einer »new unpaid publicity chair role« für das Scala Center und
                                                                                                                                                                                                                                                                                      4. Fortsetzung der Unterstützung für Scala.js
                                                                                                                                                                                                                                                                                      5. Protokoll des ersten Meetings

                                                                                                                                                                                                                                                                                        Zweites Meeting vom 9. August

                                                                                                                                                                                                                                                                                        Folgende Empfehlungen wurden beschlossen:

                                                                                                                                                                                                                                                                                        1. Native Execution of Scala/Spark via LLVM
                                                                                                                                                                                                                                                                                        2. Compile Time Check of Serializability
                                                                                                                                                                                                                                                                                        3. Protokoll des zweiten Meetings

                                                                                                                                                                                                                                                                                          Links
                                                                                                                                                                                                                                                                                          • The Scala Center Advisory Board
                                                                                                                                                                                                                                                                                          • Github Repository mit Meeting-Minutes
                                                                                                                                                                                                                                                                                          • ScalaCenter Meetings
                                                                                                                                                                                                                                                                                            Neuer SIP-Prozess

                                                                                                                                                                                                                                                                                            Im neuen Scala Improvement Process wird jeder SIP einem Reviewer zugeordnet, der diesen dem SIP-Komitee präsentiert.

                                                                                                                                                                                                                                                                                            Status aus Juli- und August-Meetings

                                                                                                                                                                                                                                                                                            Im Prozess sind:

                                                                                                                                                                                                                                                                                            • SIP-20 Improved Lazy Val Initialization: Vermeidung von Deadlocks
                                                                                                                                                                                                                                                                                            • SIP-23: Literal-based singleton types: ???
                                                                                                                                                                                                                                                                                            • SIP-25 Trait Parameters: Im Prinzip »Konstruktorparameter« für Traits
                                                                                                                                                                                                                                                                                            • SIP-26 Unsigned Integer Data Types: Einführung von UByte, UShort, UInt und ULong
                                                                                                                                                                                                                                                                                            • SIP-27 Trailing Commas: Erlaubt Kommas nach dem letzten Parameter einer Funktion oder dem letzten Eintrag einer einer Liste (ähnliche JavaScript). Soll das Auskommentieren und austauschen von Elementen erleichtern.
                                                                                                                                                                                                                                                                                            • Ein SIP wurde auf Wunsch des Autors zurückgestellt:

                                                                                                                                                                                                                                                                                              • SIP-22 Async
                                                                                                                                                                                                                                                                                              • Zwei weitere wurden abgelehnt:

                                                                                                                                                                                                                                                                                                • SIP-12: Uncluttering Scala’s syntax for control structure: »Verschönerung von if- und for-Statements.
                                                                                                                                                                                                                                                                                                • SIP-16: Self-cleaning macros
                                                                                                                                                                                                                                                                                                • Links
                                                                                                                                                                                                                                                                                                  • Juli SIP-Meeting
                                                                                                                                                                                                                                                                                                  • August SIP-Meeting
                                                                                                                                                                                                                                                                                                  • Multiversal Equality for Scala
                                                                                                                                                                                                                                                                                                    Aktuelles Problem

                                                                                                                                                                                                                                                                                                    Equality-Operator == ist nicht typsicher. So kann man versehentlich folgendes schreiben:

                                                                                                                                                                                                                                                                                                    val a = "hello"
                                                                                                                                                                                                                                                                                                    val b = Some("hello")
                                                                                                                                                                                                                                                                                                    a == b

                                                                                                                                                                                                                                                                                                    Das Ergebnis wird immer false sein, da die Typen nicht übereinstimmen.

                                                                                                                                                                                                                                                                                                    Potentielle Lösung

                                                                                                                                                                                                                                                                                                    Andere Sprachen bietet dazu den ===-Operator. Odersky möchte aber möglichst keinen neuen Operator einführen, sondern es bei dem ==-Operator belassen. Dabei ist allerdings das Problem der Abwärtskompatibilität zu berücksichtigen.

                                                                                                                                                                                                                                                                                                    Martin Odersky hat dafür einen Language Enhancement Proposal erstellt, den er in einem Blog-Eintrag inklusive möglichem Lösungsweg beschreibt.

                                                                                                                                                                                                                                                                                                    Links
                                                                                                                                                                                                                                                                                                    • Language Enhanceent Proposal
                                                                                                                                                                                                                                                                                                    • Blog-Eintrag von Martin Odersky
                                                                                                                                                                                                                                                                                                    • Statische Code-Analyse
                                                                                                                                                                                                                                                                                                      Compiler Option

                                                                                                                                                                                                                                                                                                      Der Scala Compiler bietet selbst einige Optionen, die für zusätzliche Warnungen und sogar Fehler sorgen.

                                                                                                                                                                                                                                                                                                      Die Optionen -Xlint -Ywarn-dead-code -Ywarn-numeric-widen -Yno-adapted-args -Ywarn-value-discard führen zu 323 Warnungen und 13 Fehlern!

                                                                                                                                                                                                                                                                                                      Die Fehler entstehen, weil die Option -Yno-adapted-args die Konvertierung von a, b nach (a, b) unterbindet.

                                                                                                                                                                                                                                                                                                      Externe Tools
                                                                                                                                                                                                                                                                                                      • Linter
                                                                                                                                                                                                                                                                                                        • Typ: Compiler Plugin (muss gegebenenfalls einzeln zu den Sub-Projekten hinzugefügt werden)
                                                                                                                                                                                                                                                                                                        • IDE-Integration: Keine
                                                                                                                                                                                                                                                                                                        • Konfiguration: scalacOptions
                                                                                                                                                                                                                                                                                                        • Ausnahmen:
                                                                                                                                                                                                                                                                                                          • Einzelne Zeilen über Kommentare (Komplett oder für einzelne Regeln)
                                                                                                                                                                                                                                                                                                          • Ausführen: Implizit bei compile
                                                                                                                                                                                                                                                                                                          • Ausgabe: Konsole
                                                                                                                                                                                                                                                                                                          • Warnungen: 106
                                                                                                                                                                                                                                                                                                          • WartRemover
                                                                                                                                                                                                                                                                                                            • Typ: SBT Plugin
                                                                                                                                                                                                                                                                                                            • IDE-Integration: Keine
                                                                                                                                                                                                                                                                                                            • Konfiguration: SBT
                                                                                                                                                                                                                                                                                                            • Ausnahmen:
                                                                                                                                                                                                                                                                                                              • Einzelne Dateien über SBT Einstellungen
                                                                                                                                                                                                                                                                                                              • Klassen oder Methoden über die Annotation java.lang.SuppressWarnings (Komplett oder für einzelne Regeln)
                                                                                                                                                                                                                                                                                                              • Ausführen: Implizit bei compile
                                                                                                                                                                                                                                                                                                              • Ausgabe: Konsole
                                                                                                                                                                                                                                                                                                              • Warnungen: 4332
                                                                                                                                                                                                                                                                                                              • Scapegoat
                                                                                                                                                                                                                                                                                                              • Nur Scala 2.11!
                                                                                                                                                                                                                                                                                                                • Typ: SBT Plugin
                                                                                                                                                                                                                                                                                                                • IDE-Integration: Keine
                                                                                                                                                                                                                                                                                                                • Konfiguration: SBT
                                                                                                                                                                                                                                                                                                                • Ausnahmen:
                                                                                                                                                                                                                                                                                                                  • Einzelne Dateien über SBT Einstellungen
                                                                                                                                                                                                                                                                                                                  • Klassen oder Methoden über die Annotation java.lang.SuppressWarnings (Komplett oder für einzelne Regeln)
                                                                                                                                                                                                                                                                                                                  • Ausführen: Explizit über scapegoat
                                                                                                                                                                                                                                                                                                                  • Ausgabe: Konsole, HTML, XML
                                                                                                                                                                                                                                                                                                                  • Scalastyle
                                                                                                                                                                                                                                                                                                                  • Wird im Coursera Kurs Functional Programming Principles in Scala für die Auswertung der Übungen mit verwendet.
                                                                                                                                                                                                                                                                                                                    • Typ: SBT Plugin
                                                                                                                                                                                                                                                                                                                    • IDE-Integration:
                                                                                                                                                                                                                                                                                                                      • Eclipse Plugin
                                                                                                                                                                                                                                                                                                                      • Inspection für IntelliJ IDEA
                                                                                                                                                                                                                                                                                                                      • Konfiguration:XML Datei (kann über ein SBT Kommando generiert werden)
                                                                                                                                                                                                                                                                                                                      • Ausnahmen:
                                                                                                                                                                                                                                                                                                                        • Einzelne Zeilen und Code-Blöcke über Kommentare (Komplett oder für einzelne Regeln)
                                                                                                                                                                                                                                                                                                                        • Ausführen: Explizit über scalastyle
                                                                                                                                                                                                                                                                                                                        • Ausgabe: Konsole, XML im Checkstyle Format
                                                                                                                                                                                                                                                                                                                        • Warnungen: 1097
                                                                                                                                                                                                                                                                                                                        • Interessante Warnungen
                                                                                                                                                                                                                                                                                                                          • case classes must be final siehe stackoverflow
                                                                                                                                                                                                                                                                                                                          • Inferred type containing Any
                                                                                                                                                                                                                                                                                                                          • Descendants of a sealed type must be final or sealed
                                                                                                                                                                                                                                                                                                                          • Merge these two map operations
                                                                                                                                                                                                                                                                                                                          • Verwendung von
                                                                                                                                                                                                                                                                                                                            • var
                                                                                                                                                                                                                                                                                                                            • null
                                                                                                                                                                                                                                                                                                                            • Option.get
                                                                                                                                                                                                                                                                                                                            • Links
                                                                                                                                                                                                                                                                                                                              • How to make the Scala compiler to review your code (2016)
                                                                                                                                                                                                                                                                                                                              • Review of Scala Static Analysis Tools (2015)
                                                                                                                                                                                                                                                                                                                              • Linter
                                                                                                                                                                                                                                                                                                                              • WartRemover
                                                                                                                                                                                                                                                                                                                              • WartRemover & quasiquotes
                                                                                                                                                                                                                                                                                                                              • Scapegoat
                                                                                                                                                                                                                                                                                                                              • Scalastyle
                                                                                                                                                                                                                                                                                                                              • ScalaTest 3.0: What’s new

                                                                                                                                                                                                                                                                                                                                Kürzlich wurde ScalaTest 3.0.0 freigegeben. In dem Artikel What’s new in ScalaTest 3.0 werden Hauptneuerungen der Version aufgeführt:

                                                                                                                                                                                                                                                                                                                                • Vollständige Unterstützung für Scala.js
                                                                                                                                                                                                                                                                                                                                • Asynchrone Varianten zum Testen von Future (siehe auch Episode SP06/16 zu den ScalaDays)
                                                                                                                                                                                                                                                                                                                                • Erweiterte Matchers mit zusätzlichen Match-Words um Container zu testen: Einleitung durch z.B. must contain oneElementOf, noElementOf, atLeastOneElementOf, atMostOneElementOf, allElementsOf and inOrderElementsOf.
                                                                                                                                                                                                                                                                                                                                • Assertions und Macher liefern als Ergebnis jetzt ein Objekt vom Typ Assertion an Stelle von Unit.
                                                                                                                                                                                                                                                                                                                                • Link
                                                                                                                                                                                                                                                                                                                                  • What’s new in ScalaTest 3.0
                                                                                                                                                                                                                                                                                                                                  • ScalaFiddle

                                                                                                                                                                                                                                                                                                                                    ScalaFiddle ist ein Seite zum testen und teilen von Scala Code, also JsFiddle nur für Scala. Ein ScalaFiddle kann per ›

                                                                                                                                                                                                                                                                                                                                    Links
                                                                                                                                                                                                                                                                                                                                    • ScalaFiddle
                                                                                                                                                                                                                                                                                                                                    • play-swagger

                                                                                                                                                                                                                                                                                                                                      Swagger ist eine Sprache zur Spezifikation von REST-Schnittstellen. play-swagger kann aus dieser Spezifikation folgende Play-Artefakte generieren:

                                                                                                                                                                                                                                                                                                                                      • Routes file
                                                                                                                                                                                                                                                                                                                                      • Generators of random test data
                                                                                                                                                                                                                                                                                                                                      • Wrappers for Play route files to convert semantics from http-related to domain-related (controller_base)
                                                                                                                                                                                                                                                                                                                                      • Skeletons for the domain-driven controller implementation
                                                                                                                                                                                                                                                                                                                                      • Model classes and validation rules
                                                                                                                                                                                                                                                                                                                                      • Unit tests for invalid and valid parameter sets
                                                                                                                                                                                                                                                                                                                                      • Security extractors (if needed)
                                                                                                                                                                                                                                                                                                                                      • Skeletons for custom deserializers (if needed)
                                                                                                                                                                                                                                                                                                                                      • Links
                                                                                                                                                                                                                                                                                                                                        • play-swagger
                                                                                                                                                                                                                                                                                                                                        • Scala Exercises

                                                                                                                                                                                                                                                                                                                                          Scala Exercises ist ein Open-Source Projekt von 47 Degrees. Auf der Web-Seite gibt es Einführungen mit Übungen zu verschiedenen Scala Bibliotheken.

                                                                                                                                                                                                                                                                                                                                          Der Code für die verschiedenen Übungen liegt auf GitHub.

                                                                                                                                                                                                                                                                                                                                          Momentan gibt es Übungen zu den folgenden Themen:

                                                                                                                                                                                                                                                                                                                                          • STD LIB
                                                                                                                                                                                                                                                                                                                                          • Cats
                                                                                                                                                                                                                                                                                                                                          • Shapeless
                                                                                                                                                                                                                                                                                                                                          • Doobie
                                                                                                                                                                                                                                                                                                                                          • Scalacheck
                                                                                                                                                                                                                                                                                                                                          • FP in Scala
                                                                                                                                                                                                                                                                                                                                          • Es gibt eine Anleitung zum Hinzufügen von neuen Themen, wenn die Episode online ist sind es also unter Umständen noch mehr.

                                                                                                                                                                                                                                                                                                                                            Links
                                                                                                                                                                                                                                                                                                                                            • Scala Exercises
                                                                                                                                                                                                                                                                                                                                            • Gib uns Dein Feedback als Kommentar auf unserer Web-Site, via Twitter oder Google+.

                                                                                                                                                                                                                                                                                                                                              Kapitel
                                                                                                                                                                                                                                                                                                                                              1. Intro (00:00:00.000)
                                                                                                                                                                                                                                                                                                                                              2. Wir suchen einen Scala-Entwickler (00:02:19.309)
                                                                                                                                                                                                                                                                                                                                              3. Scala 2.12-RC1 released (00:03:56.024)
                                                                                                                                                                                                                                                                                                                                              4. The Scala Center Advisory Board (00:07:40.696)
                                                                                                                                                                                                                                                                                                                                              5. ScalaCenter Meetings (00:18:49.080)
                                                                                                                                                                                                                                                                                                                                              6. Multiversal Equality for Scala (00:30:54.765)
                                                                                                                                                                                                                                                                                                                                              7. Statische Code-Analyse (00:35:57.251)
                                                                                                                                                                                                                                                                                                                                              8. ScalaTest 3.0: What’s new (01:04:16.003)
                                                                                                                                                                                                                                                                                                                                              9. ScalaFiddle (01:06:57.624)
                                                                                                                                                                                                                                                                                                                                              10. play-swagger (01:09:31.907)
                                                                                                                                                                                                                                                                                                                                              11. Scala Excercises (01:13:09.411)
                                                                                                                                                                                                                                                                                                                                              12. Outro (01:14:52.408)
                                                                                                                                                                                                                                                                                                                                              13. Lizenz


                                                                                                                                                                                                                                                                                                                                                Scala Profis von Benjamin Hagemeister & Sven Wiegand ist lizenziert unter einer Creative Commons Namensnennung — Keine Bearbeitungen 4.0 International Lizenz.

                                                                                                                                                                                                                                                                                                                                                Über diese Lizenz hinausgehende Erlaubnisse kannst Du unter http://scalaprofis.de erhalten.

                                                                                                                                                                                                                                                                                                                                                Titelsong basierend auf Wish You Were Here von THE.MADPIX.PROJECT lizensiert unter Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0).

                                                                                                                                                                                                                                                                                                                                                1 hr 17 min
                                                                                                                                                                                                                                                                                                                                              14. SP06/16: ScalaDays

                                                                                                                                                                                                                                                                                                                                                Wir suchen einen Scala-Entwickler

                                                                                                                                                                                                                                                                                                                                                Willst Du Scala endlich auch beruflich einsetzen? Dann komm zu uns. Für unser Berliner Team bei der Beta System IAM Software AG suchen wir einen Scala-Entwickler bzw. eine Scala-Entwicklerin für unser siebenköpfiges Scrum-Team.

                                                                                                                                                                                                                                                                                                                                                Auch als Quereinsteiger aus der Java-Welt bist Du herzlich willkommen.

                                                                                                                                                                                                                                                                                                                                                Bewirb Dich jetzt (gib bei Deiner Bewerbung bitte an, dass Du über diesen Podcast auf die Stelle aufmerksam geworden bist).

                                                                                                                                                                                                                                                                                                                                                Scaladays 2016 Berlin
                                                                                                                                                                                                                                                                                                                                                Keynote von Martin Odersky
                                                                                                                                                                                                                                                                                                                                                Aktuelles
                                                                                                                                                                                                                                                                                                                                                • Scala 2.12 erfordert Java 8
                                                                                                                                                                                                                                                                                                                                                • Scala 2.11 wird es noch länger geben für die, die noch nicht auf Java 8 gehen können
                                                                                                                                                                                                                                                                                                                                                • Blick in die Zukunft
                                                                                                                                                                                                                                                                                                                                                  • Procedure Syntax fällt weg
                                                                                                                                                                                                                                                                                                                                                  • Macros werden durch Metaprogramming ersetzt
                                                                                                                                                                                                                                                                                                                                                  • Benamte Typ-Parameter
                                                                                                                                                                                                                                                                                                                                                  • Typen mit & und |
                                                                                                                                                                                                                                                                                                                                                  • Verarbeitung von Tuples in Funktionen (map)
                                                                                                                                                                                                                                                                                                                                                  • Tuples wie HList (22 Schranke fällt)
                                                                                                                                                                                                                                                                                                                                                  • Übernahme von Shapeless Funktionen in die Sprache
                                                                                                                                                                                                                                                                                                                                                  • Vereinfachung
                                                                                                                                                                                                                                                                                                                                                    • Li Haoyis Blog lesen (Principle of least Power)
                                                                                                                                                                                                                                                                                                                                                    • infix Schreibweise vermeiden
                                                                                                                                                                                                                                                                                                                                                    • Bei Operatoren: @infix mit Beschreibung
                                                                                                                                                                                                                                                                                                                                                    • Donnerstag
                                                                                                                                                                                                                                                                                                                                                      • Keynote: Scala Center
                                                                                                                                                                                                                                                                                                                                                        • Non Profit Organization
                                                                                                                                                                                                                                                                                                                                                        • Online Kurse
                                                                                                                                                                                                                                                                                                                                                        • scaladex
                                                                                                                                                                                                                                                                                                                                                        • ScalaFiddle
                                                                                                                                                                                                                                                                                                                                                        • Protokolle auf Github verfügbar
                                                                                                                                                                                                                                                                                                                                                        • Roll your own Shapeless
                                                                                                                                                                                                                                                                                                                                                          • Miles hat keinen speziellen Scala Compiler
                                                                                                                                                                                                                                                                                                                                                          • Das Typsystem kann viel mehr als ich dachte
                                                                                                                                                                                                                                                                                                                                                          • lesbar ist das ganze nicht
                                                                                                                                                                                                                                                                                                                                                          • akka.js
                                                                                                                                                                                                                                                                                                                                                            • akka für Scala.js
                                                                                                                                                                                                                                                                                                                                                            • bisher ohne akka remote
                                                                                                                                                                                                                                                                                                                                                            • verwendet akka als Git subproject
                                                                                                                                                                                                                                                                                                                                                            • Principles of elegance
                                                                                                                                                                                                                                                                                                                                                              • Was Elegant ist, ist Ansichtssache
                                                                                                                                                                                                                                                                                                                                                              • Acht Prinzipien
                                                                                                                                                                                                                                                                                                                                                              • Zum Naming: Verweis auf Li Haoyis Blog
                                                                                                                                                                                                                                                                                                                                                              • Reactive Microservices with akka and Docker
                                                                                                                                                                                                                                                                                                                                                                • einfaches Deployment von Aktorsystemen in Docker Container mit sbt-native-packager
                                                                                                                                                                                                                                                                                                                                                                • Beeing creative with type classes and genetic algorithm
                                                                                                                                                                                                                                                                                                                                                                  • Type classes bieten eine alternative zu Vererbung
                                                                                                                                                                                                                                                                                                                                                                  • Man kann lange an der Mona Lisa rechnen
                                                                                                                                                                                                                                                                                                                                                                  • @inline and @specialized
                                                                                                                                                                                                                                                                                                                                                                    • Tool: JITWatch
                                                                                                                                                                                                                                                                                                                                                                    • @inline erfordert scalac ‑optimize
                                                                                                                                                                                                                                                                                                                                                                    • @inline bringt nichts
                                                                                                                                                                                                                                                                                                                                                                    • @specialized vermeidet boxing, generiert aber mehr Klassen. Bringt nur in bestimmten Situationen was.
                                                                                                                                                                                                                                                                                                                                                                    • Freitag
                                                                                                                                                                                                                                                                                                                                                                      • Keynote: Postcapitalism
                                                                                                                                                                                                                                                                                                                                                                      • Typelevel

                                                                                                                                                                                                                                                                                                                                                                        • Jede Menge Projekte
                                                                                                                                                                                                                                                                                                                                                                        • Meet-Ups/Hacking bei Konferenzen
                                                                                                                                                                                                                                                                                                                                                                        • Arbeit am Scala Fork aufgegeben, stattdessen soll mehr direkt geändert werden über PRs
                                                                                                                                                                                                                                                                                                                                                                        • Deep Dive into Scala.js Internals
                                                                                                                                                                                                                                                                                                                                                                          • Compiler Plugin: > 5000 Zeilen Code (a bunch of crazy stuff)
                                                                                                                                                                                                                                                                                                                                                                          • Optimizer
                                                                                                                                                                                                                                                                                                                                                                            • ähnlich groß (> 4400 Zeilen)
                                                                                                                                                                                                                                                                                                                                                                            • Single Pass
                                                                                                                                                                                                                                                                                                                                                                            • Macht alles anders als an den Universitäten gelehrt
                                                                                                                                                                                                                                                                                                                                                                            • Beispiel: Umwandlung von Multiplikationen in Bit-Shift Operationen
                                                                                                                                                                                                                                                                                                                                                                            • Metaprogramming 2.0
                                                                                                                                                                                                                                                                                                                                                                              • Version 1.0 ist jetzt verfügbar
                                                                                                                                                                                                                                                                                                                                                                              • Weniger Boilerplate Code notwendig
                                                                                                                                                                                                                                                                                                                                                                              • Async Testing on the JVM and Scala.js
                                                                                                                                                                                                                                                                                                                                                                                • Notwendig für Scala.js
                                                                                                                                                                                                                                                                                                                                                                                • Alle Style traits (z.B. FunSpec) gibt es jetzt auch in einer Async-Variante
                                                                                                                                                                                                                                                                                                                                                                                • Links
                                                                                                                                                                                                                                                                                                                                                                                  • YouTube Channel
                                                                                                                                                                                                                                                                                                                                                                                  • Scaladex

                                                                                                                                                                                                                                                                                                                                                                                    Der Scala Library Index jetzt online. Hier werden Scala-Libraries getaggt aufgelistet. Somit erhält man einen guten Überblick populärer Bibliotheken zu unterschiedlichen Themen.

                                                                                                                                                                                                                                                                                                                                                                                    Scaladex ist eine der ersten Initiativen des Scala Centers.

                                                                                                                                                                                                                                                                                                                                                                                    Links
                                                                                                                                                                                                                                                                                                                                                                                    • Scaladex
                                                                                                                                                                                                                                                                                                                                                                                    • Scala Center
                                                                                                                                                                                                                                                                                                                                                                                    • Hörerfeedback

                                                                                                                                                                                                                                                                                                                                                                                      Paul Boschmann hat uns eine gute Eselsbrücke zu Either genannt:

                                                                                                                                                                                                                                                                                                                                                                                      Der Right-Part von Either enthält korrekte Werte (Right is right) und ins Left kommt der Rest: Errorcodes, Exceptions und sonstige Unwahrheiten. […] steht so tatsächlich in der Haskell-Doku drin.

                                                                                                                                                                                                                                                                                                                                                                                      Sommerpause

                                                                                                                                                                                                                                                                                                                                                                                      Wir verabschieden uns in die Sommerpause. Die nächste Episode gibt es voraussichtlich im September.

                                                                                                                                                                                                                                                                                                                                                                                      Gib uns Dein Feedback als Kommentar auf unserer Web-Site, via Twitter oder Google+.

                                                                                                                                                                                                                                                                                                                                                                                      Kapitel
                                                                                                                                                                                                                                                                                                                                                                                      1. Intro (00:00:00.000)
                                                                                                                                                                                                                                                                                                                                                                                      2. Wir suchen eine(n) Scala-Entwickler(in) (00:00:52.999)
                                                                                                                                                                                                                                                                                                                                                                                      3. ScalaDays 2016 in Berlin (00:02:25.368)
                                                                                                                                                                                                                                                                                                                                                                                      4. Keynote: Gegenwart und Zukunft von Scala (00:06:32.685)
                                                                                                                                                                                                                                                                                                                                                                                      5. Keynote: Scala Center (00:24:46.285)
                                                                                                                                                                                                                                                                                                                                                                                      6. Roll your own Shapeless (00:32:12.867)
                                                                                                                                                                                                                                                                                                                                                                                      7. akka.js (00:35:17.272)
                                                                                                                                                                                                                                                                                                                                                                                      8. Principles of elegance (00:38:09.773)
                                                                                                                                                                                                                                                                                                                                                                                      9. Reactive Microservices with akka and Docker (00:40:19.032)
                                                                                                                                                                                                                                                                                                                                                                                      10. Beeing creative with type classes and genetic algorithm (00:41:45.336)
                                                                                                                                                                                                                                                                                                                                                                                      11. @inline and @specialized (00:46:04.493)
                                                                                                                                                                                                                                                                                                                                                                                      12. Keynote: Postcapitalism (00:52:14.061)
                                                                                                                                                                                                                                                                                                                                                                                      13. Typelevel (was aus dem geplanten Scala-Fork geworden ist) (00:53:55.437)
                                                                                                                                                                                                                                                                                                                                                                                      14. Deep Dive into Scala.js Internals (00:58:22.968)
                                                                                                                                                                                                                                                                                                                                                                                      15. Metaprogramming 2.0 (01:02:16.867)
                                                                                                                                                                                                                                                                                                                                                                                      16. Async Testing on the JVM and Scala.js (01:05:15.413)
                                                                                                                                                                                                                                                                                                                                                                                      17. Welche Vorträge soll ich mir anschauen? (01:09:37.137)
                                                                                                                                                                                                                                                                                                                                                                                      18. Hörerfeedback: Eselsbrücke für Either (01:11:13.432)
                                                                                                                                                                                                                                                                                                                                                                                      19. Verabschiedung in die Sommerpause (01:12:59.264)
                                                                                                                                                                                                                                                                                                                                                                                      20. Lizenz


                                                                                                                                                                                                                                                                                                                                                                                        Scala Profis von Benjamin Hagemeister & Sven Wiegand ist lizenziert unter einer Creative Commons Namensnennung — Keine Bearbeitungen 4.0 International Lizenz.

                                                                                                                                                                                                                                                                                                                                                                                        Über diese Lizenz hinausgehende Erlaubnisse kannst Du unter http://scalaprofis.de erhalten.

                                                                                                                                                                                                                                                                                                                                                                                        Titelsong basierend auf Wish You Were Here von THE.MADPIX.PROJECT lizensiert unter Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0).

                                                                                                                                                                                                                                                                                                                                                                                        1 hr 16 min
                                                                                                                                                                                                                                                                                                                                                                                      21. SP05/16: Scala.js, Gradle vs. SBT

                                                                                                                                                                                                                                                                                                                                                                                        Änderungen beim ScalaProfis-Podcast

                                                                                                                                                                                                                                                                                                                                                                                        »Alles neu macht der Mai«. In diesem Sinne haben wir ein paar kleinere Anpassungen vorgenommen:

                                                                                                                                                                                                                                                                                                                                                                                        • Die Episoden werden nun nicht mehr fortlaufend, sondern nach Jahr und Monat nummeriert — das ist unserer Meinung nach hilfreicher, da man die Episode gleich zeitlich einordnen kann.
                                                                                                                                                                                                                                                                                                                                                                                        • Auf der Übersichtsseite werden nur noch die Themen der jeweiligen Episode aufgeführt.
                                                                                                                                                                                                                                                                                                                                                                                        • Unterabschnitte der Show-Notes einer Episode sind jetzt besser als solche erkennbar.
                                                                                                                                                                                                                                                                                                                                                                                        • Zu viele Kanäle machen die Pflege aufwändig. Daher konzentrieren wir uns auf Twitter und stellen die Google+ Seite ein.
                                                                                                                                                                                                                                                                                                                                                                                        • ScalaJS

                                                                                                                                                                                                                                                                                                                                                                                          Sven hat sich mit ScalaJS beschäftigt.

                                                                                                                                                                                                                                                                                                                                                                                          Warum nicht direkt JavaScript?

                                                                                                                                                                                                                                                                                                                                                                                          Für jemanden, der statisch typisierte, mächtige Sprachen gewöhnt ist, ist das Programmieren in JavaScript kein Vergnügen:

                                                                                                                                                                                                                                                                                                                                                                                          • die Auto-Completion in der IDE schlägt entweder nichts oder dutzende von (an dieser Stelle nicht relevanten) Feldern/Methoden vor
                                                                                                                                                                                                                                                                                                                                                                                          • selbst simple Refactorings wie Umbenennungen erfordern viel Handarbeit — je allgemeiner der ursprüngliche Name, desto schlimmer
                                                                                                                                                                                                                                                                                                                                                                                          • keine sinnvolle Modularisierung
                                                                                                                                                                                                                                                                                                                                                                                          • umständliche Erstellung von Klassen
                                                                                                                                                                                                                                                                                                                                                                                          • ungewohntes Sprachverhalten (Scope lokaler Variablen)
                                                                                                                                                                                                                                                                                                                                                                                          • keine Immutability
                                                                                                                                                                                                                                                                                                                                                                                          • geschwätzige Syntax (zumindest im Vergleich zu Scala)
                                                                                                                                                                                                                                                                                                                                                                                          • Einiges wird mit ECMAScript 6 besser (Module, Arrow-Syntax für Funktionen, Klassen, let-Deklarationen für »korrektes« Scoping, const). In der Realität kommt man aber um einen ES6-nach-ES5-Transpiler wie Babel nicht herum.

                                                                                                                                                                                                                                                                                                                                                                                            Was für Alternativen gibt es zu JavaScript?

                                                                                                                                                                                                                                                                                                                                                                                            Wenn man eh einen Transpiler nutzt kann man auch gleich eine brauchbare Programmiersprache nehmen. Folgende Alternativen habe ich mir angeschaut:

                                                                                                                                                                                                                                                                                                                                                                                            • CoffeeScript: Dynamisch, bringt somit nur marginale Verbesserungen, dafür ohne Runtime-Overhead (Library)
                                                                                                                                                                                                                                                                                                                                                                                            • TypeScript: Sehr populär, statisch typisiert, erfordert somit Fassaden (für viele Libraries verfügbar), nicht sonderlich mächtig, kaum Runtime-Overhead
                                                                                                                                                                                                                                                                                                                                                                                            • Kotlin: JavaScript-Generierung von Anfang an vorgesehen, schmale Standard-Library, aber noch nicht verfügbar
                                                                                                                                                                                                                                                                                                                                                                                            • Scala.js: Volle Mächtigkeit von Scala zum Preis großer Runtime-Artefakte
                                                                                                                                                                                                                                                                                                                                                                                            • Entscheidung für Scala.js

                                                                                                                                                                                                                                                                                                                                                                                              Maßgeblich war für mich die geplante Förderung von Scala.js durch das Scala Center — das suggeriert Ernsthaftigkeit und Zukunftssicherheit.

                                                                                                                                                                                                                                                                                                                                                                                              Ebenfalls interessant: Code-Sharing zwischen Frontend und Backend (ist natürlich via Node.js auch mit JavaScript möglich).

                                                                                                                                                                                                                                                                                                                                                                                              Wie funktioniert Scala.js

                                                                                                                                                                                                                                                                                                                                                                                              Scala.js ist im Wesentlichen ein Compile-Plug-In, das den Scala AST (der zuvor den größten Teil der Scala-To-JVM-Pipeline durchlaufen hat und dem entsprechend vereinfacht ist) in einen JavaScript AST übersetzt (Link).

                                                                                                                                                                                                                                                                                                                                                                                              Zum Zugriff auf JavaScript-Funktionen werden Fassaden benötigt. Die besorgt man sich entweder fertig oder man erstellt sie einfach selbst:

                                                                                                                                                                                                                                                                                                                                                                                              @js.native
                                                                                                                                                                                                                                                                                                                                                                                              trait Window extends js.Object {
                                                                                                                                                                                                                                                                                                                                                                                              val document: HTMLDocument = js.native
                                                                                                                                                                                                                                                                                                                                                                                              var location: String = js.native
                                                                                                                                                                                                                                                                                                                                                                                              def innerWidth: Int = js.native
                                                                                                                                                                                                                                                                                                                                                                                              def innerHeight: Int = js.native
                                                                                                                                                                                                                                                                                                                                                                                              def alert(message: String): Unit = js.native
                                                                                                                                                                                                                                                                                                                                                                                              def open(url: String, target: String,
                                                                                                                                                                                                                                                                                                                                                                                              features: String = ""): Window = js.native
                                                                                                                                                                                                                                                                                                                                                                                              def close(): Unit = js.native
                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                              @js.native
                                                                                                                                                                                                                                                                                                                                                                                              object GlobalDomDefinition extends js.GlobalScope {
                                                                                                                                                                                                                                                                                                                                                                                              val window: Window = js.native
                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                              Um Scala-Klassen aus JavaScript nutzbar zu machen müssen diese exportiert werden:

                                                                                                                                                                                                                                                                                                                                                                                              @JSExport
                                                                                                                                                                                                                                                                                                                                                                                              class Foo(val x: Int) {
                                                                                                                                                                                                                                                                                                                                                                                              @JSExport
                                                                                                                                                                                                                                                                                                                                                                                              def square(): Int = x*x // note the (), omitting them has a different behavior
                                                                                                                                                                                                                                                                                                                                                                                              @JSExport("foobar")
                                                                                                                                                                                                                                                                                                                                                                                              def add(y: Int): Int = x+y
                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                              Was geht nicht?

                                                                                                                                                                                                                                                                                                                                                                                              Es kann fast alles genutzt werden, was Scala bietet. Ausgeschlossen sind im Wesentlichen Reflection-basierte Funktionalitäten.

                                                                                                                                                                                                                                                                                                                                                                                              Wie sieht’s mit Performance und Overhead aus?

                                                                                                                                                                                                                                                                                                                                                                                              Um die Performance zu testen hat das Scala.js-Team einen Benchmark nach Scala.js überführt und die Ergebnisse auf der Scala.js-Seite veröffentlicht. Extrakt: Die Ausführung via Scala.js lag je nach Anwendungsfall 10 bis 20% über der nativen JavaScript-Lösung.

                                                                                                                                                                                                                                                                                                                                                                                              Ausnahme: Bei einem Collection-lastigen Test hat die Nutzung der Scala-Collections die Ausführungszeit um den Faktor 2.2 steigen lassen. Nachdem der Benchmark auf die Nutzung von JavsScript-Arrays umgestellt wurde, war der Benchmark wieder nur ca. 20% langsamer.

                                                                                                                                                                                                                                                                                                                                                                                              Was die Größe des resultierenden JavaScripts angeht: Während der Entwicklung wird zugunsten der Turnaround-Zeiten eine schnelle Optimierung durchgeführt. Ein einfaches AngularJS-Projekt hatte hier bei mir ca. 1 MB Größe. Der Release-Build wird unter Einsatz des Google Closure-Compilers größenoptimiert und lieferte bei mir 196 kB.

                                                                                                                                                                                                                                                                                                                                                                                              Aber Achtung: Der Google Closure Compiler macht die Anwendung wieder etwas langsamer.

                                                                                                                                                                                                                                                                                                                                                                                              Aufbau eines Scala.js-Projekts

                                                                                                                                                                                                                                                                                                                                                                                              Scala.js-Projekte werden mit SBT erstellt. Dabei kommen drei Source-Verzeichnisse zum Einsatz:

                                                                                                                                                                                                                                                                                                                                                                                              • jvm: Scala-Sourcen hin, die nur für die JVM compiliert werden
                                                                                                                                                                                                                                                                                                                                                                                              • js: Scala-Sourcen, die nur nach JavaScript compiliert werden
                                                                                                                                                                                                                                                                                                                                                                                              • shared: Scala-Sourcen, die von jvm- und js-Sourcen genutzt werden können — diese werden also sowohl für die JVM als auch für JavaScript compiliert.
                                                                                                                                                                                                                                                                                                                                                                                              • Ich habe Scala.js in einem Play-Projekt genutzt.

                                                                                                                                                                                                                                                                                                                                                                                                Testing & Debugging

                                                                                                                                                                                                                                                                                                                                                                                                ScalaTest 3 bringt als Haupt-Feature die Unterstützung für Scala.js — somit können die Tests mit einem bewährten Framework geschrieben werden.

                                                                                                                                                                                                                                                                                                                                                                                                Debugging im Browser funktioniert, da Scala.js Source-Maps generiert. Durch die Optimierung, sind allerdings teilweise Variablen nicht verfügbar und auf diversen Source-Zeilen können keine Breakpoints gesetzt werden. Evtl. müsste man mal probieren die Fast-Optimization im Entwicklungsprozess zu deaktivieren.

                                                                                                                                                                                                                                                                                                                                                                                                Erfahrungen

                                                                                                                                                                                                                                                                                                                                                                                                Mit Scala.js macht Frontend-Entwicklung endlich Spaß und wird produktiv! Wenn Fehler auftreten kann die Suche nach der Ursache aufwändig werden, aber wie immer hilft Erfahrung hier weiter.

                                                                                                                                                                                                                                                                                                                                                                                                Aufgrund des Overheads, den die Standard-Library produziert, ist Scala.js sicherlich nicht zum Aufwerten einer normalen Web-Seite geeignet. Geht es aber um eine vollwertige Web-Applikation, mit der sich der Anwender längere Zeit beschäftigt, steht in meinen Augen einer Nutzung in Produktivsystemen nichts mehr im Wege.

                                                                                                                                                                                                                                                                                                                                                                                                Links
                                                                                                                                                                                                                                                                                                                                                                                                • Frontend to Backend: Everything is on Scala
                                                                                                                                                                                                                                                                                                                                                                                                • Hands-on Scala.js (freies »eBook«)
                                                                                                                                                                                                                                                                                                                                                                                                • Scala-Js-Fiddle
                                                                                                                                                                                                                                                                                                                                                                                                • Gradle vs. SBT
                                                                                                                                                                                                                                                                                                                                                                                                  Gradle
                                                                                                                                                                                                                                                                                                                                                                                                  • In Groovy geschriebene DSL für Build-System
                                                                                                                                                                                                                                                                                                                                                                                                  • Plug-Ins können in jeder JVM Sprache geschrieben werden (also auch in Scala)
                                                                                                                                                                                                                                                                                                                                                                                                  • Convention over Configuration
                                                                                                                                                                                                                                                                                                                                                                                                  • Hervorragende Dokumentation
                                                                                                                                                                                                                                                                                                                                                                                                  • Ant-Tasks können direkt aus Gradle aufgerufen werden
                                                                                                                                                                                                                                                                                                                                                                                                  • Installation

                                                                                                                                                                                                                                                                                                                                                                                                    Gradle muss nicht von allen Entwicklern installiert werden. Wenn ein Projekt neu aufgesetzt wird kann ein Entwickler der Gradle

                                                                                                                                                                                                                                                                                                                                                                                                    installiert hat den Gradle-Wrapper erzeugen. Der Gradle-Wrapper wird dann zusammen mit dem restlichen Code im Repository abgelegt
                                                                                                                                                                                                                                                                                                                                                                                                    und kann von allen anderen Entwicklern direkt verwendet werden.

                                                                                                                                                                                                                                                                                                                                                                                                    Die konkrete Version ist dann Build-Skript festgelegt und wird bei der ersten Verwendung runter geladen.

                                                                                                                                                                                                                                                                                                                                                                                                    Definieren von Abhängigkeiten
                                                                                                                                                                                                                                                                                                                                                                                                    scalaMajorVersion = 2.10
                                                                                                                                                                                                                                                                                                                                                                                                    scalaVersion = 2.10.5
                                                                                                                                                                                                                                                                                                                                                                                                    dependencies {
                                                                                                                                                                                                                                                                                                                                                                                                    compile "org.scala-lang:scala-library:$scalaVersion"
                                                                                                                                                                                                                                                                                                                                                                                                    compile "org.scala-lang:scala-reflect:$scalaVersion"
                                                                                                                                                                                                                                                                                                                                                                                                    compile("com.escalatesoft.subcut:subcut_$scalaMajorVersion:2.0") {
                                                                                                                                                                                                                                                                                                                                                                                                    exclude module: 'scala-compiler'
                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                    Definieren von Tasks
                                                                                                                                                                                                                                                                                                                                                                                                    task taskA << {
                                                                                                                                                                                                                                                                                                                                                                                                    println("Hello Gradle!")
                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                    Etwas komplizierter:

                                                                                                                                                                                                                                                                                                                                                                                                    task taskA {
                                                                                                                                                                                                                                                                                                                                                                                                    description "Gibt 'Hello Gradle!' aus"
                                                                                                                                                                                                                                                                                                                                                                                                    doLast {
                                                                                                                                                                                                                                                                                                                                                                                                    println("Hello Gradle!")
                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                    Aufrufen von anderen Tasks

                                                                                                                                                                                                                                                                                                                                                                                                    Aus einem Gradle-Task heraus können andere Tasks nicht direkt ausgeführt werden. Das geht nur indirekt über Abhängigkeiten:

                                                                                                                                                                                                                                                                                                                                                                                                    task taskA {
                                                                                                                                                                                                                                                                                                                                                                                                    ...
                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                    task taskB {
                                                                                                                                                                                                                                                                                                                                                                                                    ...
                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                    task taskC {
                                                                                                                                                                                                                                                                                                                                                                                                    dependsOn(taskA, taskB)
                                                                                                                                                                                                                                                                                                                                                                                                    ...
                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                    Wenn sichergestellt werden muss, dann beim Aufruf von Task C erst A und dann B ausgeführt wird kann entweder noch eine Abhängigkeit

                                                                                                                                                                                                                                                                                                                                                                                                    von Task B zu Task eingerichtet werden

                                                                                                                                                                                                                                                                                                                                                                                                    taskB.dependsOn taskA

                                                                                                                                                                                                                                                                                                                                                                                                    oder (z.B. wenn Task B auch unabängig von Task A ausgeführt werden kann) über mustRunAfter eine Reihennfolge festgelegt werden:

                                                                                                                                                                                                                                                                                                                                                                                                    taskB.mustRunAfter taskA
                                                                                                                                                                                                                                                                                                                                                                                                    Zugriff auf Einstellungen
                                                                                                                                                                                                                                                                                                                                                                                                    task printMainTargetDirectory << {
                                                                                                                                                                                                                                                                                                                                                                                                    println(sourceSets.main.output.classesDir)
                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                    Solange man den Namen kennt kann man dynamisch auf jede Einstellung zugreifen. Allerdings ist das nicht typsicher und Tippfehler

                                                                                                                                                                                                                                                                                                                                                                                                    fallen auch erst zur Laufzeit auf.

                                                                                                                                                                                                                                                                                                                                                                                                    SBT
                                                                                                                                                                                                                                                                                                                                                                                                    • In Scala geschriebene DSL für Build-Systeme (wobei Benjamin findet, dass SBT eher eine API als eine DSL ist)
                                                                                                                                                                                                                                                                                                                                                                                                    • Convention over Configuration
                                                                                                                                                                                                                                                                                                                                                                                                    • Sehr gute Unterstützung von inkrementeller Compilierung
                                                                                                                                                                                                                                                                                                                                                                                                    • Man arbeitet in einer Konsole, so dass nicht für jeden Befehl die Build-Skripte neu kompiliert werden müssen
                                                                                                                                                                                                                                                                                                                                                                                                    • Cross-Compile für verschiedene Scala Versionen
                                                                                                                                                                                                                                                                                                                                                                                                    • Installation

                                                                                                                                                                                                                                                                                                                                                                                                      SBT muss nicht installiert werden. Auf der Homepage kann man sich ein sehr schlankes Paket runterladen, dass so wie der Gradle-Wrapper

                                                                                                                                                                                                                                                                                                                                                                                                      nur die unbendingt notwendigen Dateien enthält und den notwendigen Rest bei Bedarf nach lädt. Dieses Paket kann man auch im Repository
                                                                                                                                                                                                                                                                                                                                                                                                      ablegen.

                                                                                                                                                                                                                                                                                                                                                                                                      Die in einem Projekt verwendete SBT Version wird in project/build.properties definiert.

                                                                                                                                                                                                                                                                                                                                                                                                      Definieren von Abhängigkeiten
                                                                                                                                                                                                                                                                                                                                                                                                      scalaVersion in Global := "2.10.5"
                                                                                                                                                                                                                                                                                                                                                                                                      libraryDependencies ++= Seq(
                                                                                                                                                                                                                                                                                                                                                                                                      "org.scala-lang" % "scala-library" % scalaVersion.value,
                                                                                                                                                                                                                                                                                                                                                                                                      "org.scala-lang" % "scala-reflect" % scalaVersion.value,
                                                                                                                                                                                                                                                                                                                                                                                                      "com.escalatesoft.subcut" %% "subcut" % "2.0" exclude("org.scala-lang", "scala-compiler")
                                                                                                                                                                                                                                                                                                                                                                                                      )
                                                                                                                                                                                                                                                                                                                                                                                                      Definieren von Tasks
                                                                                                                                                                                                                                                                                                                                                                                                      val taskA = taskKey[Unit]("Gibt 'Hello sbt!' aus")
                                                                                                                                                                                                                                                                                                                                                                                                      taskA := {
                                                                                                                                                                                                                                                                                                                                                                                                      println("Hello sbt!")
                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                      Aufrufen von anderen Tasks
                                                                                                                                                                                                                                                                                                                                                                                                      val taskA = taskKey[Unit]("...")
                                                                                                                                                                                                                                                                                                                                                                                                      val taskB = taskKey[Unit]("...")
                                                                                                                                                                                                                                                                                                                                                                                                      val taskC = taskKey[Unit]("...")
                                                                                                                                                                                                                                                                                                                                                                                                      taskC := {
                                                                                                                                                                                                                                                                                                                                                                                                      taskA.value
                                                                                                                                                                                                                                                                                                                                                                                                      taskB.value
                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                      Anders als man denken könnte führt taskC damit aber nicht taskA und taskB in der angegebenen Reihennfolge aus — zumindest

                                                                                                                                                                                                                                                                                                                                                                                                      nicht solange es keine Abhängigkeiten zwischen den Tasks gibt. SBT führt die Tasks parallel aus und abhängig von den Tasks
                                                                                                                                                                                                                                                                                                                                                                                                      und eventuellen Abhängigkeiten zu anderen Tasks kann es sogar sein, dass taskB vor taskA ausgeführt wird.

                                                                                                                                                                                                                                                                                                                                                                                                      Wenn man eine bestimmte Reihenfolge erzwingen will kann man das wie bei Gradle über Abhängigkeiten machen oder über Def.sequential:

                                                                                                                                                                                                                                                                                                                                                                                                      val taskA = taskKey[Unit]("...")
                                                                                                                                                                                                                                                                                                                                                                                                      val taskB = taskKey[Unit]("...")
                                                                                                                                                                                                                                                                                                                                                                                                      val taskC = taskKey[Unit]("...")
                                                                                                                                                                                                                                                                                                                                                                                                      taskA := ...
                                                                                                                                                                                                                                                                                                                                                                                                      taskB := ...
                                                                                                                                                                                                                                                                                                                                                                                                      taskC := Def.sequential(taskA, taskB).value
                                                                                                                                                                                                                                                                                                                                                                                                      Zugriff auf Einstellungen
                                                                                                                                                                                                                                                                                                                                                                                                      val printMainTargetDirectory = taskKey[Unit]("Prints the main target directory")
                                                                                                                                                                                                                                                                                                                                                                                                      printMainTargetDirectory := println((classDirectory in Compile).value)

                                                                                                                                                                                                                                                                                                                                                                                                      Der Zugriff auf Einstellungen oder dem Rückgabewert einer Task erfolgt immer über .value. Das funktioniert aber nur innerhalb

                                                                                                                                                                                                                                                                                                                                                                                                      einer Task oder wenn man den Wert für eine andere Einstellung festlegt.

                                                                                                                                                                                                                                                                                                                                                                                                      Gradle vs. SBT
                                                                                                                                                                                                                                                                                                                                                                                                      Vorteile Gradle
                                                                                                                                                                                                                                                                                                                                                                                                      • Dokumentation
                                                                                                                                                                                                                                                                                                                                                                                                      • Einfacher Zugriff auf Einstellungen (allerdings nicht Typsicher)
                                                                                                                                                                                                                                                                                                                                                                                                      • Besser lesbarer und verständlicherer Code
                                                                                                                                                                                                                                                                                                                                                                                                      • Vorteile SBT
                                                                                                                                                                                                                                                                                                                                                                                                        • Konsole
                                                                                                                                                                                                                                                                                                                                                                                                        • Performance (insbesonders inkrementelles compilieren, ausführen der durch eine Änderung betroffenen Tests)
                                                                                                                                                                                                                                                                                                                                                                                                        • Typsicher
                                                                                                                                                                                                                                                                                                                                                                                                        • Ökosystem
                                                                                                                                                                                                                                                                                                                                                                                                        • Links
                                                                                                                                                                                                                                                                                                                                                                                                          • Gradle
                                                                                                                                                                                                                                                                                                                                                                                                          • SBT
                                                                                                                                                                                                                                                                                                                                                                                                          • Improving your project with SBT
                                                                                                                                                                                                                                                                                                                                                                                                          • Effective sbt
                                                                                                                                                                                                                                                                                                                                                                                                          • Scala Native

                                                                                                                                                                                                                                                                                                                                                                                                            Your favourite language gets closer to bare metal.

                                                                                                                                                                                                                                                                                                                                                                                                            Ahead-of-time-Compilierung für Scala inklusive Low-Level-Operationen wie Structs und Pointer und Interoperabilität mit C.

                                                                                                                                                                                                                                                                                                                                                                                                            Projekt vom EPFL.

                                                                                                                                                                                                                                                                                                                                                                                                            Link
                                                                                                                                                                                                                                                                                                                                                                                                            • Scala Native
                                                                                                                                                                                                                                                                                                                                                                                                            • Scala Compiler Hacking

                                                                                                                                                                                                                                                                                                                                                                                                              Miles Sabin hat in einem Blog erläutert wie er den PR für SI-2712 entwickelt hat.

                                                                                                                                                                                                                                                                                                                                                                                                              Links
                                                                                                                                                                                                                                                                                                                                                                                                              • Hacking on scalac
                                                                                                                                                                                                                                                                                                                                                                                                              • SI-2712
                                                                                                                                                                                                                                                                                                                                                                                                              • clippy

                                                                                                                                                                                                                                                                                                                                                                                                                Clippy ist ein SBT-Plugin, dass schwer verständliche Compiler-Fehler in verständliche übersetzt.

                                                                                                                                                                                                                                                                                                                                                                                                                Beispiel
                                                                                                                                                                                                                                                                                                                                                                                                                [error] TheNextFacebook.scala:16: type mismatch;
                                                                                                                                                                                                                                                                                                                                                                                                                [error] found : akka.http.scaladsl.server.StandardRoute
                                                                                                                                                                                                                                                                                                                                                                                                                [error] required: akka.stream.scaladsl.Flow[akka.http.scaladsl.model.HttpRequest,akka.http.scaladsl.model.HttpResponse,Any]
                                                                                                                                                                                                                                                                                                                                                                                                                [error] Http().bindAndHandle(r, "localhost", 8080)

                                                                                                                                                                                                                                                                                                                                                                                                                wird übersetzt in

                                                                                                                                                                                                                                                                                                                                                                                                                [error] Clippy advises: did you forget to define an implicit akka.stream.ActorMaterializer?
                                                                                                                                                                                                                                                                                                                                                                                                                [error] It allows routes to be converted into a flow.
                                                                                                                                                                                                                                                                                                                                                                                                                [error] You can read more at http://doc.akka.io/docs/akka-stream-and-http-experimental/2.0/scala/http/routing-dsl/index.html
                                                                                                                                                                                                                                                                                                                                                                                                                Links

                                                                                                                                                                                                                                                                                                                                                                                                                https://github.com/softwaremill/scala-clippy

                                                                                                                                                                                                                                                                                                                                                                                                                Einbetten von Dateiinhalten via Macro: Leider nicht praxistauglich

                                                                                                                                                                                                                                                                                                                                                                                                                Sven hatte von seiner Lösung geschwärmt, bei der Inhalte einer HTML-Datei via Macro als String eingebettet wurden. Leider ist diese Lösung nicht praxistauglich, da SBT die Abhängigkeit zwischen den beiden Sourcen nicht korrekt erkennt: Ändert sich die HTML-Datei, so erkennt SBT nicht, dass es die importierende Scala-Source-Datei neu kompilieren muss. Somit ist diese Lösung nicht praktisch einsetzbar.

                                                                                                                                                                                                                                                                                                                                                                                                                Expressions in string interpolation

                                                                                                                                                                                                                                                                                                                                                                                                                Unser Hörer Daniel Jentsch hat sich Svens Fragestellung aus der letzten Episode angenommen, wie man einen String-Interpolator erstellt, der nicht das Ergebnis eines Ausdrucks einbettet, sondern den Ausdruck selbst (um z.B. Reafctoring-sichere Templates im Umfeld von Scala.js zu erstellen).

                                                                                                                                                                                                                                                                                                                                                                                                                Das Ergebnis findet Ihr im Artikel Expressions in string interpolation

                                                                                                                                                                                                                                                                                                                                                                                                                Libraray-Liste »Awesome Scala«

                                                                                                                                                                                                                                                                                                                                                                                                                Awesome Scala ist eine von der Community erstellte Liste von nützlichen Scala-Libraries, Frameworks und Software.

                                                                                                                                                                                                                                                                                                                                                                                                                Vielen Dank für den Tipp von Stefan Kaufmann.

                                                                                                                                                                                                                                                                                                                                                                                                                Gib uns Dein Feedback als Kommentar auf unserer Web-Site, via Twitter oder Google+.

                                                                                                                                                                                                                                                                                                                                                                                                                Kapitel
                                                                                                                                                                                                                                                                                                                                                                                                                1. Intro (00:00:00.000)
                                                                                                                                                                                                                                                                                                                                                                                                                2. Änderung beim ScalaProfis-Podcast (00:00:38.061)
                                                                                                                                                                                                                                                                                                                                                                                                                3. ScalaJS (00:03:07.939)
                                                                                                                                                                                                                                                                                                                                                                                                                4. Gradle vs. SBT (00:39:23.757)
                                                                                                                                                                                                                                                                                                                                                                                                                5. Scala Native (01:11:27.299)
                                                                                                                                                                                                                                                                                                                                                                                                                6. Scala Compiler Hacking (01:13:24.547)
                                                                                                                                                                                                                                                                                                                                                                                                                7. Clippy (01:14:23.267)
                                                                                                                                                                                                                                                                                                                                                                                                                8. Einbetten von Dateiinhalten via Macro (01:16:44.856)
                                                                                                                                                                                                                                                                                                                                                                                                                9. Expressions in string interpolation (01:18:40.792)
                                                                                                                                                                                                                                                                                                                                                                                                                10. Library-Liste »»Awesome Scala (01:19:55.267)
                                                                                                                                                                                                                                                                                                                                                                                                                11. Closer (01:21:12.978)
                                                                                                                                                                                                                                                                                                                                                                                                                12. Lizenz


                                                                                                                                                                                                                                                                                                                                                                                                                  Scala Profis von Benjamin Hagemeister & Sven Wiegand ist lizenziert unter einer Creative Commons Namensnennung — Keine Bearbeitungen 4.0 International Lizenz.

                                                                                                                                                                                                                                                                                                                                                                                                                  Über diese Lizenz hinausgehende Erlaubnisse kannst Du unter http://scalaprofis.de erhalten.

                                                                                                                                                                                                                                                                                                                                                                                                                  Titelsong basierend auf Wish You Were Here von THE.MADPIX.PROJECT lizensiert unter Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0).

                                                                                                                                                                                                                                                                                                                                                                                                                  1 hr 23 min
                                                                                                                                                                                                                                                                                                                                                                                                                13. SP005: Macros, Compiler und Web-Geschichten

                                                                                                                                                                                                                                                                                                                                                                                                                  Erste Erfahrungen mit Macros

                                                                                                                                                                                                                                                                                                                                                                                                                  Endlich hat Sven selber Erfahrungen mit Macros gesammelt. Auslöser waren erste Gehversuche mit Scala.js zur Umsetzung eines AngularJS-Projekts auf Basis von scalajs-angular.

                                                                                                                                                                                                                                                                                                                                                                                                                  Scala.js bietet nahezu alle Möglichkeiten von Scala, aber Reflection gehört nicht dazu. Probleme, die in Java üblicherweise über Reflection gelöst werden, lassen sich in Scala.js aber mit Macros meist eleganter und vor Allem zur Compilier-Zeit lösen.

                                                                                                                                                                                                                                                                                                                                                                                                                  scalajs-angular definiert zum Beispiel eine @injectable-Annotation um in Scala.js geschriebenen Komponenten den von Angular für Dependency-Injection benötigten Namen zuzuweisen. Darauf basierend hat Sven einige nützliche Macros erstellt:

                                                                                                                                                                                                                                                                                                                                                                                                                  • Methode um sich vom Injector eine Instanz eines Typs liefern zu lassen ohne manuell den Namen angeben und dann auch noch explizit casten zu müssen (PR #79)
                                                                                                                                                                                                                                                                                                                                                                                                                  • Methoden relativeTemplate und companionTemplate, um in HTML-Dateien abgelegte Templates zur Compile-Zeit als String einbetten zu können (PR #83)
                                                                                                                                                                                                                                                                                                                                                                                                                  • Erfahrungen
                                                                                                                                                                                                                                                                                                                                                                                                                    • Wenn man eine Vorlage hat ist die Erstellung eines Makros mit reify oder Quasiquotes relativ einfach.
                                                                                                                                                                                                                                                                                                                                                                                                                    • Ohne Vorlage ein Macro zu erstellen ist für mich weiterhin schwierig.
                                                                                                                                                                                                                                                                                                                                                                                                                    • Auch nach dem Schreiben erschließen mir sich diverse Aspekte nicht (Beispiel splice) — hier ist wohl doch ein tiefergreifendes Verständnis des ASTs und der zugehörigen API notwendig. Gibt es da irgendwo eine brauchbar Beschreibung?
                                                                                                                                                                                                                                                                                                                                                                                                                    • Macros können nur auf Objekten definiert werden — nicht auf Klassen. Um auf Instanzen zu operieren sind also Hilfs-Objekte notwendig — implizite Parameter können die Nutzung vereinfachen.
                                                                                                                                                                                                                                                                                                                                                                                                                    • Die notwendige Verteilung von Macros und Nutzung auf zwei Projekte macht die Erstellung von Libraries mit Komfort-Funktionen schwierig.
                                                                                                                                                                                                                                                                                                                                                                                                                    • Mehr zu meinen Erfahrungen mit Scala.js in der nächsten Episode.

                                                                                                                                                                                                                                                                                                                                                                                                                      SourceCode

                                                                                                                                                                                                                                                                                                                                                                                                                      Kleine Scala Bibliothek, die Zugriff auf Source-Code Informationen wie z.B. den Dateinamen oder der Zeile zur Laufzeit bietet. Die benötigten Objekte können dazu über implizite Parameter oder implicitly geholt werden.

                                                                                                                                                                                                                                                                                                                                                                                                                      User-Cases
                                                                                                                                                                                                                                                                                                                                                                                                                      • Logging
                                                                                                                                                                                                                                                                                                                                                                                                                      • def log(message: String)(implicit line sourcecode.Line, file sourcecode.File): Unit =
                                                                                                                                                                                                                                                                                                                                                                                                                        println(s"[${file.value}:${line.value}]: $message")
                                                                                                                                                                                                                                                                                                                                                                                                                      • Übernehmen von Namen
                                                                                                                                                                                                                                                                                                                                                                                                                      • val CREATION_DATE = newField("CREATION_DATE", ...)

                                                                                                                                                                                                                                                                                                                                                                                                                        =>

                                                                                                                                                                                                                                                                                                                                                                                                                        val CREATION_DATE = newField(...)
                                                                                                                                                                                                                                                                                                                                                                                                                      • Debug Ausgaben
                                                                                                                                                                                                                                                                                                                                                                                                                      • def log[A](value: sourcecode.Text[V])(implicit name sourcecode.Name): Unit =
                                                                                                                                                                                                                                                                                                                                                                                                                        println(s"${name.value}(${value.source} = ${value.value})")
                                                                                                                                                                                                                                                                                                                                                                                                                        def foo(arg: String): Unit = {
                                                                                                                                                                                                                                                                                                                                                                                                                        log(arg)
                                                                                                                                                                                                                                                                                                                                                                                                                        ...
                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                        foo("bar")

                                                                                                                                                                                                                                                                                                                                                                                                                        Gibt aus: foo(arg = bar)

                                                                                                                                                                                                                                                                                                                                                                                                                        Links

                                                                                                                                                                                                                                                                                                                                                                                                                        SourceCode

                                                                                                                                                                                                                                                                                                                                                                                                                        Dotty
                                                                                                                                                                                                                                                                                                                                                                                                                        • Compiliert den größten Teil er Scala Standard Library und eine handvoll anderer Projekte
                                                                                                                                                                                                                                                                                                                                                                                                                        • Ziel ist es einen neuen, schlanken Compiler zu erhalten, der sich deutlich leichter weiterentwickeln lässt (wie der Roslyn Compiler für C#)
                                                                                                                                                                                                                                                                                                                                                                                                                        • Das Vorgehen über einen experimentellen Compiler hat sich ebenfalls bei Roslyn bewährt (der übrigens laut eigenen Aussagen einiges von Scala übernommen hat)
                                                                                                                                                                                                                                                                                                                                                                                                                        • Ob dotty irgendwann scalac ablösen wird ist nicht klar — es kann auch sein, dass lediglich Erkenntnisse aus dotty nach scalac zurückfließen.
                                                                                                                                                                                                                                                                                                                                                                                                                        • Scala 2.12.0‑M4

                                                                                                                                                                                                                                                                                                                                                                                                                          Vervollständigt die Features von 2.12. Auffälligste Änderung ist der neue ScalaDoc-Style.

                                                                                                                                                                                                                                                                                                                                                                                                                          Es folgen M5 und danach RC1.

                                                                                                                                                                                                                                                                                                                                                                                                                          Scala 2.12 Features

                                                                                                                                                                                                                                                                                                                                                                                                                          In Scala 2.12 geht es im Wesentlichen darum die neuen Java 8 Features optimal zu nutzen:

                                                                                                                                                                                                                                                                                                                                                                                                                          • Traits zu Interfaces compilieren (bisher Klasse und Interface)
                                                                                                                                                                                                                                                                                                                                                                                                                          • Java 8‑styled Lambdas:
                                                                                                                                                                                                                                                                                                                                                                                                                            • Keine anonymen Klassen mehr und somit deutlich kleinere JARs.
                                                                                                                                                                                                                                                                                                                                                                                                                            • Bessere Java-Scala interoperabilität
                                                                                                                                                                                                                                                                                                                                                                                                                            • Neues Compiler-Backend arbeitet schneller
                                                                                                                                                                                                                                                                                                                                                                                                                            • Neuer Bytecode-Optimizer (unter anderem Inlining von final Methoden)
                                                                                                                                                                                                                                                                                                                                                                                                                            • Links
                                                                                                                                                                                                                                                                                                                                                                                                                              • Scala 2.12.0‑M4 is now available
                                                                                                                                                                                                                                                                                                                                                                                                                              • SI-2712
                                                                                                                                                                                                                                                                                                                                                                                                                                Links
                                                                                                                                                                                                                                                                                                                                                                                                                                • SI-2712
                                                                                                                                                                                                                                                                                                                                                                                                                                • Explaining Miles’s Magic
                                                                                                                                                                                                                                                                                                                                                                                                                                • Frontend Asset-Pipeline mit Play

                                                                                                                                                                                                                                                                                                                                                                                                                                  sbt-webverspricht mit Web-JARs die einfache Einbindung von JavaScript-Libraries und mit Plug-Ins einen einfachen Aufbau einer Frontend-Asset-Pipeline, um z.B. LESS- oder SASS-Dateien zu CSS zu compilieren, ES6-JavaScript nach ES5 zu compilieren, zu konkatenieren und zu minifizieren.

                                                                                                                                                                                                                                                                                                                                                                                                                                  In der Praxis klappt das leider nicht: Die sbt-web-Plug-Ins sind halbherzig umgesetzt:

                                                                                                                                                                                                                                                                                                                                                                                                                                  • Optionen fehlen oder funktionieren nicht wie versprochen
                                                                                                                                                                                                                                                                                                                                                                                                                                  • sinnvolle Verarbeitungsketten (z.B. mit der Erstellung von Source-Maps über mehrere Schritte hinweg) lassen sich gar nicht realisieren.
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Ausweg

                                                                                                                                                                                                                                                                                                                                                                                                                                    Mit sbt-web-Plug-Ins wie zum Beispiel sbt-play-gulp lässt sich eine Asset-Pipeline mit im JavaScript-Umfeld etablierten Build-Systemen (in diesem Fall GULP) aufbauen und in de Play-Lifecycle einbinden.

                                                                                                                                                                                                                                                                                                                                                                                                                                    ScalaCSS

                                                                                                                                                                                                                                                                                                                                                                                                                                    Scala Bibliothek zum Erzeugen von CSS, ähnlich wie LESS oder SASS, allerdings mit Scala-Code.

                                                                                                                                                                                                                                                                                                                                                                                                                                    Browser Prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                    Bei CSS-Attributen oder Funktionen bei denen für die verschiedenen Browser ein Prefix verwendet werden muss kümmert ScalaCSS sich automatisch darum die Prefixe für alle Browser gesetzt werden.

                                                                                                                                                                                                                                                                                                                                                                                                                                    Konflikterkennung
                                                                                                                                                                                                                                                                                                                                                                                                                                    // In MyGenericTheme.scala
                                                                                                                                                                                                                                                                                                                                                                                                                                    val button = style(margin(8 px, auto), ...)
                                                                                                                                                                                                                                                                                                                                                                                                                                    // In UserStyles.scala
                                                                                                                                                                                                                                                                                                                                                                                                                                    val userTitle = style(marginLeft(4 ex), ...)
                                                                                                                                                                                                                                                                                                                                                                                                                                    ...
                                                                                                                                                                                                                                                                                                                                                                                                                                    val userButton = style(button, userTitle, ...)

                                                                                                                                                                                                                                                                                                                                                                                                                                    ScalaCSS produziert hier auf Wunsch eine Warnung und es kann festgelegt werden, welcher Stil gewinnen soll.

                                                                                                                                                                                                                                                                                                                                                                                                                                    Links
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Github Seite
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Dokumentation
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Can I use…
                                                                                                                                                                                                                                                                                                                                                                                                                                    • scalatags
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Gib uns Dein Feedback als Kommentar auf unserer Web-Site, via Twitter oder Google+.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Kapitel
                                                                                                                                                                                                                                                                                                                                                                                                                                      1. Intro (00:00:00.000)
                                                                                                                                                                                                                                                                                                                                                                                                                                      2. Erste Erfahrungen mit Macros (00:01:10.249)
                                                                                                                                                                                                                                                                                                                                                                                                                                      3. SourceCode (00:23:53.474)
                                                                                                                                                                                                                                                                                                                                                                                                                                      4. Dotty (00:36:01.091)
                                                                                                                                                                                                                                                                                                                                                                                                                                      5. Scala 2.12.0‑M4 (00:45:53.588)
                                                                                                                                                                                                                                                                                                                                                                                                                                      6. SI-2712 (00:51:31.693)
                                                                                                                                                                                                                                                                                                                                                                                                                                      7. Frontend Asset-Pipeline mit Play (00:54:21.364)
                                                                                                                                                                                                                                                                                                                                                                                                                                      8. ScalaCSS (01:01:41.010)
                                                                                                                                                                                                                                                                                                                                                                                                                                      9. Outro (01:10:03.021)
                                                                                                                                                                                                                                                                                                                                                                                                                                      10. Lizenz


                                                                                                                                                                                                                                                                                                                                                                                                                                        Scala Profis von Benjamin Hagemeister & Sven Wiegand ist lizenziert unter einer Creative Commons Namensnennung — Keine Bearbeitungen 4.0 International Lizenz.

                                                                                                                                                                                                                                                                                                                                                                                                                                        Über diese Lizenz hinausgehende Erlaubnisse kannst Du unter http://scalaprofis.de erhalten.

                                                                                                                                                                                                                                                                                                                                                                                                                                        Titelsong basierend auf Wish You Were Here von THE.MADPIX.PROJECT lizensiert unter Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0).

                                                                                                                                                                                                                                                                                                                                                                                                                                        1 hr 13 min

                                                                                                                                                                                                                                                                                                                                                                                                                                      About Scala Profis

                                                                                                                                                                                                                                                                                                                                                                                                                                      From the publisher's feed

                                                                                                                                                                                                                                                                                                                                                                                                                                      Der Podcast rund um die Programmiersprache Scala