Your current filters are…
Come learn all about Behavior Driven Development and see it action to help define system behavior from the top level down to the unit level, describing the need for code to exist and then writing the code to meet that need. This will include a live demo of creating a complete feature from the outside and working our way in one piece at a time. Concepts demonstrated can be applied in other languages.
Scala is an intensely powerful language. One of the most obvious ways in which this manifests is the syntax, which is wonderfully amenable to internal DSLs and flexible APIs (not to mention endless reams of obfuscated sources and fanciful operators). However, despite the superficial flash of Scala's syntactic skin, its true power lies in the type system and in the language's deep semantic constructs.
This talk will dive into some of the more remote regions of the kingdom of Scala. Specifically, we will cover the following topics:
Higher-Kinds (what they are and how they can be applied)
Type-Level Encodings (*really* exploiting Scala's type system)
Typeclasses (just like Haskell...except not)
Delimited Continuations (and you thought kinds were confusing!)
Please note that this is an advanced talk targeted at the Scala practitioner who is already fairly comfortable with the language. With that said, we hope the talk will remain reasonably accessible to the Scala beginner - so long as they don't object to the presentation of odd and esoteric language features with disturbing enthusiasm.
by Bruce Tate
Every foreign language you learn makes you a little smarter, and even shapes the way you think. In the Pragmatic Programmer, Dave Thomas and Andy Hunt say that a developer should learn a new programming language every year. In the upcoming book Seven Languages in Seven Weeks, Bruce takes this challenging advice to the extreme. The book, in progress, helps a developer solve a nontrivial problem in each of seven different programming languages, spanning four different programming paradigms. In this talk, Bruce will take a light hearted look through the evolution of programming languages, paying special attention to the seven languages in his book, Ruby, Io, Prolog, Scala, Erlang, Clojure, and Haskell.
by Dean Wampler
Akka (akkasource.org) is a Scala and Java framework for building highly scalable, fault-tolerant applications. Akka is inspired by Erlang's OTP framework. It uses *Actors* as the primary concurrency mechanism, with support for fault tolerance through transactional actors ("transactors"), actor supervision and error recovery, distributed processing, and transactional state management using Clojure-style persistent data structures, with or without "durable" persistence from NoSQL data stores like MongoDB, Redis, and Cassandra.
Akka also provides convenient integration APIs to 3rd-party libraries for web applications, REST, messaging queues, security, Spring and Guice dependency injection, etc.
Using a live example, this session demonstrates the capabilities of Akka and the productivity you can enjoy while using it.
14th–15th October 2010