Josh Suereth, senior software engineer at Typesafe and author of Scala In Depth, kicks off the 2012 NEScala Symposium with a talk on general best practices in Scala. Josh reviews the basics and asks, "What is effective Scala?".
Topics addressed include immutability, style, composition and inheritance, limiting the scope of implicits (and watching out for the implicit cat). Following his keynote Josh engaged in a brief Q&A with the audience.
Most people have heard of ENSIME by now as the go-to mode for Scala editing in Emacs. This alone is quite awesome, but what you may *not* know is that ENSIME itself is entirely editor agnostic! This talk will briefly cover ENSIME, what it offers, how it works, how we talk to it, and what it means for you.
Generic (aka polytypic) programming involves parametrizing programs in terms of the "shape" of the data types they operate on, going beyond what's possible with simple type parametrization. In the Haskell world it's exemplified by Scrap your Boilerplate and related projects.
shapeless is an exploration of this space in Scala, and my talk shows some of its capabilities and applications and also explains some of the type class and dependent type based implementation techniques involved.
Martin Odersky didn't initially expect Scala to find a following in the field of machine learning because of machine learning's large appetite for memory and numeric computation. But the field is expanding in new ways, with interest in parallel and distributed computation, dynamically changing model structures, and the desire to put easy-to-use DSLs into the hands of non-experts. This talk will describe these trends and discuss several machine learning projects that use Scala, including FACTORIE, a 30k-line DSL for graphical models whose development is being sponsored by Google and the NSF.
We believe that one should never have to choose between productivity and scalability, which has been the case with traditional approaches to concurrency and distribution. The cause of that has been the wrong tools and the wrong layer of abstraction and Akka is here to change that. Akka is a unified runtime and programming model for scaling both UP (utilizing multi-core processors) and OUT (utilizing the grid/cloud). With Akka 2.0 this will be taken to a whole new level, "Distributed by Design".
Beginner-friendly talk introducing the concept of “typeclasses”. What are these “typeclass” things Scala people are always talking about? Where did they come from? How are they expressed in Scala? Are they in the Scala standard library? When might I want to use them instead of other kinds of polymorphism such as inheritance and overloading? (reprise of talk previously delivered at Boston Scala)
Apache Hadoop is the current darling of the "Big Data" world. Most Hadoop Applications are written in the low-level Java API or high-level languages like Hive (a SQL dialect). I examine how OOP and Java thinking is impacting the effectiveness of Hadoop, both the internals and the way you write applications. Using Scala examples from tools like Scrunch, Spark, and others, I demonstrate why functional programming is the way to improve internal efficiency and developer productivity. Finally, I look at the potential future role for Scala in Big Data
If web interaction is this century's version of running water, Unfiltered is a set of Scala pipes and wrenches that work with everything from Tomcat to Netty.
This talk will walk through the options for integrating Unfiltered with application servers big and small, old and new, before performing some live-plumbing for an NE Scala web service using the toolkit. (We'll do our best not to flood the conference hall.)
Even simpler than the Cake Pattern, more flexible than Guice, and more powerful than Spring, the ultimate tool in dependency injection is already built into Scala.
Asynchronous and non-Blocking network frameworks have become a big deal: tools like node.js and BlueEyes have set the pattern for new projects.
Many Scala developers don't understand these approaches though. In this talk I'll introduce Async/Non-Blocking IO and demonstrate both Netty & Raw NIO – and discuss strengths and weaknesses of each.
We'll also discuss patterns and concepts around this: The use of callbacks, Either[E, T] to pass errors, implicit tricks to simplify them and even the Iteratee pattern.
this talk is unsynchronized
Ever since it's first release, Akka has been receiving a lot of interest and praise from the Scala community. With a tagline promising to deliver "Event-driven, scalable and fault-tolerant architectures", who wouldn't want to use it? The framework does indeed deliver, but it's not a general purpose technology that can or should be applied anywhere. Dag starts off introducing us to Akka, then moves into real use cases, while addressing many of the strengths and potential pain points of the framework.
spray (www.spray.cc) is a suite of lightweight Scala libraries for building and consuming RESTful web services on top of Akka.
In this talk I'll show you how spray makes it easy to supply your Scala applications with a high-performance, fully asynchronous REST/HTTP API, no matter whether Akka is already a key component in your application stack or not. The talk will briefly highlight the design goals and key concepts behind spray before showing off one or more real-world examples as well as emerging best-practices with regard to architecture and development process.
IO is the trickiest of operations to tackle in a functional way. Try to make IO efficient, non-leaky, composable, and pure, and the problem becomes virtually unsolvable. In this talk, John A. De Goes, CTO of ReportGrid, discusses three different approaches to functional IO in Scala, beginning with iteratees, and continuing on to stream processors and transducers.
The Play framework revolutionized the Java Web application development by bringing back simplicity and agility contrasting the so-called standard way of writing enterprise applications. The whole Web architecture is fast moving towards real-time and emerging new requirements have put into question the classic assumptions like SQL as the exclusive datastore technology or the MVC application design. In this talk I will introduce Play 2.0, a Scala (and Java) Web application framework and its core concepts.
We investigate the facilities in various languages for higher-order programming-in-the-large. Scala developers often borrow from Haskell, but what more can we learn from the ML family? What about (heaven forbid) C++ and its template libraries? Do dynamically-typed languages enable more sophisticated code recombination and reuse? We'll ask these questions, answer some of them, and generally compare, contrast, and encode all sorts of modularity with Scala.
*The “modular module” moniker was lifted from a paper by Xavier Leroy.
Or: how to write a functional program with IO, mutation, and other effects.
Functional programming is all well and good for mapping over lists, generating the fibonacci numbers, and writing an inefficient version of quicksort, but what about the "programmers in the trenches"? You know, the ones creating CRUD applications, writing to databases, reading from files, and building GUIs with event listeners. Don't these situations require tossing out all that theoretical FP mumbo-jumbo and writing some good ol' fashioned imperative code? In this talk I'll show that FP has a lot to say about how to write and structure useful programs that perform arbitrary effects.