Home › Technical Talks

Technical Talks

Location: 
Polydôme, main hall
Date and time: 
Friday, April 16, 2010 - 13:45 - 15:25
 
  • sbt: Design and Implementation
    Mark Harrah

    sbt is a build tool for Scala. This talk is a look at the design and implementation of sbt, both in its role as a library for writing a build definition and as a build framework.
    The most visible aspect of sbt is its API for defining a build definition. Build files use several DSLs, such as when constructing sets of files, forking and piping external processes, configuring library management with Ivy, and defining tasks. Behind the scenes, sbt executes as much of the build as possible in the same JVM for performance and flexibility. This includes compiling, testing, and running the project. With sbt 0.7, the version of Scala used to build a project is decoupled from the version running sbt and projects can use Scala versions from 2.7.2 through 2.8. The infrastructure required to implement this ranges from custom class loading to compiling sbt components on demand to booting with a special launcher application.
     
  • Processing with Spde: Scala at the Intersection of Art and Technology
    Nathan Hamblen

    Processing.org is a platform for graphical programming used in art, science, music, and commercial projects. Its greatest strength is its pragmatism: a simple programming environment called the PDE to create "sketches" that support everything from live video feeds to "hands in the mud" as input interfaces.
    But even as Processing supports a thriving community of technological creators, its adoption is limited by the rigidity of its environment and the lack of structure when working outside it. After experimentally creating a fork of the PDE for Scala called Spde, I started over and reimplemented key features like single-step applet export as plug-ins for the Scala builder simple-build-tool, decoupling functionality from the source language to support sketches written in Scala, Java, and potentially any JVM language.
    The talk will include a demonstration of using the Spde environment to create Processing sketches in Scala along with an overview of the development architecture.
     
  • Sneaking Scala Into Your Organization
    David Copeland

    Introducing new languages into an organization is always difficult. The risks are often insurmountable, especially in a well-run organization. Scala presents further challenges to Java developers, as it represents a fundamentally different way of programming.
    I will present a problem my team faced, the Java solution and the Scala solution that we ultimately adopted. I will show that Scala did provide a better solution, and identify the techniques I used to mitigate the risks our team identified.
    These techniques involve a combination of enhanced documentation, a focused problem domain, an effective DSL design, and explicit use of a small but expressive subset of Scala's features.
    This will be of interest both to the Scala community (as a means of identifying some challenges faced by adopters) as well as Scala enthusiasts and Java developers, who may want to apply Scala to better solve their organizations' problems, but aren't sure where to start.