In addition to some very cool Scala Days shwag, each conference attendee will receive a bottle opener USB drive containing the Typesafe Activator Developer Preview. (Those not at the conference can download it.) Typesafe Activator helps developers get started building applications with Play Framework, Akka, and Scala by including a number of template applications.

The latest release allows anyone to contribute their own templates! This provides projects, companies, authors, etc to create a new way for developers to get started with new technologies. We are looking forward to seeing some awesome templates from the community and our partners!

Give the latest Typesafe Activator a try and let us know how it goes.

By James Ward, Developer Advocate at Typesafe

There have been no changes to Slick Extensions (which contains the drivers for Oracle and DB2) since 1.0.0 was released, so we are not publishing a new release. Please use Slick Extensions 1.0.0 togetherwith Slick 1.0.1.

An interesting point of this success story is that BrandAirport did not have any developers with prior knowledge of Scala! They chose to learn Scala along the way, so with the help of both mentoring and Scala literature, a seasoned Java developer picked up Scala well enough to be productive within the first two or three weeks of the project - in spite of only having a part time commitment in the project.

Check out the full case study here and many thanks to Karl Dickson of Mejsla for sharing the story!

A big part of increasing Scala adoption is to educate new community members. As such, Rafał joins forces with organizers of other user groups, like PolishJUG, and JVM-focused events, like this year's geeCON, to provide the software community a chance to hear about Scala from great speakers in Krakow.

Rafał and his team has created a vibrant and rapidly growing Scala community in Krakow over the past two years, so we were very excited to interview him and ask a few questions about the various projects he's juggling:

Q: How and why did you get involved with Typesafe technologies?

A: I suppose it was in quite a typical way. I simply got fed up with all the boilerplate that we had to develop over and over again in plain old Java stack. It was hurting our development efficiency so anything helpful was highly welcome. The trending proliferation of JVM based languages was already quite strong back then and I had heard a lot of good things about Scala. After a little research and with strong suggestions from my colleague, we decided to give it a try writing a test suite at first – a typical route for an existing project. Then I decided to use Scala for a new project written from scratch. During the development I discovered more and more functional aspects of Scala, and then Akka with its actor model and distribution by configuration. Now we have all of the ongoing projects developed in Scala and I would like to keep it that way. I always look for solutions that help to get the right software done faster, especially when it gives a little fun to the dev team. By saying “right software,” I mean with high quality and meeting requirements including those for performance and scalability. I hate excessive complexity and bloatware that kills productivity - Typesafe platform is different and falls in the category of lean software and that’s why it’s my preferred choice right now.

Q: What are some exciting things that VirtusLab is currently working on?

A: There is a few projects. One of them is interesting web application within financial sector but dedicated to individual users with lots of processing at the backend and great UI for charting based on HTML5/Canvas. The other project is within natural language processing field - it automatically detects user’s problems and questions. Map-Reduce framework with jobs in Scala is used for analysis of text gathered from various sources like social networks and then alert is generated whenever something wrong happens in communication channels. The app allows quick reaction - a crucial thing these days.

One more project I’d like to mention is a tool that helps auto-scale your cloud infrastructure depending on traffic and using different strategies – that’s all what I can reveal right now but it looks promising. Our team is eager to work on new challenging projects and show our Scala expertise.

Apart from working with customers and promoting Scala we constantly work on our development efficiency and praise lean software :)

Q: In the past year, what are the prominent changes you have seen in the JVM communities?

A: Within our local community there was quite an eruption of different kind of activities. Lots of user group focused on particular fields have emerged and gained traction like Krakow Scala User Group and Lamda Launge while others matured like the PolishJUG, Software Craftsmanship Kraków or Kraków GDG, just to name a few.

Groups organize code katas, hackathons or workshops on which we’ve seen more and more Scala! It’s worth mentioning that many of those groups help each other out whenever possible. This deep cooperation is really something unique around here.

Moving out of local scope, Scala is quickly getting more attention recently and more local user groups keep appearing.

Q: At events like GeeCON and ScalaCamp, what have been the hot Scala Topics?

A: Some of the things that drew the most attention were Akka of course and functional programming concepts in Scala in general. We also had talks about DSLs and what can be surprising also Monads and Functors :). Lots has been written and blogged about monads, but understanding those concepts helps to understand functional programming better.

We had requests for Scala and Akka workshops and we are planning to host them in a few weeks.

Thanks to cooperating with the community powered GeeCON conference and the PolishJUG, we’ve been able to get in touch with great speakers from the Scala-space to meet high demand for knowledge - so again collaboration.

Q: What do future plans for ScalaCamp entail? Do you see this expanding to other cities as well?

A: The formula of ScalaCamp seems to work but we would like to make it even more interesting and intensive through more un-conference style and through introducing new ideas, interactions and community engagement. I think we will find out what works best but even before that I would like to invite every other Scala User Group in Poland and outside of Poland to organize ScalaCamps locally in their cities. Just contact us and we will share the details and help in any way we can.

Check out VirtusLab website for more details about partner’s services and ScalaCamp website for more information about future events.

• Calling Thread Dispatcher deadlock problems
• Stack overflow while loading messages from persistent mailbox
• More robust recovery in remoting in case of malformed messages
• Proper deployment of typed actors 

... and several smaller fixes

The documentation for 2.1.4 is now also available in ePub format. This update is backwards binary compatible, meaning that the JAR files of release 2.1.4 are a drop-in replacement for 2.1.0, 2.1.1 and 2.1.2 but not the other way around. We recommend that all users upgrade at their earliest convenience. Please refer to the full announcement for more details.

Happy hAkking!

Now, after reading through all the impressive submissions from the community, universities and enterprise IT shops, I’m so proud and humbled by how mature and expansive the community has become. I think the conference agenda, from sessions on asynchronous programming to building scalable, highly concurrent and fault-tolerant systems, is truly astounding and I’m looking forward to seeing everyone there.

This year, I will give a talk on writing Scala with style, which I think reflects where we are in the course of the language. One of the things that makes Scala special, to me, is it’s expressive power; this can be both a blessing and a curse, so I want to share how to make the best of it, and give my personal summary of what I think makes good Scala style. As with most questions of style, the discussion will be quite subjective, and some of it might be controversial. I hope attendees find this session stimulating, and I think it will set the stage nicely for the rest of the conference.

See you in NYC!

By Martin Odersky, Chairman, Chief Architect & Co-Founder of Typesafe

This project has been four months in the making, and reflects our vision, values, and direction as a company – changing the way software is built while delivering a great developer experience for creating and running reactive applications on the JVM. The new site also features our newest product, Typesafe Activator, an easy way to get started with the Typesafe Platform, Play Framework, Akka and Scala. Activator is currently in developer preview.  Please download it, check it out and see how easy it is to start building amazing, reactive applications with our technology.

By Mark Brewer, CEO

In our newest case study, Graham Tackley, Head of Architecture for The Guardian, shares how his team uses Scala, Akka and Play Framework to provide a solid, scalable foundation on which to start building these new services. In this piece, Graham shares valuable strategies and lessons learned for moving from an off-the-shelf CMS tool, to a monolithic platform, to an agile and modern application architecture. 

Read the full case study for more detail, and thanks to Graham for sharing his story.

Lee started the online service organization at Nest Labs, maker of the Nest thermostat.  Prior to Nest, Lee has served in executive and engineering leadership roles at Apple, Twitter, General Magic, ObjectSpeed and WebTV, and has advised a variety of startups.  Lee's current interests are in scalable reliable distributed systems, sensor networks, big data, and machine learning.

At Typesafe, we help companies like Nest build scalable and reliable software, and having Lee on our advisory team will ensure that we continue to fulfill that mission. As we continue to see rapid adoption within other organizations, like Juniper, Twitter, LinkedIn, UBS, the Guardian and more, we're fortunate to have Lee provide insight and guidance.

Welcome, Lee! Happy to have you on board.

Step 1: Host a Scala Meetup By hosting a local Scala user group meetup, you are publicly announcing that your organization is joining the Scala community. It also lets the community know that your organization is looking for ways to help promote and sponsor initiatives around the ecosystem. If one doesn’t exist, have someone in your organization take the lead of starting one, showing how committed your company is to the community. This will make your organization's new direction very clear to developers in your area and help generate recruiting leads. If you're interested in having Typesafe help host your meetup, please email marketing@typesafe.com

Step 2: Enable Book Reading Start an employee book purchase program, and if possible, do it such that no expense reporting by individuals is required so as to remove roadblocks that might keep developers from making the effort. Ideally, when an employee asks for a book on an internal wiki, it should show up on their desk or eReader shortly thereafter. Start a weekly lunchtime book discussion group, where employees either bring a lunch or have it paid for by your organization, and discuss a chapter of a specific book each week. Recommended books include:

• Scala for the Impatient (beginners)
• Atomic Scala (beginners)
• Programming in Scala (free first edition online, more info about theory)
• Scala in Action
• Programming Scala
• Scala in Depth (for experienced Scala developers)
• Akka Concurrency
• Akka in Action
• JVM Performance

Step 3: Learn Best Practices Make the following resources available to developers on your team, and organize study groups around them to share knowledge:

• Scala Coding Style Standards
• Twitter's Effective Scala
• Twitter's Scala School
• Coursera Functional Programming Course with Martin Odersky

4: Get on Twitter Have developers follow daily happenings in the Scala community via Twitter. Twitter is the best source for real-time information about what's happening in the Scala community and elsewhere. *See below for some suggestions of Twitter accounts to follow.

Step 5: Engage the Blogosphere Have developers subscribe to prominent Scala blogs, so that they can find out information about what cool new things developers have learned. They will likely hear about these posts via Twitter, Prismatic or some other aggregator, but a great way to begin getting more Twitter followers yourself is to be among the first to post a link to a great new blog post. Encourage your developers to start their own blogs talking about the challenges they've faced and how they've overcome them.

• Let It Crash, the Akka team blog
• Debasish Ghosh
• Josh Suereth
• Brendan McAdams
• Cake Solutions Team Blog: This Week in Scala
• Typesafe blog
• James Ward

Step 6: Hop on IRC, Google Groups, Stack Overflow and Podcasts Inform your developers of IRC Channels and mailing lists where they can directly interact with top developers in real time, including the creators of the technologies themselves. Eventually, they will find themselves able to answer questions from other people or participate in the podcasts themselves and thereby increase your organization’s presence in the community.

IRC:

• #scala
• #akka
• #playframework

Google Groups:

• scala-user
• scala-sips
• akka-user
• play-framework

Scala topics on Stack Overflow

Podcasts:

• ScalaTypes
• Scalawags

Step 7: Attend and Speak at Meetups Encourage employees to regularly attend Scala meetups, as well as meetups on other topics. Ask them to speak on your company's behalf when they feel comfortable with the subject matter. This will help generate excitement in the community about what your company is doing with these technologies, and help in recruiting new developers interested in what you're doing and the tools you're using.

Step 8: Attend and Speak at Conferences Attend conferences with Scala content where you can network with other Scala enthusiasts. When you feel comfortable discussing specific topics, submit talk proposals for consideration at these conferences. Even conferences not directly related to Scala are clamoring for talks about these technologies, so the rate of acceptance is relatively high. Important ones that focus on Scala and the broader ecosystem include:

• ScalaDays
• NE Scala
• PNW Scala (coming soon)
• Scalathon
• JavaOne
• StrangeLoop

Step 9: Get Involved in Open Source Have developers fork the GitHub repositories for Scala/Akka/Play and see if there are features, fixes or functionality they can contribute back. GitHub repos for each project can be found at:

• Scala
• Akka
• Play

By Jamie Allen, Director of Consulting at Typesafe

*Suggestions of Twitter accounts to follow: @_jamesward; @adriaanm; @akkateam; @aloiscochard; @andrewheadrick; @bantonsson; @brianclapper; @bruceeckel; @bvenners; @corruptmemory; @d6; @dcsobral; @deanwampler; @debasishg; @derekhenninger; @derekwyatt; @dickwall; @djspiewak; @dmarsh; @drewhk; @eed3si9n; @etorreborre; @extempore2; @gclaramunt; @gkossakowski; @h3nk3; @havocp; @helenaedelson; @higherkinded; @hseeberger; @huitseeker; @hywel_evans; @iamwarry; @ijuma; @jaguarul; @jamesiry; @jamie_allen; @jboner; @jorgeo; @jroper; @jsuereth; @jteigen; @kmizu_en; @mabrewer7; @marius; @milessabin; @mircodotta; @missingfaktor; @mkelland; @mpilquist; @mslinn; @n8han; @nescalas; @nraychauduri; @odersky; @patriknw; @philippkhaller; @pk11; @playframework; @pnwscala; @psnively; @pvlugter; @rayroestenberg; @retronym; @richdougherty; @rolandkuhn; @runarorama; @scalaide; @scalathon; @sirthias; @sky1uc; @springrod; @stefanzeiger; @strangeloop_stl; @tbjerkes; @timkirk5; @tlockney; @twittereng; @typesafe; @viktorklang; @xeno_by; @ymasory

Cox realized early on that picking the right platform and toolset for his innovative new product was critical, and after doing his homework, he settled on Scala, Akka and Play. In our newest case study, Cox explains how he built BeamStream with Typesafe technologies, emphasizing how the importance of performance and scale factored into the decision making process.

Read the full testimonial for more detail, and be sure to sign up for the BeamStream Beta test to learn more about Cox's newest venture!

Martin Odersky started the trend by donating his JAX Ambassador Award prize money for the contest. Then, two of our winners were extremely generous in donating their prize money....

William Billingsley, who submitted a Backgammon application, donated his $200 winnings to World Vision, a humanitarian organization that works with children and families around the world to combat poverty and hunger. Vibul Imtarnasan, creator of the Event Based Task Runner, pledged his $200 to the Wikimedia Foundation, a global movement with the mission to bring free educational content to the world

It's always great to see good deeds continued in the name of charity and education. William and Vibul, on behalf of all of at Typesafe, thank you!

This release brings Scala programming in Eclipse to a whole new level, with great improvements in the editor, a new Scala-aware debugger, more refactorings, a Scala worksheet and additional plugins like ScalaTest support. Read the full release notes on the Scala IDE blog.

Typesafe IDE
In order to make it as easy as possible to try out the new Scala IDE for Eclipse, we updated the Typesafe IDE bundles. Head over to the download page and get a pre-packaged Eclipse with the Scala tools pre-installed (2.9 or 2.10)! If you prefer to update your existing Eclipse installation, check out the IDE download page to get started, or read on to learn more about the highlights.

Editor improvements
The 3.0 release greatly improved the Scala editor: the new semantic highlighting feature makes it easy to spot deprecated methods, mutable variables and many other Scala-specific traits. Implicit applications are highlighted, and can be navigated to their definition. Moreover, we put a lot of effort in making the editor faster and more responsive, and moved all processing in the background. We believe that editing is now much faster and more pleasant than before!

Scala Debugger
Scala is an incredibly rich language, and its translation to the JVM introduces compilation artifacts that sometimes obscure the original program. The Scala debugger helps by de-mangling names, showing the logical structure of usual Scala collections, stepping over getters and setters (and a bunch of other artifacts), sane handling of for-loops and higher-order functions, etc. Compared to the last milestone, we made the debugger much faster and more robust.

New Scala IDE Plugins
In this release we bring an ecosystem of plugins, and make them available through the same update site as the Scala IDE. This makes it easy to discover useful plugins for Scala development. We are extremely happy to see it growing, and thanks to Chee Seng and Bill Venners, Scala IDE users can now install the ScalaTest plugin and run/debug and inspect scalatest fixtures right in Eclipse.

The worksheet is another Scala IDE plugin, allowing a new breed of interaction with your project and the language. A worksheet is a Scala file that is evaluated on save, and the result of each expression is shown in a column to the right of your program. Worksheets are like a REPL session on steroids, and enjoy 1st class editor support: completion, hyperlinking, interactive errors-as-you-type, auto-format, etc. Whether you want to explore a new library or just whip something up, the worksheet can make it fun. Don’t miss it!

We will continue to work with plugin developers to integrate new and interesting plugins in the ecosystem. Please check the ecosystem docs if you want to be part of it!

We’d also like to recognize the hard work of all contributors that helped shape this release. A huge thank you to all contributors and the great community around the Scala IDE for Eclipse!

By Iulian Dragos, Scala IDE Lead at Typesafe

The conference featured 20 talks, including lightning talks, experience reports and best practices. From Typesafe, Jonas Bonér, Jamie Allen, James Roper and myself gave talks on Scala, Akka and Play. The most telling talks, however, were the experience reports on using Scala in real world applications.

The conference featured talks from Mitsubishi UFJ Information Technology, Geisha Tokyo Entertainment, Everforth, CyberAgent, Tech to Value, M3, DWANGO, Furyu, Advanced Soft Engineering, NTT Data Intellilink and Shanon. These reports were eye-opening for a lot of us at Typesafe. Not only is Scala active and thriving in Japan, these folks are doing some cutting edge things with Scala, and contributing back into the Open Source community.

One of my favorite questions from the conference was during the Geisha Tokyo Entertainment talk, when one concerned developer asked the audience: “Do you have any horror stories from using Scala?” The answer: “None.”

The second day of the conference was a hackathon. Here, many developers got together to work on new, or existing open source projects. At the end, we had a competition to see what the most impressive project was. Here's a list of what came out:

• A DSL for generating HTML (called htmlda, based on Jsonda), with play integration.
• An Akka-based link between a running JavaFX application and a play webserver
• An unfiltered web-socket application (called closed captioning) that aggregates a twitter feed and irc chat. This was used during the conference for live Japanese <-> English translation
• A turtle parser and case-class serialiser (winner of the competition).
• A Yammer statistics collection service for Akka servers.
• A wiki written in Play, stored as a local git repo, that renders both Markdown and an emacs format.

The conference was sold out, with 200 attendees and 70 people on the waiting list. We hope to see the energy and innovation continue!

The talks and their slides are available at Scalaconf.jp

Lastly, if you're interested in getting involved with the Japanese Scala community, here's a list of prominent members and their OSS projects:

Kazuhiro Sera
Twitter: https://twitter.com/seratch
GitHub: https://github.com/seratch
Author of ScalikeJDBC, an SQL-Based DB Access Library for Scala

Toshiyuki Takahshi
Twitter: https://twitter.com/tototoshi
GitHub: https://github.com/tototoshi
Author of play-json4s, play-ascii-art-plugin and contributor of ScalikeJDBC

Manabu Nakamura (AKA Gakuzzzz)
Twitter: https://twitter.com/gakuzzzz 
GitHub: https://github.com/t2v
Author of Play20-auth, a Play2.x module for Authentication and Authorization

Kota Mizushima
Twitter: https://twitter.com/kmizu
GitHub: https://github.com/kmizu
Deputation of ScalaJP, chairman of Scala Conference in Japan and author of Jsonda

Yusuke Kuoka (AKA @mumoshu)
Twitter: https://twitter.com/mumoshu
GitHub: https://github.com/mumoshu
Author of play2-memcached, a Memcached Plugin for Play Framework 2.0

Kenji Yoshida (AKA @xuwei_k)
Twitter: https://twitter.com/xuwei_k
GitHub: https://github.com/xuwei-k
Scala, Scalaz, and Play20 contributor and SBT expert

Chris Birchall
Twitter: https://twitter.com/cbirchall
GitHub: https://github.com/cb372
Author of scala-ascii-art and ScalikeJDBC contributor

Sanshiro Yoshida (AKA nekoharu-san in)
Twitter: https://twitter.com/halcat0x15a
GitHub: https://github.com/halcat0x15a
Author of Twitter4z, a Scalaz wrapper for Twitter API

Yoshihiro Imai
Twitter: https://github.com/yoshihiro503
GitHub: https://github.com/yoshihiro503
Author of Coq2Scala and active member of the Nagoya Scala community

Tomohito Ozaki:
Twitter: https://twitter.com/yuroyoro
GitHub: https://github.com/yuroyoro
Author of svm, a Scala Version Manager

Kato Kazuyoshi
Twitter: https://twitter.com/kzys
GitHub: https://github.com/kzys
Great contribution to Scaladoc improvement in Scala 2.9.X

RKTM
Twitter: https://twitter.com/RKTM
GitHub: https://github.com/RKTM
An active member of Nagoya Scala community

By Josh Suereth, Senior Software Engineer at Typesafe

For more information on sessions, speakers, hotels and a preliminary agenda, head over to the Scala Days website, and stay tuned for continuous track updates. 

Since having proper JavaDoc artifacts is necessary for IDE support and we also do not wish to impose ScalaDoc on Java developers, we developed a Scala compiler plugin which transports the documentation comments from the Scala sources to Java output files such that native JavaDoc can be produced from them. This process has been applied to the Akka documentation, please check it out!

The compiler plugin is published to Maven Central and available under the Apache 2 license, for more information head over to github. We encourage all authors of Scala libraries which are intended to be consumed from Java to try it out and provide us feedback.

By Roland Kuhn, Akka Tech Lead at Typesafe

--

The Challenge

Running multi-tier, complicated apps on the cloud can be very tricky. There are many concerns to cater for in order for such an application to be successfully deployed and managed on the cloud.

Let’s take a relatively simple example, of an application that includes the following stack: Apache as a load balancer / static content server, a few Play instances as the web application tier and a replicated MySql cluster for storing the application’s data (say 1 primary and 2 replicas).

Let’s look and some of the things you have to cater for when managing this stack on a cloud environment:

• Starting VMs: goes without saying. You will compute resources to run your application.
• Installing and configuring the started VMs: Every VM needs to be installed and configured properly. For example, for VMs on which Play runs, you need to have JDK 6 and Play itself installed, and open the relevant ports for the Play to be accessible. For the Apache VMs, you will need to have Apache2 installed alongside its dependencies and relevant modules (e.g. mod_proxy).
• Starting and orchestrating application components: Naturally, your application tiers depend on one another and have to be aware of one another. For example, before starting the Play servers, you will have to make sure the MySql cluster is up and running, and that the Play servers are aware of the host names and ports of the relevant MySql servers.

Repairing: Once everything is up and running, things can and will break. Processes will die for no apparent reason, VMs will come and go, and you need your application to continue to work even when this happens. Monitoring key metrics and scaling your application tiers based on them: Think about a (very positive) scenario where your load spikes due to your application or service being very successful. You need to be able to tell what’s the load on your app across its various tiers and for very specific metrics (e.g. request latency), and take action based on it to make sure your users keep getting a decent service level. For example, add additional replicas to MySql, or increase the number of Play instances. Updating your application code: There’s always the issue of updating your application with new code. You want to do it as fast and painless possible, and as soon as new code is available.

In a cloud environment, which is dynamic and volatile by nature, it’s also extremely important to automate all of these processes, so that you can setup environments easily and consistently, switch between environments, test things before you go live, maximize your utilization and minimize downtimes.

Isn’t PaaS Sufficient?

Using PaaS solutions like CloudBees, CloudFoundry or Heroku can be a very good option, as it relieves you as an application owner from the intricacies of handling most the above concerns, and does most of the work for you. However in many cases, you want to control things on a more fine grained level, e.g. choose the cloud you’re running on, use a middleware component that it not consumable via PaaS, choose the version of components that you’re using, the hardware profile of your VMs, the clustering topology of your data tier, the load balancing mechanism, etc. You also want to be able to upgrade tiers (e.g. move from Play 2.0.3 to Play 2.0.4) at your own pace and not wait for the PaaS provider to do it for you.

Last, in some cases, PaaS is not even an option, e.g. when deploying on premise.

Introducing Cloudify

Cloudify is an open source framework for deploying, managing and scaling your applications on any cloud environment. This includes EC2, RackSpace, HP Cloud Services, Azure, private clouds environments based on OpenStack, Apache CloudStack or VMWare. You can even use it on an arbitrary set of servers, virtualized or non-virtualized. It’s designed to handle the above concerns for you, while still letting you retain a high degree of control and flexibility.

Similarly to Chef and Puppet, Cloudify allows you to use recipes to describe what your application looks like. But it really augments both, by defining things from an application rather than an infrastructure perspective.

In other words, while Chef and Puppet are excellent at configuring individual servers (“given a server, here’s how I want it to look like”), Cloudify focuses on what your application looks like (“here’s what my app looks like, now provision the VMs, assign them with roles and install it on the cloud for me”).

Cloudify recipes are used to define application tiers (web container cluster, database cluster, caching instances, etc.), the number of instances in each tier, how the tiers depend on one another, and how to install, start, verify and monitor each tier. Since Chef and Puppet are great for infrastructure configuration, you can and are encouraged to use them to do the installation and configuration part of a Cloudify recipe (Cloudify is integrated with both tools).

For example, for the Play application that we mentioned above (composed of Play itself, fronted by an Apache load balancer, and backed by a MySql cluster), you’d model it as follows with Cloudify

How It Works

Once you have a Cloudify recipe, the first thing to do is bootstrap a Cloudify controller environment on the cloud of your choice. This is done easily from the Cloudify CLI and will eventually result in a Cloudify controller running on the cloud of your choice. From that point onwards, the CLI will communicate with the controller over REST. Next, you issue an install-application command that will trigger the controller to analyze the installed recipe, provision the right amount of VMs for it, and orchestrate the deployment of all the recipe components. Later, this controller will monitor the deployed components and VMs, scale them if needed and make sure to restart any failed components.

What's in Store for Play Users

As one of our favorite web frameworks, one of the first recipes we created was for Play. We also created a sample app recipe for the Play Computers example, which is a full blown application stack that includes MySql, Play and Apache (as a load balancer). Using the Play recipe, you can easily automate the configuration, deployment, failover and scaling of any Play framework app, on any cloud environment (and btw, that also includes private clouds and even non-virtualized environments). If you’re interested in the all the details of the Play recipe this post will give you a good start.

Play Your Recipe with Play!

Another (very cool, IMHO...) tool that you will find very useful, is the Cloudify Player. This is also an open source project, which is implemented using the Play framework, and uses Cloudify to allow users to easily experience new frameworks and tools over the web. The idea is this: if you have a Cloudify recipe for an application (e.g. Play Computers) or a project (e.g. Cassandra), you can configure a player for it. The result of this is a simple embed code that you can include in any web page, and renders the player. What happens under the hood is that the player communicates with a Play application on the server side. This app manages a pool of VMs deployed on the cloud of your choice (in this case HPCloud) and “bootstrapped” with a running Cloudify manager. The server borrows a VM from the pool, connects to the running manager over REST and issues the recipe installation command. After about 30 seconds, you have a running app or service, available for you to try out for 30 minutes. All courtesy of the Play framework and Cloudify.

Here’s the actual widget for the Play Computers app example recipe. Feel free to click the image below, launch the real widget and see it in action for yourself. The embedded video explains how to access the sample app after launching it using the widget.

So go ahead and give it a try, we’ll be more than happy to hear your feedback!

In this case study, Mark Beeson, Heluna's Founder and Chief Architect, shares how he chose the entire Typesafe platform to create a flexible architecture that can shrink and grow organically as needed, making it simple to spin up more nodes on Amazon EC2. Mark also revamped the Heluna website through a combo of Scala, Play Framework and CouchDB, giving users complete visibility into the backend redis queues to see how their spam is processed in real-time. 

You can read the entire case study here and a big thanks to Heluna for sharing their experience with Scala, Akka and Play!

The fourth annual Scala Days will be held this year at The Hudson Theater in NYC, June 10th-12th. Now is the time to submit speaking sessions and register to attend! The CFP is open until April 15th, and speakers will be announced on a rolling basis.

This year's conference will bring together developers from all corners of the world to share their experiences and new ideas around creating applications with Scala, Akka and Play. Scala Days provides a unique opportunity for the Scala community to interact with the key contributors to the language and related technologies. This year’s keynote will be led by Martin Odersky, and featured speakers include Jonas Bonér, Viktor Klang and others.

To submit a proposal, please email Info@ScalaDays.org

If you’re interested in being a Scala Days sponsor, please complete the Sponsorship Form or send an email to Marketing@Typesafe.com for more info on custom packages.

Hope to see you in New York!

This compelling use case illustrates how Andrew Headrick, Ticketfly’s Platform Architect, selected Scala and Akka to craft a powerful reserved seating engine (something that is notoriously complicated to build because of it’s rapidly changing state), that could easily scale, handle bursty and unpredictable traffic patterns and compete with online ticket scalpers. Read the full case study here, and head over to Ticketfly to check out their local venues and events.

by Hywel Evans, Solutions Architect at Typesafe

You can read the complete testimonial here, or head over our Resources page.

Slick 1.0 also adds some important new features:

Auto-Generated Keys

Slick has always supported auto-generated primary keys through the use of the O.AutoInc column option:

object A extends Table[(Int, String)]("A") {
  def id = column[Int]("ID", O.PrimaryKey, O.AutoInc)
  def data = column[String]("DATA")
  def * = id ~ data
}
    
A.data insertAll ("foo", "bar")

However, when you insert data into such a table, you frequently want to get back the generated key in order to use it immediately to reference the new data. Slick 1.0 now supports this use case with an intuitive syntax:

val ids = A.data returning A.id insertAll ("foo", "bar")

New Drivers

Typesafe provides Slick drivers for Oracle and DB2 databases in the new Slick Extensions package, along with commercial support for Typesafe Subscribers.

Capabilities & TestKit

Database drivers for Slick implement different profiles which expose all supported features, but there are far too many small differences between minor features supported by different database systems to express using profiles. Instead, these features are now described using capability flags defined by the profiles. These provide a more formal specification of a driver's capabilities. The unsupported capabilities are listed in each driver's API documentation and you can check for the availability of a capability at runtime.

In addition to the main Slick artifacts we also publish the Slick TestKit which contains most of Slick's unit tests in a reusable package. It uses the capabilities declared by a driver to find out which tests to run, so you can use it to test your own driver implementations, too. Check out the slick-testkit-example project on GitHub for a demo.

More

Many other small improvements have gone into Slick 1.0, for example proper support for BLOBs on PostgreSQL, a fully-featured sequence emulation for MySQL, and improved SQL statement logging. You can find more details in the announcement on the Slick website.

By Stefan Zeiger - Slick Tech Lead at Typesafe.

The offer expires Feb 12, 2013 at 12 midnight EST.

Let's take a look at few of the new updates.

Dependency Injection for Controllers

In the past, the URL to code mappings in Play only supported calling static methods on a controller. This made it difficult to use Dependency Injection (e.g. Spring Framework and Guice) to setup an application at runtime based on configuration. Play 2.1 now supports a new routes syntax that enables calling injected controllers instead of static methods. Simply prefix the controller method in the routes files with an "@" symbol, like:

GET     /                  @controllers.Application.index()

Then in your Global class use the getControllerInstance method to return the instance:

public <A> A getControllerInstance(Class<A> clazz) {
    return ctx.getBean(clazz);
}

For a complete example that uses Spring 3, check out Guillaume Bort's play20-spring-demo project on GitHub.

Better Scalability, Non-Blocking Async, and Scala 2.10

For Scala developers the most exciting new feature in Play 2.1 is probably the upgrade to Scala 2.10. This brings with it a ton of new language features. One new feature that makes it easier to build scalable Play apps is the new Futures and Promises API, which was initially created in Akka. This enables a very concise programming model for doing non-blocking, asynchronous composition of services. In a nutshell, this enables your server to handle a ton more requests since it only uses threads when it absolutely needs them. Here is a simple example that makes two JSON requests, one to GitHub and one to Twitter, then when it has the responses it renders a web page containing data from both:

def social = Action {
  Async {
    val twitterPromise = WS.url("http://search.twitter.com/search.json").withQueryString(("q", "playframework")).get()
    val githubPromise = WS.url("https://api.github.com/legacy/repos/search/playframework").get()
    for {
      twitterResponse <- twitterPromise
      githubResponse <- githubPromise
    } yield Ok(views.html.social.render((twitterResponse.json \\ "text").map(_.as[String]), (githubResponse.json \\ "name").map(_.as[String])))
  }
}

The amazing thing about this is that under the covers none of the web requests block when they are in a waiting state! Of course, you can also get the same behavior in Java using Play's Functional APIs.

Modular Routing Makes Large Projects Easier to Manage

As projects grow it is important to break them into sub-projects. Now you can easily include a sub-project's routes into the master project using the new "->" syntax in the routes file. For instance, to include all of the routes defined in a subproject, under a "/foo" URL prefix, simply add the following to your routes file:

->    /foo      foo.Routes

This enables many developers to easily collaborate on large, multi-project code bases without stepping on each others toes. For more details, read Working with Sub-Projects in the documentation.

Built For Modern & Scalable Apps

These are just a few of the many new features in Play 2.1. Over the past year, the Play Framework has been successfully used in some very demanding scenarios, like Klout's billion API transactions per day, Gilt Group's real-time inventory updates via WebSockets, and of-course for the Typesafe website. This new release makes it easier to build modern and scalable apps while being developer friendly. Head on over to the all-new playframework.com to download Play 2.1 and build something amazing!

By James Roper - Play Framework Developer at Typesafe.

We’re excited to launch 'Week of Scala,' a joint promotion with Manning Publications where we highlight a new book each day that is special to us and hand-picked by the Typesafe team. We also collaborated with Manning to select a second book for each day of the week, and will be offering our choices at a 50% discount on their site! You can even read excerpts from some of the books online for free by clicking on the links below.

We hope you enjoy the deals! We’ll be Tweeting and updating our blog with the daily discount codes throughout the week, so stay tuned. Also, be sure to drop by the CodeRanch Week of Scala Forum to chat with these authors and other Scala junkies any time this week.

Here’s the schedule:

Monday, February 4, 2013

Discount Code: scalawkd1

Scala in Depth
by Josh D. Suereth, Senior Software Engineer at Typesafe*
"Scala in Depth is the Effective Java of Scala, the book every serious Scala developer just has to read. I highly recommend it as your second Scala book." -Jonas Bonér

*To read an excerpt, click here!

You also might be interested in:

 DSLs in Action 

 by Debasish Ghosh

Tuesday, February 5, 2013

Discount Code: scalawkd2

 
Play for Scala
by Peter Hilton, Erik Bakker, and Francisco Canedo
“If you’re interested in getting started with Play 2 from a Scala perspective, this is absolutely the book to get!” -Jonas Bonér

*To read an excerpt, click here!

You also might be interested in:
HTML5 in Action
by Rob Crowther, Joe Lennon, Ash Blue and Greg Wanish

Wednesday, February 6, 2013

Discount Code: scalawkd3  

Akka in Action
by Raymond Roestenburg and Rob Bakker
“This is a great book to read if you want to get started by Akka and understand how to use it in the real world. Written by one of the first production users of Akka.” -Jonas Bonér

*To read an excerpt, click here!

You also might be interested in:
Camel in Action
by Claus Ibsen and Jonathan Anstey

Thursday, February 7, 2013

Discount Code: scalawkd4

Scala in Action
by Nilanjan Raychaudhuri, Developer at Typesafe*
"Scala in Action provides a great beginning to Scala, with particular focus on what blended functional & object-oriented programming looks like." -Josh D. Suereth

*To read an excerpt, click here!

You also might be interested in:
Single Page Web Applications  
by Michael S. Mikowski and Josh C. Powell

Friday, February 8, 2013

Discount Code: scalawkd5

Functional Programming in Scala
by Paul Chiusano and Rúnar Bjarnason
“If you are interested in learning how to fully utilize Scala's functional side, then this is the book to get. Will teach you everything from basic to advanced use of functional programming.” -Jonas Bonér

*To read an excerpt, click here!

You also might be interested in:
The Joy of Clojure
by Michael Fogus and Chris Houser

Saturday, February 9, 2013

Discount Code: scalawkd6

Play for Java
by Nicolas Leroux and Sietse de Kaper
“If you want to get started with using Play 2 from a Java perspective then you should start reading this book.” -Jonas Bonér

You also might be interested in:
The Responsive Web
by Matthew Carver

Sunday, February 10, 2013

Discount Code: scalawkd7

Scalatra in Action
by Ivan Porto Carrero, Ross A. Baker, Dave Hrycyszyn, Stefan Ollinger, and Jared Armstrong

*To read an excerpt, click here:

You also might be interested in:
The Well-Grounded Java Developer
by Benjamin J. Evans and Martijn Verburg

 *To read an excerpt, click here:

We’d like to thank Manning Publications for making “Week of Scala” possible, as well as the folks at CodeRanch for helping us promote this deal!

Happy Reading!

Our users and clients expect data to be up to date and accurate and it has been a significant technical challenge to reliably meet these goals. In this blog post we describe the usage of Play! Iteratees in our redesigned data collection pipeline. This post is not meant to be a tutorial on the concept of Iteratees, for which there are many great posts already such as James Roper's post and Josh Suereth's post. Rather, this post is a detailed look at how Klout uses Iteratees in the context of large scale data collection and why it is an appropriate and effective programming abstraction for this use case. In a later post we will describe our distributed Akka-based messaging infrastructure, which allowed us to scale and distribute our Iteratee based collectors across clusters of machines.

Head over the the Klout blog to read the rest of the post. Thanks to Naveen Gattu for providing such an excellent post!

My thanks to Jon for taking the time out of his busy schedule to answer these questions. Check out Jon’s company, Scala Technology, as well as his own open-source projects on GitHub!

If you know someone who fits the bill, please send them our way by emailing careers@typesafe.com. If we hire your candidate, you win a MacBook!

Many new features enable library and framework developers to provide a simpler yet richer developer experience for their users. For example, the Play Framework harnesses Scala 2.10's new asynchronous programming model to compose services efficiently and concisely. Similarly, other library developers are using Scala 2.10's experimental Macros and Reflection features to further reduce complexity in applications. Even String Interpolation is easily extensible by library developers in Scala 2.10!

Here are some of Scala 2.10's new features that you can start using right now.

String Interpolation: Simple Type Safe String Substitution

Often times a developer needs to compose strings of text by substituting values for place holders. Scala 2.10 adds a new String Interpolation library that works with the power of compile-time type checking in Scala. Here are two examples.

To insert the contents of a variable in a string, simply prefix the string literal with an "s" and prefix the variable with a "$".

println(s"The word of the day is ‘$wordOfTheDay’.")

String interpolation also supports arbitrary expressions when wrapped with braces. Using printf style formatting, the string interpolator executes the expression and enforces type safety.

// log only two digits after the decimal to display as seconds
log.info(f"Time elapsed: ${millisElapsed/1000.0}%.2fs.")

The Scala IDE now supports Scala expressions in String Interpolations.

Futures & Promises: A Concise Async Programming Model

The Scala team at EPFL and the Akka team collaborated on a new API which standardizes the API for asynchronous programming using the Future and Promise paradigms. With valued input from Twitter and many other developers building massively asynchronous systems, the result is a very convenient API for expressing powerful asynchronous computations. Additionally, Akka's actors are now included in the distribution.

Developers who are building complex integration apps with Play and Akka are raving about the new Scala 2.10 Future API because it allows them to fire off hundreds of HTTP calls, then compose the results and render a web page. Composing numerous asynchronous calls in Scala 2.10 using a for-comprehension provides a concise programming model that feels natural but also manages resources efficiently and deals with errors gracefully. For instance, an asynchronous request handler in Play, that makes three asynchronous requests to render a page, may look like:

def profile(user: User) = Action {
      Async {
        for {
          lastPostId <- user.fetchLastPostId
          posts      <- fetchPosts(user, lastPostId)
          avatar     <- user.fetchAvatar
        } yield Ok(views.html.profile(user, posts, avatar))
      }
    }

Under the covers, Akka, Scala, and Play all work together to efficiently manage concurrency and resource utilization while maintaining a simple and concise programming model.

Value Classes: Objects On a Diet

Enhancing classes to include additional functionality while avoiding runtime overhead is now possible in Scala 2.10 with Value Classes. For instance, if you need to be able to convert every Int to its hexadecimal representation, then a Value Class can do this without having to create unnecessary instances. For example, the following RichInt class is a Value Class that allows you to wrap an Int to add a toHexString method, without the overhead of allocating an extra object.

class RichInt(val self: Int) extends AnyVal {
 def toUpperHexString: String = java.lang.Integer.toHexString(self).toUpperCase}

In the following example the new RichInt is automatically optimized by Scala so that the underlying instance stays in Int! This provides faster execution and less memory usage.

val x = new RichInt(2) // at run time, x is simply an integer!
x.toUpperHexString

Scala also provides a way to automatically use Value Classes. For instance, to make it so all Int classes can be used as a RichInt simply make the RichInt Value Class implicit:

implicit class RichInt(val self: Int) extends AnyVal { … }
2.toUpperHexString // no explicit wrapping required anymore!

Together with Implicit Classes, Value Classes make it simple to enhance objects in a type safe and concise way!

Even More: Scala 2.10 is Simply Better

• Scala now provides a way to control different levels of language features so that those just learning to swim don't get thrown into the deep end of the pool. We've come up with a way of putting you in control of which of the features your codebase relies on. This simplifies the initial experience that developers have with Scala and allows organizations to scale their use of the language.
• The pattern matcher was rewritten from scratch to produce more robust code and provide more user-friendly error messages.
• The Dynamic trait provides a convenient construct for using dynamically typed objects when it makes sense (for example, accessing untyped data over REST).
• The bytecode generator now uses the industry-standard ASM library to generate bytecode much faster and for a wider variety of JDK versions including the Java 1.5, 1.6 and 1.7 versions.
• Scaladoc now shows implicitly added members, inheritance diagrams and member grouping. Check out the Future documentation to see it in action!
• Scala 2.10 includes a few experimental features, including Macros and Reflection. While these are expected to change in the Scala 2.11 series, it hasn't stopped people from doing very cool things with them!

At Typesafe we are very excited about the Scala 2.10 release and everything it does to make developers more productive and apps more efficient! You can try out Scala 2.10.0 by downloading the standalone distribution (which includes the REPL) or get started in Eclipse using the Scala Eclipse Plugin. We think Scala 2.10 sets a new standard for building highly sophisticated and amazing apps in a simple, concise manner; we think you'll agree. More power less code!

By Adriaan Moors - Scala Tech Lead at Typesafe.

Why Learn Scala in 2013?

2012 was a big year for the Scala programming language! If you haven't learned Scala yet perhaps 2013 should be the year. We've assembled a list of some of the best articles of 2012 that address the "why learn Scala" question. Read more...

Akka 2.1.0 Released

The new Akka 2.1.0 release makes for a nice holiday gift! Akka 2.1.0 now includes cluster support, forming a powerful substrate on which elastic cloud-based applications are built. There are a ton of other new features like support for Apache Camel. Read more...

Jonas Bonér, Typesafe CTO, is Sweden's Top Developer

Every year Computer Sweden creates a list of their country’s top developers. This year we are thrilled that Jonas Bonér, the Typesafe CTO, has been named Sweden’s Top Developer! Jonas created Akka and co-founded Typesafe. He is still actively contributing code to the Akka project while also figuring the next big problems in software. Read more...

SpringSource Releases Spring Scala

Many Java developers use the Spring Framework as the foundation for their applications so it’s great to see direct support for using Spring from Scala. The combination of Spring and Scala means that code for composing applications is concise and elegant. Read more...

Rod Johnson is "writing purely in Scala"

The creator of the Spring Framework and now Typesafe board member, Rod Johnson, was recently interviewed on the TechCast podcast. In the podcast Rod talks about his move from Java to Scala and how he now writes code "purely in Scala." Read more...

Odersky's Functional Programming Course Has 1.7m Lecture Views

This past fall Martin Odersky taught an online class about Functional Programming Principles in Scala. The course was a huge success with more than 50,000 developers viewing lecture videos a total of 1.7 million times! Read more...

2012 was a great year! Stay tuned for more exciting news in 2013 by subscribing to the Typesafe Newsletter!

• Allow null as reply from a TypedActor
• Properly set stateData when stopping an FSM Actor
• Fix a regression introduced in version 2.0.4 within the embedded ForkJoinPool implementation (only relevant for direct users of the JSR166y API)

Please see the full announcement for more details.

Happy hAkking!

19 Pages of Scala Jobz!

The Knoldus Software team has created the Scala Jobz app (built with Scala and Play) to provide a central listing of Scala jobs. There are already 19 pages of jobs! There is no doubt that the job market for Scala developers is huge and growing quickly!

Should You Learn Scala?

Jean Yang, a Ph.D. Computer Science student at MIT, makes a great case for learning Scala, arguing that its libraries and interoperability with Java make it ideal for mainstream adoption. Jean points out that learning Scala makes you more marketable as a developer, since companies like Twitter, LinkedIn, Foursquare and Quora are all looking for hires with Scala skills.

Scala Second Impressions

If you made the leap to Scala and found features lacking or simply were not persuaded, then check out Rod Hilton's Scala Second Impressions blog post. Rod previously shared his early thoughts on Scala about a year ago, and originally had some issues with the compiler, APIs and general youth of the language. But his new article revises these assumptions and makes the delightful statement that "Scala is awesome!"

Scala is like Git

Sander Mak discusses complexity issues surrounding Scala on Branch and Bound, tackling the topic of how the language is often portrayed as being too hard to pick up. Sanders compares these statements to similar arguments around Git, giving the Scala complexity discussion an entirely new perspective.

Scala, the Next Frontier

Finally, if you missed Barb Darrow's article on GigaOm titled "How Martin Odersky rewrote the rules of coding for a mobile world", it's definitely worth reading. Barb outlines the benefits of Scala in a real-world context and links the language to advancements in mobile and cloud environments. Her portrayal of Odersky as "belonging in the same pantheon of programming gods as James Gosling, the father of Java itself; Niklaus Wirth, who wrote Pascal (and with whom Odersky studied); Anders Hejlsberg, of Turbo Pascal fame; and Bjarne Stoustrup, who wrote C++ and other languages," makes us pretty proud!

New Year's Resolution to Learn Scala in 2013

If you've made a resolution to learn Scala in 2013, then get started with the Scala Learning Resources and subscribe to the monthly Typesafe newsletter to follow the latest news.  Here's to a Scalacious 2013!  Happy New Year!

We adapted the Riak and DynamoDB designs to enable Akka nodes to act in concert, but instead of hosting passive units of data, they now support millions of active units of computation—actors. Of course, we hardened and polished the features that made 2.0 such a great release: supervision hierarchies, death watch and distribution by configuration. On top, we added cluster-aware message routers that will automatically add or remove routing targets when you scale your application to match varying performance needs; this is done by adding or removing cluster nodes. It should be noted that these elastic routers are mere users of the new cluster APIs, which means that you can also develop tailored cluster-aware features for your applications if needed..

This brings me to an important point: we marked the cluster support “experimental” because these new APIs have not yet had enough exposure to the great variety of distributed computing problems tackled world-wide. Therefore, we deemed it unwise to freeze our design at this point, and instead will allow it to be refined during the next development cycle based on our users’ feedback. We will keep those changes to a minimum.

Additional key features of Aka 2.1.0 include:

• Integration with the Scala Standard Library: futures have been unified with SIP-14 and akka-actor.jars will be part of the Scala distribution from 2.10 onward
• Akka Camel support
• Encrypted Akka remoting using SSL/TLS
• OSGi support
• A module for multi-node testing to support you in developing clustered applications—experimental in the same sense as cluster support
• A Java API for the TestKit

A series of blog posts highlighting the new features has been published over the past weeks on our team blog, see the “spotlight21” tag. The more technically inclined may also want to peruse the release announcement on letitcrash.com.

We are proud to say that this release contains contributions from many members of our very active community. A special thanks goes to Raymond Roestenburg, Oliver Schulz, Gert Vanthienen, Peter Badenhorst, Piotr Gabryanczyk, Gerolf Seitz, Rick Latrine, Michael Pilquist, Brian Scully, Helena Edelson, Mathias Doenitz, Amir Moulavi and Joshua Gao.

Happy hAkking!

Guest post by Roland Kuhn.

One of the interesting aspects of running a MOOC (massive open online course) is that you get a lot of data out of it. We got statistics on many aspects from the Coursera site. Overall, we had more than 50,000 people registered for the course, who viewed lecture videos 1.7 million times, and handed in 230,000 submissions of homework assignments (people could submit multiple times, and assignments were automatically graded). There were 11,400 posts on the discussion forums, where students could ask questions and discuss aspects of the course. 9,600 students successfully completed the course and earned a certificate of completion. That's a much higher success rate than average for an online course.

We also ran a survey among the people enrolled in the course. More than 7,000 participants filled out the questionnaire. Here's a detailed writeup of the course and the survey results.

For those of you who want to have a little bit of fun with the numbers, we've made all of the data publicly available, and we've made a small Scala project out of it. In particular, we put the code that we used to produce the above plots on github (progfun-stats).

Overall, it was an intense 7 weeks for us as well as the course students. Organizing a MOOC is no small matter. We could not have done it without the help of many people at EPFL, at Typesafe, and the many active and knowledgeable contributors to the forums all over the world.

Hard as the work of preparing and running the course was, the amount of positive feedback we got made it worth for us many times over. We believe this medium has a lot of potential and, so far, we are only scratching the surface.

Martin Odersky and Heather Miller

Scala Leads InfoQ's "Next JVM Language" Poll
InfoQ is polling developers about their "Next JVM Language" and currently Scala leads with 78% saying it's ready for adoption. It is great to have so many developers excited about the future of Scala!

New Release Candidates for Akka, Play, and Scala
Typesafe's open source projects have posted new release candidates:

• Akka 2.1 RC3
• Play Framework 2.1 RC1
• Scala 2.10 RC3

Please try out these releases and let us know if you run into any problems.

Videos from Scala eXchange 2012
The Scala eXchange 2012 conference was packed with great content! In case you weren't there you can still watch the session recordings by going to the session list and clicking a "View the podcast here..." link. Make sure you check out Martin Odersky's Keynote and the other great talks!

Video Leadership Series and Typesafe YouTube Channel
We've launched a new Video Leadership Series and the Typesafe YouTube Channel. The first video in the series was recently recorded at Intel during a San Francisco Scala meetup. James Baldwin, General Manager of the Engineering Division of Intel Media, opens the video with an overview of the value Intel sees Scala playing in the future of software development.

Typesafe Developer Contest Wraps Up with 65 Contenders
The Typesafe Developer Contest challenged developers to build beautiful apps with Play, Akka, and Scala. It was great to see so many developers participate! All 65 submissions are currently being judged and the winners will be announced on the Typesafe Blog.

Gradle 1.3 Improves Scala Support
The Gradle build tool version 1.3 has been released with improved Scala support, including faster Scala compilation and better Scala IDE support.

Make sure you subscribe to the Typesafe Newsletter to get future newsletters by email!

We hope this series will inspire, challenge and motivate all those developers out there looking for the next generation software solution. When we launched Typesafe, we made a commitment to remain at the forefront of software development and to set the agenda for the next wave of programming solutions aimed to tackle the problems of tomorrow. This video series will showcase this commitment by giving all of you a peek into what we think are going to be the next challenges as well opinions on crucial development topics from experts in the field.

We welcome your suggestions on who you'd like to see on camera as well as any questions you might want us to ask these experts! Give us a shout-out on Twitter.

Check out the full version of the first video of the Typesafe Thought Leadership Series on our YouTube channel.

• Fix a divide-by-zero bug in routers
• Fix a wrap-around bug in HashedWheelTimer which would expire timeouts early
• Stop using Unsafe.throwException to allow running on Android
• Configurable worker pool size in remoting to allow running with fewer threads

We strongly recommend updating all projects using the 2.0 series to this version. Please see the full announcement for more details.

Happy hAkking!

A series of short blog posts will "Spotlight" the new Akka 2.1 features on the Akka Team Blog during the upcoming weeks. In fact, there are already four Akka 2.1 Spotlights:

1. Try the new shiny actor DSL in the REPL
2. A circuit breaker for asynchronous calls
3. Get notifications when new nodes joins and leaves the cluster
4. Cluster failure detection hooked hooked up with death watch

More exciting posts are in the pipeline. So stay tuned and watch the Akka Team Blog for more Spotlights!

Scala Moves From "Trial" to "Adopt" in ThoughtWorks Tech Radar

In their latest Technology Radar, ThoughtWorks has moved Scala from the "Trial" category to "Adopt" which according to them means "We feel strongly that the industry should be adopting these items." Read more...

Rod Johnson, Spring Framework Creator, Joins Typesafe's Board

Typesafe is very excited to have Rod Johnson now on the Board of Directors. Rod brings vast experience building successful developer frameworks. Read more...

The Typesafe Developer Contest Open Until November 30

There is still time to enter your Scala, Akka, and Play sample applications in the Typesafe Developer Contest! The deadline is November 30th and now that Rod Johnson is part of Typesafe, he will be doing a strict code review on all submissions. Well... Actually he will just be joining the panel of judges but how cool is that? Read more...

JavaOne 2012 Was Packed with Typesafe Goodness

There were over 15 sessions at JavaOne 2012 that featured Scala, Akka, and Play Framework! Oracle has posted the video recordings of many of these sessions. Here are a few that you may want to check out (video links are under "Presentation Download"):

• Scala 2.10 with Martin Odersky
• Scala Tricks by Venkat Subramaniam
• Concurreny Without Pain in Pure Java by Venkat Subramaniam
• Up, Up, and Out: Scaling Software with Akka by Viktor Klang
• Modern Java Web Development with Play Framework 2.0 by Peter Hausel
• Introduction to the Play Framework by James Ward

DZone Publishes a Scala Refcard

DZone Refcardz are a great way to get started with a new technology and so it is great to see a new Scala Refcard by Jesper de Jong. Go grab your free PDF of the Scala Refcard!

Scala 2.10 RC1 & Akka 2.1 RC1 Have Been Released

The first release candidates of Scala 2.10 and Akka 2.1 have been released! These early releases provide a great way to experiment with new features and catch any last minute bugs. Let us know what you think about Scala 2.10 RC1 and Akka 2.1 RC1!

Klout Scales Out with Scala, Akka, and Play

Klout knew that building on the Typesafe Stack would allow them to easily scale their popular social influence technology. Now they are processing over one billion requests per day through their Play Framework web API server and managing concurrency through Akka. By writing the code in Scala they kept things simple and focused on the core business values instead of the plumbing. Read more...

It's been an exciting month! Make sure you subscribe to the Typesafe Newsletter to get future newsletters by email!

In a nutshell, a worksheet is a Scala file that is evaluated on save, and the result of each expression is shown in a column to the right of your program. This makes it easy to see the execution results of each statement in a Scala app without having to step through a debugger. Worksheets are like a REPL session on steroids. The Scala Worksheet also supports editor completion, hyperlinking, interactive errors-as-you-type, and auto-formatting.  This new release includes a number of fixes related to the worksheet instrumentation.

The worksheet plugin is available for both Scala 2.9 and Scala 2.10.0-RC1.  It can be installed on both Eclipse 3.7 (Indigo) and Eclipse 4.2 (Juno).  Get started by either downloading the ready-to-use Typesafe Scala IDE or reading the Scala Worksheet installation instructions.

For more details about this release, check out the Scala Worksheet article on the Scala IDE blog.

Enjoy the latest release and provide any feedback via the scala-ide-user mailing list.

Rod is truly an authority on Java architecture, a thought leader on open source development and business models, and a popular speaker at conferences around the world. We're honored that he's participating as a judge in our contest.

You can still submit your sample applications that demonstrate the power and functionality of the Typesafe Stack for the chance to win $1000, $500 and $200 for the first, second and third placed entries respectively. And don't forget that every complete entry receives a free t-shirt!

In addition to Rod, entries will be judged by our panel of experts: Martin Odersky, Jonas Bonér, Viktor Klang, Peter Hausel and Josh Suereth.

Get the full details on the developer contest and submit your app before the November 30th deadline!

University Sessions

• First Steps with Scala by Dick Wall and Bill Venners
• Play Framework - Crash Course by Peter Hausel (Typesafe), Sadek Drobi and Guillaume Bort
• Scala Advanced Concepts and Best Practices by Dick Wall and Bill Venners

Tools in Action

• Rapid Application Development with Play 2 by Peter Hausel (Typesafe)

BOFs

• Scala Enthusiasts Gathering by BeScala
• Scala Puzzlers by Andrew Phillips

Labs

• Practical - Scala Koans by Dick Wall and Bill Venners

Conference Sessions

• Effective Scala by Joshua Suereth (Typesafe)
• Simplicity in Scala Design by Bill Venners
• Functional Compilers: From CFG to EXE by Daniel Spiewak
• Up, up, and Out - Scaling Software with Akka by Jonas Bonér (Typesafe)

Make sure you also check out the Belgian Play Meetup and the Typesafe booth! See you at Devoxx 2012!

If you’re just getting started with Scala, we encourage you to head over to DZone and download: Scala: The Scalable JVM Language: http://refcardz.dzone.com/refcardz/scala

Happy coding!

Below are the words spoken by Typesafe co-founder and creator of Scala, Martin Odersky, at Phil's funeral earlier today:

Like many of his friends I am terribly sad to see him go so untimely soon. But I am also thankful for having known him and for the things he brought into our lives.

I met Phil 11 years ago. He came into my office and told me he wanted to write up some nifty ideas on datastructures in an academic conference paper. It was the first time he ventured into that terrain after a successful career in industry. So his question was: How could he make sure the program committee would not steal his ideas?

I told him that program committees are not in the habit of doing that, but in any case, if he had concerns, he could publish a technical report from EPFL, so the precedence of his ideas would be established. So that's what he did. We started to discuss, and I asked him whether he could write a datastructure for a functional programming language that was essentially as efficient as an array. He tweaked his ideas and produced a paper which appeared at the IFL conference in 2002 with the title "Fast Functional Lists". 

Fast forward 10 years and the majority of functional languages out there have a version of the data structure Phil invented.  Arguably, the rise of functional programming in the last 5 years would not have been possible without it. So, Phil happened to influence the development of functional programming to no small degree even though he never wrote programs in a functional language himself.

We then got back together about 5 years ago, when Phil told me that he would like to help us market the Scala language we were working on.  Us academics understood as little of marketing then as Phil understood of academic publishing when he first walked into my office. Phil taught us that marketing is about people, taking their concerns seriously and making them your own. He was great at that.

One outstanding thing he did was organize the Scala Days conferences. We had the first one in 2010 in Lausanne, and Phil made it a huge success, with people being super-enthusiastic and excited. He then repeated this feat twice more, in Stanford, and in London, every time with increasing numbers of speakers and participants. Sadly, the London conference he could no longer attend himself, although his presence was very much felt.

The first Scala Days conference sparked so much enthusiasm that we decided to form a company to support the language, which soon after merged to become Typesafe.  Phil was part of it from day one.  It's fair to say, that, without Phil, there would not have been a Scala Days conference, nor a company like Typesafe.

In all this, Phil is remembered for his touch with people. It's no understatement to say that Phil was the bright light of every group he worked with, whether at EPFL or at Typesafe. Phil was a very kind person, he genuinly understood people, he cared for them, and was attentive to their needs. He was also always positive, seeing the bright side of things and insisting that people have fun. For me, he was a personal friend, that would teach me new ways to approach things, and to whom I could speak about everything in complete confidence. I will very much miss him, and I will keep him fondly in my memories.

General improvements to incremental compilation: 

• With 0.12.1, general incremental compilation should be faster. This is but one step of many towards better builds.

Improved caching and cache documentation:

• Please read the new Dependency Management Flow document for details on how you can improve your experience with sbt’s caching and dependency management in Ivy.

Fixes to forking tests.

Enjoy the latest release and provide any feedback to: simple-build-tool@googlegroups.com

"Back in March, we had just released the Scala Play! Framework API infrastructure that we had been writing the previous few months. Previously, disparate teams were responsible for their own serving infrastructure; now, having a central platform has empowered Klout to scale to a billion API requests per day and export powerful new functionality to partners.  Six months after launch, we’ve made some serious improvements to the API’s scalability and availability using Akka’s rich toolset for concurrent programming. Though Akka is mostly famous for its implementation of the Actor Model, I’m going to talk about two other Akka features, Futures and Agents."

Read the complete story on the Klout engineering blog.

Read more here.

You can read more about it here and the apps are available for download here: iOS and Android

Enjoy the conference!

The Console is an enterprise-grade dashboard for monitoring your application built on the Typesafe Stack, including Akka event-driven middleware.

The Console will be part of a commercially licensed, but free for developers distribution of the Stack. Once an application goes into production, there is a requirement to purchase the Stack with commercial support from Typesafe.

You can find more information about the Console here.

• The memory size setting for Windows 32 bit was too large, leading to errors when starting the JVM
• The PermGen space was too small leading to crashes on some systems

The good news is that we issued a fix and the new downloads are ready on the Stack download page.  Per usual, please file tickets in the upstream project.

Typesafe Scala IDE

To make it easier for new users, today we released the Typesafe Scala IDE, a full-featured IDE based on Eclipse! This is an Eclipse distribution that comes pre-configured and pre-installed with all the right Scala plugins. No more tweaking eclipse.ini, no more updating site configurations! Choose the right download for your platform (all three major OSs are supported) and start developing Scala right away! You can easily stay up to date by using Check for updates to be sure to never miss any new developments!

We hope you'll enjoy using our IDE and, as usual, please file tickets in the upstream project. And, as they say, if there's no screenshot it didn't happen, so here's one:

What’s a kata?

From Wikipedia: “Kata is a Japanese word describing detailed choreographed patterns of movements practised either solo or in pairs. … More recently, kata has come to be used in English in a more general or figurative sense, referring to any basic form, routine, or pattern of behavior that is practiced to various levels of mastery.”

Katas have been used to master everything from the traditional tea ceremony, karate and, for the first time afaik, for mastering Akka.

The Akka kata

We, in the Akka team, sat down one lunch and discussed what “movements” we wanted the kata to cover and a good domain to which we could apply those “movements.” The result was a betting domain in which you should be able to recover everything from small hick-ups to JVM crashes. This would cover some of the essential bits of Akka like:

• Creating actor systems and actors
• Sending and receiving messages
• Scheduling tasks
• Supervising actors and taking appropriate action

Design Overview - Scaffolding

The aim of this kata was to point the student in the right direction. To enable this we created some scaffolding code together with a brief introduction of the Akka concepts that they would need to solve the task ahead. You can find the project here:

https://github.com/henrikengstrom/akka-meetup-sthlm

We also did a very simplified overview of what parts the application consisted of and also what communication between these parts that was needed. You can find the overview here below.

The Meeting

We started off the meeting with a very brief introduction of what Akka is and some of the concepts and features that you use when you build systems with Akka. After that there was a more hands on walk through of the parts of Akka that were relevant to this kata - we call this the Akka green belt examination.

Every meeting participant had a computer and everyone had also installed the scaffolding code beforehand so we asked them to pair up two and two and then get started. Björn and I circled the room, like hawks, answering questions, giving advice while also having a lot of fun. We estimated that they would be able to solve the kata in about two hours time and this seemed like a good estimation. Not everyone was 100% done when we presented the solution proposal, but not far away from a complete solution.

The Solution Proposal

There is no correct way of implementing a system - there are many ways! Therefore you should view the proposal we have made as one solution not the solution.

The above also became apparent when we presented the solution to the group. Many had solved the task a little bit different than the way we had. We discussed pros and cons with the alternatives and also got into the differences between designing a standard n-layered system and an actor based system. Overall a very interesting and productive experience - for both us from the Akka team and the participants in the meeting. We, in the team, feel it is extremely valuable to see how users of Akka apply it to their domains. It is only with this feedback loop we can continue to improve and evolve Akka to become even greater than it already is.

When you are done with your kata you can compare your solution to the proposal we have created: https://github.com/henrikengstrom/akka-meetup-sthlm/tree/solution

About the Senseis

Henrik Engström - @h3nk3

After graduating with a M.Sc. degree in Computer Science in 1998 at the Royal Institute of Technology in Stockholm Henrik has been working as a consultant up until his Typesafe employment in 2011. Henrik has not only vast experience from programming languages but also a great domain knowledge within the financial, retail and e-gambling industries. Apart from his major interest, programming, he is also an avid Arsenal supporter, black belt in Shotokan Karate and a hobby wine connoisseur.

Björn Antonsson - @bantonsson

Björn is a passionate software engineer with a M.Sc. in Computer Science from the Royal Institute of Technology in Stockholm, whose experience ranges from the lowest levels of hardware memory models right through the operating system and the JVM as a founder and longtime developer of JRockit, and straight up into high volume financial data systems and large traffic website.

GUI Improvements

There have been a lot of improvements to the GUI and its related functionality since the last final release (v1.0). Below are some highlights.

Minimized Node Mode

 The nodes can now be viewed in three modes: minimized, normal and expanded. The minimized mode is the new one and it will enable a good overview of many nodes.

Actor Navigation

The actors can now be viewed and navigated in a tree view.

Graph Selection

It is possible to change graphs in each scope view (node, actor system, dispatcher, actor and tag). Available graphs are dependent on in what context they are being shown, i.e. the node view has a set of graphs that may not be available in for example the actor view.  

A new graph is selected by clicking on the upside-down-triangle-icon on a graph and then selecting an option with white text:

Infobox Selection

The structure and selection of an infobox is exactly the same as for graphs (see above).

Zoomed Graph View

It is possible to zoom in on a graph. Just click on the icon in the upper right corner and it will open a popup window containing the graph in a zoomed in view. 

Improved Deviations View with Context Information

The deviations view has been improved with time based ordering of the deviations, context information, i.e. from where the user navigated to the deviations view, and also all types of deviations (errors, warnings, deadlocks,unhandled messages and dead letters) can be viewed.

This version of the Console has been updated to support MongoDB version 2.x (Special thanks to @prasinous who cut a new release of Salat especially for this release of the Console.)

Additional Information about new features

Please see the full documentation of the Typesafe Console for more information about the new, and old, features that the 1.1 version has.

Pricing, Evaluation and Contact Information

Firstly, we invite you to take the online demo of the Typesafe Console for a test drive.

For more information on pricing and arranging an evaluation of the Typesafe Console, as part of the Typesafe Subscription, please contact Typesafe.

In his presentation Martin will be covering some of the exciting Scala 2.10 features, including the new reflection API which allows Scala programmers to explore and interact with a programs structure, and effectively treat the entire program as data itself. Unlike Java's stunted reflection capabilities, Scala 2.10 can obtain a plethora of type information via reflection, and amongst other things is the basis for a powerful macro system that allows for sophisticated compile-time metaprogramming, allowing one to dynamically generate types.

Intel is building a brand new distributed platform atop Scala, and making heavy use of its powerful features to build elegant APIs which leverage the full power of type system. One way such a technique is being used in practice is to give developers compile-time safety when accessing a backend storage system that by default treated all items as indifferent Objects. Not wanting to deal with these overly nondescript types the engineering team constructed an abstraction that provided a type-safe facade, allowing the compiler to then infer all the type information users of that storage system wanted in their programs. In addition to designing such APIs, Intel makes strong use of community tools such as the Akka concurrency toolkit, which helps in solving some of the inherent problems associated with distributed systems, whilst producing a final product that is fast, reliable and very high-quality.

To attend this event, please sign up here. For more information about how Scala is used at Intel or to discuss employment opportunities, please contact Fui Meng Liew (fui.meng.liew@intel.com).

This summer, we've been running a guest blogging contest called the "Akka Summer of Blog" on the Akka Team blog at letitcrash.com.

The winner of the contest will recieve an exclusive, black Akka Team hoodie, signed by Akka tech lead Viktor Klang (aka √). Every author of an accepted post will receive an Akka T-shirt. 

The competition ends Aug 31st, so submit your entries soon. Read all the details here. We already have a few posts published, tagged as «summer of blog», which you can use as inspiration. Good luck!

What do we plan to do with this additional capital? Simply put, we'll continue on the journey we started when we formed Typesafe last year: to build the most scalable software platform for the computing architectures of the future—multicore, parallel and cloud applications. 

This will include additional investments in the Typesafe Stack -- including Scala, Akka, Play, and Slick -- as well as supporting infrastructure such as the Scala IDE for Eclipse, sbt, and zinc. 

We'll continue to enhance the commercial maintenance, support, and management capabilities in the Typesafe Subscription (including the Typesafe Console), and Typesafe's training and services capabilities.

And perhaps most importantly, we'll ramp up our efforts to bring Typesafe technologies to a broader audience, so that they can enjoy the benefits experienced by early adopters like Juniper Networks, who commented:

"The Typesafe Stack enables us to leverage the most recent advances in large-scale parallel processing and distributed computing while building on existing investments in Java."

If you are new to Typesafe and Scala, don't miss your opportunity to get involved by joining Scala creator Martin Odersky's upcoming free 7-week online Scala course at Coursera, which kicks off on September 18.

And yes -- we're hiring.

We’ve separated out sbt’s incremental compiler and made it more widely available through a build compiler called Zinc. Zinc has already been integrated with the Scala Maven Plugin and is currently being integrated with a new build tool developed at Twitter called Pants.

Zinc

Zinc is a stand-alone version of sbt’s incremental compiler. It comes with a command-line interface and built-in Nailgun integration. Zinc can be used as an alternative to scalac, adding incremental compilation, and as an alternative to fsc, serving as a build daemon.

Running with Nailgun provides Zinc as a server, communicating commands via a client, keeping cached compilers in a warm running JVM and avoiding startup and load times. This gives the same benefits and performance as sbt’s interactive shell.

Scala Maven Plugin

Compiling with Zinc has been added to version 3.1 of the Scala Maven Plugin, bringing incremental compilation for both Scala and Java to Maven. We’ve also added support for talking to a Zinc server, which can improve compilation speeds dramatically.

Example

As a realistic example I’ve taken the first few modules of Akka 2.0 and set them up as a Maven project. The modules are akka-actor, akka-testkit, and akka-actor-tests, with both Scala and Java sources, and akka-testkit has both main and test sources. I’m running this example on a MacBook Air.

Let’s first look at a regular clean compile of all the code, without incremental compilation:

% mvn clean test-compile

[INFO] akka ................ SUCCESS [1.088s]
[INFO] akka-actor .......... SUCCESS [43.187s]
[INFO] akka-testkit ........ SUCCESS [28.756s]
[INFO] akka-actor-tests .... SUCCESS [59.122s]
[INFO] ------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------
[INFO] Total time: 2:12.289s

Okay, that gives us a baseline.

Now let’s add incremental compilation. This is enabled by setting the recompileMode configuration option to incremental. Here’s a full clean compile with incremental enabled:

% mvn clean test-compile

[INFO] Compiling 69 Scala sources and 75 Java sources to akka-actor/target/classes...
[INFO] Compiling 9 Scala sources to akka-testkit/target/classes...
[INFO] Compiling 5 Scala sources and 1 Java source to akka-testkit/target/test-classes...
[INFO] Compiling 83 Scala sources and 9 Java sources to akka-actor-tests/target/test-classes...

[INFO] akka ................ SUCCESS [1.074s]
[INFO] akka-actor .......... SUCCESS [47.382s]
[INFO] akka-testkit ........ SUCCESS [32.702s]
[INFO] akka-actor-tests .... SUCCESS [1:18.782s]
[INFO] ------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------
[INFO] Total time: 2:40.081s

This takes a little longer because the incremental compiler analyzes the compilation so that it knows how the sources relate to each other. For this project it adds around 20% overhead for a full compile.

Now that we’ve compiled everything, with the incremental analysis ready, let’s try changing just one of the tests in akka-actor-tests, in this case ActorRefSpec.scala, and recompile everything:

% mvn test-compile

[INFO] Compiling 1 Scala source to akka-actor-tests/target/test-classes...

[INFO] akka ................ SUCCESS [1.050s]
[INFO] akka-actor .......... SUCCESS [1.617s]
[INFO] akka-testkit ........ SUCCESS [0.461s]
[INFO] akka-actor-tests .... SUCCESS [13.604s]
[INFO] ------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------
[INFO] Total time: 16.878s

Perfect, only the changed file was recompiled.

What about a much more pervasive change? Let’s change the Actor trait, which will affect most of the codebase, and see what happens:

% mvn test-compile

[INFO] Compiling 1 Scala source to akka-actor/target/classes...
[INFO] Compiling 48 Scala sources and 4 Java sources to akka-actor/target/classes...
[INFO] Compiling 5 Scala sources to akka-testkit/target/classes...
[INFO] Compiling 5 Scala sources to akka-testkit/target/classes...
[INFO] Compiling 5 Scala sources to akka-testkit/target/test-classes...
[INFO] Compiling 65 Scala sources and 3 Java sources to akka-actor-tests/target/test-classes...
[INFO] Compiling 46 Scala sources and 4 Java sources to akka-actor-tests/target/test-classes...

[INFO] akka ................ SUCCESS [1.061s]
[INFO] akka-actor .......... SUCCESS [40.546s]
[INFO] akka-testkit ........ SUCCESS [36.294s]
[INFO] akka-actor-tests .... SUCCESS [1:45.205s]
[INFO] ------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------
[INFO] Total time: 3:03.249s

So in this case it actually takes longer than a clean compile, which is useful to know. The logging shows the files being compiled, starting with the initial invalidation of Actor.scala and then subsequent compiles triggered from this change.

Nailing it

When compiling from sbt’s interactive shell, the JVM is warm and the classloader containing the Scala compiler is reused. This reduces a lot of startup and load time. Zinc supports similar warmth through running as a Nailgun server, and the Scala Maven Plugin supports running as a Zinc client. This can be enabled alongside the incremental recompilation configuration option by setting useZincServer to true.

Let’s look at the same example compiles as above, a clean compile, a change at one of the leaves of the source tree, and a fundamental change, but using a Zinc server. First, we need to start Zinc:

% zinc -start

Now a full clean compile:

% mvn clean test-compile

[INFO] akka ................ SUCCESS [1.094s]
[INFO] akka-actor .......... SUCCESS [47.747s]
[INFO] akka-testkit ........ SUCCESS [12.196s]
[INFO] akka-actor-tests .... SUCCESS [48.081s]
[INFO] ------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------
[INFO] Total time: 1:49.261s

This is already faster than the earlier clean compiles, with or without incremental compilation, as the same Zinc compiler is reused across the four compile runs.

This will get faster again as the JVM warms up. Let’s try five more full clean compiles and then see what we have:

% mvn clean test-compile

[INFO] akka ................ SUCCESS [1.443s]
[INFO] akka-actor .......... SUCCESS [13.199s]
[INFO] akka-testkit ........ SUCCESS [6.268s]
[INFO] akka-actor-tests .... SUCCESS [33.751s]
[INFO] ------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------
[INFO] Total time: 54.890s

Nice! This is almost a third of the time compared to the full clean compile with a cold incremental compiler. The warm incremental compiler, after a handful of compiles, knocks 60% off the time of the baseline clean compile.

Let’s try the change to one of the tests, ActorRefSpec.scala:

% mvn test-compile

[INFO] Compiling 1 Scala source to akka-actor-tests/target/test-classes...

[INFO] akka ................ SUCCESS [1.044s]
[INFO] akka-actor .......... SUCCESS [0.781s]
[INFO] akka-testkit ........ SUCCESS [0.223s]
[INFO] akka-actor-tests .... SUCCESS [2.910s]
[INFO] ------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------
[INFO] Total time: 5.096s

The total time is a third of the cold compile time. The akka-actor-tests module which contains the changed file is compiled in 2.9 seconds, compared with 13.6 seconds. Four times faster.

And the change to the Actor trait, triggering widespread recompilation:

% mvn test-compile

[INFO] Compiling 1 Scala source to akka-actor/target/classes...
[INFO] Compiling 48 Scala sources and 4 Java sources to akka-actor/target/classes...
[INFO] Compiling 5 Scala sources to akka-testkit/target/classes...
[INFO] Compiling 5 Scala sources to akka-testkit/target/classes...
[INFO] Compiling 5 Scala sources to akka-testkit/target/test-classes...
[INFO] Compiling 65 Scala sources and 3 Java sources to akka-actor-tests/target/test-classes...
[INFO] Compiling 46 Scala sources and 4 Java sources to akka-actor-tests/target/test-classes...

[INFO] akka ................ SUCCESS [1.025s]
[INFO] akka-actor .......... SUCCESS [10.854s]
[INFO] akka-testkit ........ SUCCESS [8.779s]
[INFO] akka-actor-tests .... SUCCESS [57.491s]
[INFO] ------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------
[INFO] Total time: 1:18.289s

Using the Zinc server gives us sbt-like compilation from Maven, and a warm incremental compiler can compile code twice as fast, or even faster. Incremental compilation can also be used with the continuous compile (scala:cc) goal in the Scala Maven Plugin. For more information about using incremental compilation in Maven see the documentation for Scala Maven Plugin.

Pants

Pants is a build tool developed at Twitter and is modeled after Google’s build system. It’s intended to support selective compilation within large, heterogeneous codebases with an explicitly-modeled DAG structure. Pants is used internally at Twitter and at foursquare, and is also used to build the twitter/commons open-source project.

Until recently, Pants invoked the scala compiler directly. If any file in a DAG node changed, the entire node and anything depending on it had to be rebuilt. Benjy Weinberger from foursquare is currently working on integrating Zinc with Pants, so that it too can enjoy the benefits of incremental Scala compilation:

The tricky part of this integration is the fact that Pants contains its own node-level invalidation logic. Pants also has options to both ‘flatten’ and ‘unflatten’ the build.

The advantage of the non-flat mode is that the compiler only has to bite off small chunks at a time. In small codebases this is slower than building everything in a single pass, because you incur the compiler startup overhead multiple times (although Zinc’s cached compilers can help with this). However in large codebases it can be impractical to build everything in a single pass. Building a couple of thousand Scala source files may require 8GB or more of RAM and can take 20-30 minutes. Breaking the codebase down into a modular DAG, and applying Zinc’s incremental compilation to each node, supports effective builds and fast rebuilds even in a large codebase.

The combination of Pants and Zinc will allow companies like Twitter and foursquare to work productively in a single shared, large-scale codebase, even if any individual developer only builds a small subset of the codebase.

Summary

We’ve separated out sbt’s incremental compiler and made it available both stand-alone and ready for integration with other build tools. Using Zinc as a build daemon, similar to sbt’s interactive shell, can dramatically improve build times. Zinc has already been integrated with the Scala Maven Plugin, and we’re expecting incremental compilation to find its way into other build tools for Scala. Zinc is also being integrated with Pants, a build tool for large-scale codebases.

Enjoy!

Slick provides a framework for Scala programmers to easily connect to databases (both relational and NoSQL) and other data sources. Slick makes it even easier for developers to build next-generation distributed applications using Scala, and points to the maturation of the ecosystem around Scala. Making Scala easily interoperable with these databases is a testament to the growth in interest from developers of all backgrounds to leverage Scala for the next wave of applications that need to be highly scalable.  

According to Michael Azoff, principal analyst with Ovum: "Slick, the database connector, will enhance the capabilities of Scala in multiple dimensions including web, parallel scalability across multiple cores, and horizontal scalability across multiple machines." 

With more modern, efficient database query and access capabilities, Slick delivers a powerful database integration framework for Scala programmers. 

Key features of the Slick database connector include:

• Work with stored data as if they are normal Scala collection
• Retain full control over when a database access happens and which data is transferred
• Write your database queries in Scala instead of SQL, thus profiting from the static checking, compile-time safety and compositionality of Scala.

Slick features an extensible query compiler that can generate code for different backends. The following database systems are initially directly supported for type-safe queries:

• Derby/JavaDB
• H2
• HSQLDB/HyperSQL
• Microsoft Access
• Microsoft SQL Server
• MySQL
• PostgreSQL
• SQLite

Accessing other database systems is possible, with a reduced feature set.  Slick features an extensible query compiler that can generate code for different backends, and we look forward to additing support for more data sources in the future.

To learn more about today's announcement, please visit the project web site at: slick.typesafe.com

You can try out the new version at http://console-demo.typesafe.com. Please contact us if you are interested in an evaluation account. We appreciate your feedback so that we can continue to evolve the product in the right direction. In this blog post we will highlight a few of the new features.

Time Periods

It is now possible to specify the time period as either rolling or historical. This is done in the search field or by selecting predefined filters (see images below). The specified time period affects all time series graphs and aggregated statistics. (Please note that the demo only keeps 20 minutes of data which means that any searches outside of the last 20 minutes will not return any result.)

Graphs and Infoboxes

The expanded view of a scope now contains three graphs and infoboxes respectively (see image below). All views have the same layout. Animation, key metrics and throughput in the collapsed view and 3 graphs plus 3 infoboxes in the expanded view.

When you mouse-over any graph/infobox icons will appear in the upper right corner of that component (see image below).  

Clicking on the upside down pyramid icon will either open up a menu from which you can select a graph/infobox (see image below). Selecting an item will change the underlying graph/infobox of that component.

Clicking on the box icon will open up the underlying graph in a zoomed mode. 

Latency Scatter and Spans

We have also added a latency scatter plot which is one of the most useful new graphs.

Each dot represents a span duration. The measured duration depends on selected span type. Default span type is "message", which is the time measured from when the message was sent until the message processing has completed in the receiving actor. You may define marker spans that start and end in any location in the message trace, i.e. it may span over several actors. Another built in span type is "receive", which is the message processing time inside the actor, i.e. the receive function. You specify the span type in the search field.

Aggregated statistics is now also be grouped by actor system, i.e. you can monitor several actor systems running in the same or separate JVMs.

Deviation View

It's also worth mentioning that the deviation view has been improved. 

All deviations are sorted on time with the most current first in the list.

More information

Please see the full documentation of the Typesafe Console for more information.

We invite you to take the online demo of the Typesafe Console for a test drive.

Finally, for more information on pricing and arranging an evaluation of the Typesafe Console, as part of the Typesafe Subscription, please contact Typesafe.

This course offers the opportunity to learn online directly from the creator of Scala!

You'll discover the elements of the functional programming style and learn how to apply them usefully in your daily programming tasks. You will also develop a solid foundation for reasoning about functional programs, by touching upon proofs of invariants and the tracing of execution symbolically. 

The course is hands on; most units introduce short programs that serve as illustrations of important concepts and invite you to play with them, modifying and improving them. It will be complemented by a series of assignments, most of which are also programming projects.

The first session is 7 weeks long and begins September 18, 2012. The class will consist of lecture videos, which are between 6 and 15 minutes in length. These contain integrated quiz questions per video. There will also be standalone homeworks that are not part of video lectures, and a final exam. The expected workload is 5-7 hours/week.

Students who successfully complete the class will receive a certificate signed by the instructor.

View the full syllabus and register to participate for free today at Coursera!

And if you are planning to register, start preparing today with a free sample of the Scala for the Impatient e-book (one of the suggested course texts) from Typesafe.

We think this commitment by Juniper is an exciting validation for Typesafe, and the broader Akka and Scala communities.

Juniper chose the Typesafe Stack for building next-generation networking products because it allows them to:

• Efficiently utilize today and tomorrow's multi-core hardware
• Boost the productivity of their software developers
• Create highly available distributed software based on Akka middleware

Will Eatherton, vice president of Engineering, Core Routing Business Unit at Juniper Networks, comments:

"The Typesafe Stack, including the Scala programming language and Akka middleware, represents a fresh approach to software development. By leveraging the Typesafe Stack, Juniper developers will be able to quickly and reliably create distributed software based on Akka middleware that can scale to take advantage of modern multi-core processors."

It’s been a busy few months at Typesafe. In addition to this Juniper announcement, we recently announced the Mark Brewer has joined Typesafe as CEO, coming from VMware/SpringSource; Typesafe was named to Gartner’s Cool Vendors in Application Development 2012; we hosted a sold-out Scala Days 2012 conference in London; and we released the Typesafe Stack 2.0 featuring Akka 2.0 and Play web framework 2.0.

For more details on the Juniper news, visit the press release in our news section. To stay informed on Typesafe news, follow us on Twitter or sign up for our email newsletter.

It’s been a great experience working with the talented team at Juniper Networks so far. We’re looking forward to continuing this exciting collaboration.

Mark joins us from VMware, where he served as VP of Business Operations for VMware’s Cloud Application Platform. At VMware, Mark was responsible for a portfolio of platform technologies including SpringSource, RabbitMQ, Gemstone and WaveMaker.

Mark arrived at VMware through the acquisition of SpringSource, where he was VP and GM of Enterprise Services. Mark played a key role in the definition and delivery of SpringSource's enterprise subscription offerings. He joined SpringSource when it acquired Covalent, provider of commercial services for Apache technologies including Tomcat, where he was CEO.

It's pretty evident that Mark's leadership credentials and domain expertise are a great fit for Typesafe. But from the first time we met him, we knew that Mark shared an even more important trait with the rest of the Typesafe team: a passion to fundamentally change the way the world builds software.

Welcome, Mark. We look forward to scaling Typesafe with you.

Preparation for Scalathon 2012, July 27-29 in Philadelphia, is well underway. In addition to the coding and social attractions of last year's successful event, this year's Scalathon provides opportunities for Scala training.

Typesafe and our partner Chariot Solutions are offering three Scala training classes in conjunction with Scalathon. Even better, Scalathon attendees are eligible for substantial discounts on the training fees.

The week prior to Scalathon, Chariot Solutions is offering the Fast Track to Scala course, probably the best way to dive head-first into Scala.

The week of Scalathon, Typesafe is offering Fast Track to Play and Fast Track to Akka, two of the exciting and powerful components of the Typesafe Stack.

With the discounts, these courses are a terrific value. If you've been waiting for a good opportunity to pester your employer to send you to Scala training, that opportunity is here. See the Scalathon Training page for complete details on the training offerings, including money-saving discounts codes.

And even if you can't make the training, please join us at Scalathon 2012. Last year was fun and informative. We're hoping this year will be even better.

Starting today, Typesafe is offering a free preview of Josh Suereth's new work, Scala in Depth, when you sign up for the Typesafe e-mail newsletter.

Scala in Depth is a unique new book designed to help you integrate Scala effectively into your development process. By presenting the emerging best practices and designs from the Scala community, it guides you through dozens of powerful techniques example by example.  There's little heavy-handed theory here—just dozens of crisp, practical techniques for coding in Scala. 

Topics in the full book include:

• Concise, expressive, and readable code style
• Integrating Scala into your existing Java projects
• Scala's collections API
• How to use actors for concurrent programming
• Mastering the Scala type system Scala's OO features—type member inheritance, multiple inheritance, and composition
• Functional concepts and patterns—immutability, applicative functors, and monads

The free sample PDF available from Typesafe includes a subset of the book, including:

• Chapter 1: Scala - A blended language
• Chapter 2: The core rules
• Chapter 9: Actors

As an added bonus, when you sign up for the Typesafe mailing list and download the book sample, we'll send you a discount code for 38% off the full book in print and eBook formats at manning.com.

We're proud to have Josh as part of the Typesafe team, and glad to offer a sample of his exciting new work. Download your free copy from Typesafe here.

VMware announced today that Cloud Foundry now supports Play 2.0 as a first-class framework.

Cloud Foundry is an open platform-as-a-service, providing a choice of clouds, developer frameworks and application services. Initiated by VMware, with broad industry support, Cloud Foundry makes it faster and easier to build, test, deploy and scale applications. It is an open source project and is available through a variety of private cloud distributions and public cloud instances, including CloudFoundry.com.

Play framework, part of the Typesafe Stack, is a lightweight, stateless, web-friendly framework for Java and Scala. Developers can leverage this event-driven non-blocking IO architecture to build highly scalable applications. Play 2.0 applications can now be deployed to CloudFoundry.com and take advantage of being a fully supported framework that includes auto-reconfiguration, simplified service connections, and automatic database management. 

Cloud Foundry joins Heroku, Cloudbees, Jelastic, and other platform-as-a-service providers with first class support for Play 2.0.  Give it a test drive today!

Migration Manager gives Scala project owners the ability to test their projects for binary compatibility with prior versions. Migration Manager has already been used to ensure binary compatibility for the 2.9.x series of Scala releases, and we look forward to seeing other projects in the Scala ecosystem adopt it soon.

While Migration Manager has been available for download free of charge since its inception, Typesafe has now made the source code available under the Apache License 2.0 in this GitHub repository. Please check it out and contribute!

Migration Manager provides the ability to detect binary incompatible changes between two versions of the same project. This can be done in one of three ways:

• A rich user interface
• A command line tool
• An SBT (Simple Build Tool) plugin

Rich User Interface

The rich user interface is the same interface that has been available for the life of the tool. You can find a more detailed getting started guide at Migration Manager - Step by Step guide.

Command Line

With the open-source release of the Migration Manager, a command line interface has been added. You can download the standalone jar here.

Here’s how to invoke it:

java -jar path/to/mima-reporter-assembly-0.1.3.jar \
  --prev previous.jar \ 
  --curr current.jar
Found 0 binary incompatibiities
===============================

SBT Plugin

The Migration Manager also provides an SBT plugin for usage within SBT.

To use it, add the following lines to your project/plugins.sbt file:

resolvers += Resolver.url("sbt-plugin-releases", 
  new URL(
"http://scalasbt.artifactoryonline.com/scalasbt/sbt-plugin-releases/"))(Resolver.ivyStylePatterns)

addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % "0.1.3")

And then in your build.sbt, configure the migration manager so that it knows which artifact to use for testing binary compatibility:

import com.typesafe.tools.mima.plugin.MimaPlugin.{
    mimaDefaultSettings, 
    previousArtifact
  }

mimaDefaultSettings

previousArtifact := Some("organization" % "artifact" % "1.0")

In the above, the previousArtifact setting is used to resolve the previous version of your project, using the resolvers defined in your project, and compare the current class files to the previous version. To run the test, call the mima-report-binary-issues task from the SBT prompt.

Summary

We’re excited to make this open source contribution, and we look forward to collaborating with the Scala community to continue to improve Migration Manager.

For downloads and to learn more, please visit the Migration Manager page on the Typesafe web site.

This is a maintenance release with improvements and bug fixes, and includes Akka middleware 2.0.1, Scala 2.9.2, and Play framework 2.0.1.

Highlights of this release include:

• Updated SBT to 0.11.3, with support for Scala 2.10 and new default repositories
• Updated Giter8 to 0.4.5, with fixes for github authentication issues and support for SBT 0.11.3

The update release is available at the Typesafe Stack download page.

The Typesafe Console is a tailor-made tracing and monitoring solution for event-driven Akka actor based systems. The Typesafe Console captures the events that comprise your application’s asynchronous processing, links those events into meaningful trace flows across actors and remote nodes, and makes this information actionable to developers and operations staff through a rich web-based user interface.

You can try the new online demo at http://console-demo.typesafe.com.

The Typesafe Console is part of the commercial Typesafe Subscription. Please contact us if you are interested in an evaluation account. We appreciate your feedback so that we can continue to evolve the product in the right direction.

In this blog post we will highlight a few of the new features.

What's New in 1.1-M2

It is now possible to specify the time period as either rolling or historical. This is done in the search field or by selecting predefined filters. The specified time period affects all time series graphs and aggregated statistics. (Please note that the demo only keeps 20 minutes of data.)

Several graphs and boxes with numerical information have been added to each view. You can pick 3 graphs and 3 info boxes for display in each view. All views have the same layout. Animation, key metrics and throughput in the collapsed view and 3 graphs plus 3 info boxes in the expanded view.

Latency scatter plot is one of the most useful new graphs.

Each dot represents a span duration. The measured duration depends on selected span type. Default span type is "message", which is the time measured from when the message was sent until the message processing has completed in the receiving actor. You may define marker spans that start and end in any location in the message trace, i.e. it may span over several actors. Another built in span type is "receive", which is the message processing time inside the actor, i.e. the receive function. You specify the span type in the search field.

Aggregated statistics is now also be grouped by actor system, i.e. you can monitor several actor systems running in the same or separate JVMs.

It's also worth mentioning that the error view has been improved. 

You find links from all views in the Errors info box, as you can see in above screens for the node and actor system. All deviations are sorted on time with the most current first in the list.

More information

Please see the full documentation of the Typesafe Console for more information.

We invite you to take the online demo of the Typeafe Console for a test drive.

Finally, for more information on pricing and arranging an evaluation of the Typesafe Console, as part of the Typesafe Subscription, please contact Typesafe.

This is primarily a maintenance release with improvements and bug fixes, and includes Akka 2.0.1, Scala 2.9.2, Play framework, and an improved installer.

In this milestone there are a whole lot of new features for you to try out: implicit highlight, move refactoring, a Scala debugger and semantic highlight are some of the most exciting ones. If you are like us, once you start using them you will no longer be able go back. They are simply too addictive!

Let’s have a quick round at the new available features.

Implicit Highlight

Implicits are a powerful Scala construct, but it is often hard to guess when they are applied. With implicit highlight you get immediate visual feedback in the editor and, by pressing Cmd/Ctrl+1, you can turn an implicit into an explicit call. Read more…

Mantra: de-obfuscate code!

Move Refactoring

There is a new refactoring available in your toolbox. Move refactoring will let you move a source file between packages or extract a class/object/trait definition (from a file with multiple definitions) and move it to a new location. And, of course, it will make sure to keep your imports sane. Read more…

Forget copy/paste!

Scala Debugger

You have been asking for better debugging support, we have been listening.

A few weeks ago we started to work on a full-fledged Scala Debugger and today you can have an early look at what is going to offer. As of now, you can already step through closures and have a Scala-aware display of debugging information. Read more…

Profit.

Semantic Highlight

Semantic highlight colors identifiers based on their meaning, which goes a long way into improving readability. All the contextual information about identifiers are available right at the usage site, which means you no longer need to jump to the declaration to tell what kind of Scala element you are looking at. Read more…

Embrace semantic highlight and say “au revoir” to the old habit!

A glance at the future

While we are really excited about this milestone, we are already working on the next “big things” planned for 2.1. One important addition is the creation of an API to ease the development of plugins on top of the Scala IDE. We are confident that this will incentivize developers, and hopefully we will soon have an exciting plugins’ ecosystem.

Have a look at the Roadmap and see what is planned next.

Install it now!

Follow this link and grab the update-site!

This milestone is available only with Scala 2.9 and it works with Eclipse 3.7 (Indigo). We developed and tested it using Java 6, but Java 7 can be used with some caveats.

We hope you will enjoy using it and, please, let us know what you think. This is the perfect time to help us with ideas and improvement suggestions, or just contribute them.

Thanks

We would like to take the opportunity to thank all contributors for the amazing work they have done to make this milestone possible. Special thanks go to David Bernard, Luc Bourlier, Mirco Dotta, Iulian Dragos, Jeremy Heiner, Dan Kilman, Heather Miller, Jin Mingjian, Eric Molitor, Martin Odersky, Hubert Plociniczak, Matt Russell and Mirko Stocker.

The Typesafe Stack is a comprehensive platform for building applications in Java and Scala that can scale to the largest workloads in cloud computing and virtualized datacenter environments. The Typesafe Stack includes the Scala programming language, Akka event-driven middleware, and now the Play web framework, along with a robust suite of development tools.

Since we have a lot to talk about today, we’ve broken the news up into a few different blog posts. Here, we provide the highlights with links for you to dig deeper.

We’ve also posted a new whitepaper on our web site that goes into more depth on the Typesafe Stack 2.0, and why it's relevant to today's professional software developers.

Play 2.0

We announced in November that Play framework, the highly productive web framework for Scala and Java, would become part of the Typesafe Stack. Now, just a few months later, we are happy to announce that Play 2.0 has arrived and is part of the open source Typesafe Stack 2.0 and the commercial Typesafe Subscription.

Play framework 2.0 continues the emphasis on web developer productivity that has always separated Play from the pack. Version 2.0 takes the framework to a new level, with a stable and scalable foundation based on Scala and Akka, and a reactive model based on event-driven, non-blocking IO. All with native support for both Java and Scala applications.

Learn more about Play 2.0 in our blog post: Introducing Play 2.0

Akka 2.0

Just last week we announced the open source release of Akka 2.0, the event-driven middleware framework for building high performance, reliable, and distributed applications in Java and Scala. Now, it’s available as part of the Typesafe Stack and the commercial Typesafe Subscription as well.

Akka 2.0 simplifies the creation of distributed applications that span many nodes in a cloud computing or virtualized datacenter environment, with new features including location transparency, configuration-based deployment, supervision and life-cycle monitoring, and dramatic performance and scalability improvements.

Learn more about Akka 2.0 in our blog post: Introducing Akka 2.0

Typesafe Console

Monitoring distributed event-driven systems at scale can be a challenge. That’s why we’re excited to introduce the Typesafe Console, an enterprise-grade dashboard for monitoring applications built on the Typesafe Stack. The Typesafe Console is exclusively available to Typesafe Subscription customers.

The Typesafe Console provides insight into usage trends and performance characteristics of event-driven Akka actor based systems. It enables your staff to optimize system performance and detect bottlenecks before they become a problem.

Learn more about the Typesafe Console in our blog post: Introducing Typesafe Console

Scala IDE for Eclipse 2.0

Great platforms require great developer tools.  That's why we're delighted to have recently released the Scala IDE for Eclipse 2.0, which provides advanced editing and debugging support for the development of pure Scala and mixed Scala-Java applications.

Learn more about the IDE in our blog post: Scala IDE for Eclipse 2.0

Typesafe Subscription and Services

The Typesafe Subscription provides commercial support, maintenance, and deployment tools for the open source Typesafe Stack. With this release, the Typesafe Subscription covers the Play web framework in addition to Scala and Akka, and adds the Typesafe Console for monitoring Typesafe Stack applications. Typesafe also provides training and consulting for Scala, Akka, and now the Play web framework.

Learn more about commercial services on our web site: Typesafe Products and Services

Putting It To Work

Great technology is meaningless unless it can be productively applied. That’s why we’re so excited to be working with organizations ranging from the smallest startups to the largest global financial institutions who are adopting the technology in the Typesafe Stack. A case in point is Klout, the fast growing startup that measures influence online. Felipe Oliveira, Lead Application Services Engineer at Klout, makes the case for our stack well:

We were able to scale to billions of API transactions with a very small team with the extensive use of Play and Akka. Scala has also been a powerful development platform for Klout, offering greater scalability and efficiency than our previous platform.

Learn more about how Klout is using Play framework and the Typesafe Stack in this post on the Official Klout Blog.

Download the Typesafe Stack today, and get started taking your own business to the next level. We’ll be there to support you every step of the way.

Starting today, the Typesafe Subscription includes the Typesafe Console, an enterprise-grade dashboard for monitoring your application built on the Typesafe Stack, including Akka event-driven middleware. The Typesafe Console is exclusively available to Typesafe Subscription customers.

The Typesafe Console is a tailor-made tracing and monitoring solution for event-driven Akka actor based systems. The Typesafe Console captures the events that comprise your application’s asynchronous processing, links those events into meaningful trace flows across actors and remote nodes, and makes this information actionable to developers and operations staff through a rich web-based user interface.

The Typesafe Console provides insight into usage trends and performance characteristics of the running system. The Console enables your staff to optimize system performance and detect bottlenecks before they become a problem, but also to understand reasons for current or historical problems.

Typesafe Console monitoring has been carefully designed to be always active in high-volume production environments with a minimal impact on performance. For high transaction rate systems it provides measurement sampling to reduce the overhead and amount of data.

In addition to the web user interface, aggregated metrics and detailed trace flows are also accessible through a REST and JMX API, for easy integration with third party monitoring and operations tools. Both historical and current monitoring information is available, which makes it possible to compare across time and analyze trends. The information can be scoped: by node, groups of actors, or even drilling down to individual actors.

The Typesafe Console includes probes to collect the following information from a Typesafe Stack based system:

• message rates and peaks
• individual trace events linked as trace trees or spans
• latency between predefined or user defined points
• latency distributions
• actor supervisor hierarchies
• actor mailbox queue size and delays
• actor message dispatcher status
• status of remoting and system errors
• metadata about the system
• JVM and OS health

You can look at the console for a live demo application here.

Graphical Console

This is what the dashboard looks like. Key metrics visualized in nice-looking graphs, animations and numbers.

And here’s a closer look at the system overview, which displays information about the whole system.

A node corresponds to a ActorSystem, and typically also a JVM. The circle gives a quick overview of the current health of the node, and whether any errors have occurred. Details about the errors, including the full tree of trace events are one click away.

Actors can be grouped into logical units using tags, and statistics are aggregated for all actors associated with a given tag.

Another interesting way of grouping statistics for the actors is by their message dispatcher. Insight to the dispatcher status, such as number of active threads, is also available.

At the lowest level of detail you can see individual actors.

How to Find a Bottleneck

Let’s walk through one of many useful features of the console.

Mailbox queues are interesting to monitor in an actor system. An increasing number of messages waiting in mailboxes is an indication of a problem. If mailboxes are growing constantly it is a fatal problem (memory will be exhausted).

Directly in the system overview pane you see Max mailbox size. In this example, the value is not very high, but several messages are waiting in the queue. The Max time in mailbox also makes us curious, because a half second of waiting time is more than we would expect.

We click on the Max mailbox size or Max time in mailbox value to go directly to the actor with the potential problem.

In the graphs for the mailbox we can see that we have peaks in both the size and wait time, and it looks like they correlate with the peaks in the message throughput. The good news is that the actor is capable of processing the queue before the next peak of messages. The mailbox size is not increasing continually so it’s not a big worry, but the application would not be able to handle a sustained load corresponding to the message rate of the peaks.

Let’s compare with another actor. As you see the mailbox graphs for ActorA and ActorB looks very different. Note the scale of the y-axis.

Technical Details

Please see the full documentation of the Typesafe Console for more information.

We invite you to take the online demo of the Typeafe Console for a test drive.

Finally, for more information on pricing and arranging an evaluation of the Typesafe Console, as part of the Typesafe Subscription, please contact Typesafe.

While you're here, don't miss our other recent posts introducing the Typesafe Stack 2.0, Play 2.0, and Akka 2.0.

Let's see some of the highlights!

Native Java and Scala Support

While the original version of the Play Framework was written primarily in Java (and provided Scala support through a plug-in), Play 2.0 embraces Scala more completely. Not only has Play’s core transitioned to Scala, but the new release also makes the Scala language a first class citizen for developing Play applications. As a result, the new version of the framework now provides two equally polished sets of APIs: one for Scala developers and one for Java developers.

A Controller class using Java

Rapid Application Development

One of the features that provided the “Play feel” in the 1.x series of releases was the development console and browser-based error reporting. Play 2.0 greatly extends these capabilities by allowing developers to execute code snippets, tests, and shell scripts in the runtime application context and also by compiling and building many additional parts of a typical web application.

Pushing Type Safety to a New Level

Play 2.0 takes compilation and type checking even further. Routes (which define URL and action mappings), templates, and even assets are now compiled (using LESS, CoffeeScript and the Google Closure compiler), providing a unified development workflow for both client side and server side developers. The result of all of this is that more errors will be detected earlier, speeding your development process. It also makes it a lot easier to work on large projects with many developers involved.

Example route compilation failure detection

Playing Nicely

Play 1.x implemented many of its original ideas (like providing properties for Java classes and hot class reloading) through techniques that required a relatively Play-specific runtime environment. Play 2.0, on the other hand, takes a more standardized approach to runtime deployment. This was made possible partly by writing the core framework in Scala and also by building on top of SBT, the popular build tool for Scala.

Play 2.0 delivers the same simple “play new, run, start” experience as the 1.x series, while standing on a more extensible foundation. Play 2.0 comes with a preconfigured build script that will work unmodified for most, but if you need to change the way your application is built and deployed, you have the ability to customize and adapt it as needed. As a result, you’ll find it even more straightforward to deploy Play 2.0 applications in a wider variety of scenarios.

Because web application design has evolved a lot in the last few years, Play 2.0 features a modular architecture that helps to avoid making hard assumptions about your technology stack. You do not want to use a database? You can disable the DBPlugin. Want to use your own templating engine? Just plug it in. Do not need a full featured web framework with all the bells and whistles? Use Play as a library. How much of the architecture you want to use in your application is entirely up to you.

Disabling plugins in conf/application.conf

 

Scales Up, Down, and Out with Akka

 
Play is based on a lightweight, stateless, web-friendly architecture that features predictable and minimal resource consumption (in terms of CPU, memory, threads) for highly-scalable applications. This is partly thanks to Akka 2.0, the event-driven middleware at the heart of Play 2.0. Developers also have direct access to the many additional features Akka provides, to build highly distributed systems that can scale to meet any level of demand.

Quoting the SpringSource announcement:

"The Spring Integration Scala DSL is a Domain Specific Language written in Scala with the goals of:

• providing a strongly-typed alternative to XML configuration for Spring Integration
• raising awareness about Spring Integration in Scala community
• providing first class integration with various Scala frameworks and products such as Akka
• providing seamless integration with Java where Scala developers can still leverage their existing Java investments"

The SpringSource blog post includes examples of the DSL and screencast demonstrations, as well as links to the project's GitHub web site, a comprehensive Introduction, a guide to Getting Started, a DSL Reference and more. 

Chris Mayer at jaxenter.com also covered the announcement in an article posted today, noting the release as another step in Scala's "ascent into the world of comprehensive enteprise support".

We're excited to see this project release as another way to accelerate adoption of Scala, Akka, and the Typesafe Stack among the Spring developer community.  Thanks to Oleg Zhurakousky and the team at VMware SpringSource behind this project.

I'm just back from an exciting few days with the Typesafe team at Jfokus 2012. Jfokus is a conference that rapidly is becoming one of the best developer conferences in Europe. This year was no exception: high energy, great speakers and well produced. 

Typesafe had a booth where the Akka Team together with Peter Hilton from the Play framework community project were hanging around answering questions about Scala, Akka and Play. The two big announcements were that we released Akka 2.0-RC1 and Play 2.0-RC1 on the first conference day. This was great fun and created some buzz around the conference floor.

Scala, Akka and Play were well represented in the conference agenda.

The first day of pre-conference university track workshops started with Peter Lundberg from Valtech delivering a fully booked hands-on half-day workshop on Getting started with Play! framework for web development in Java and Scala.

The actual conference opened with a keynote by Juergen Hoeller from SpringSource on Enterprise Java in 2012 an Beyond in which Juergen talked about Akka and stated Scala as the “next-generation language on the JVM”. That was directly followed by a great talk on Play 2.0 by Peter Hilton, speaking in front of a packed room of developers.

Matt Raible did a nice writeup of the talk on his blog.

Day two started with Matt himself doing a replay of his highly appreciated Devoxx 2011 talk on HTML 5 with Play Scala, Coffeescript and Jade. Once again he did a great performance and got rave reviews. Read more about the talk on Matt’s blog. The Play talk was directly followed by Akka’s Tech Lead Viktor Klang of Typesafe presenting Up and Out: Scaling Sofware with Actors in front of a fully packed room of enthusiastic developers.

His talk was very well received. One interesting thing to note was that when Viktor asked the audience how many had heard about Akka, almost everyone in the room raised their arms, and when he asked how many had used Scala, almost half of the audience did.

At the same time, in another room, Heroku’s James Ward did a talk on how to using Git to deploy Play applications to the Cloud using Heroku. James Ward’s talk was followed by James Strachan from FuseSource who presented his Scalate - Scala Templating Engine project.

By the end of the second day Typesafe’s Heiko Seeberger did a very well received, bold, almost exclusively live-coding session on how to get started with Scala titled Scala in Action, followed by a short “lightning” session by Thomas Alexandre from DevCode on the productivity boost Scala can give you titled One-liners are Your Friend: Increasing Productivity with Scala.

In total 8 conference talks on Scala, Play and Akka. Great fun.

The conference ended with myself and Peter Hilton doing a live stage interview for Oracle’s JavaSpotlight podcast, discussing the integration work between Play and Akka that the teams have done to allow Play to be fully asynchronous and non-blocking and giving Akka users a slick thin HTTP DSL module through the Play-Mini module, and much more. The result of this collaboration will be released in the next few weeks.

In short, Jfokus 2012 included lots of fun and energy for Typesafe and the Scala, Akka and Play communities. Don’t miss next year’s Jfokus conference, or for that sake the upcoming Scala Days conference in London.

We recently announced that the Play web framework is joining the Typesafe Stack. Play has always been known for its ease of use and developer productivity. The upcoming Play 2.0 release, which is built on top of the Scala language, Akka event-driven middleware, and the sbt build tool, will continue that tradition while delivering even greater performance and scalability.

While many of the concepts and features from Play 1.x carry through to Play 2.0, there are some changes and new features. Therefore Typesafe's Fredrik Ekholdt, a Scala and web application expert, and Typesafe's Peter Hausel, one of the main Play committers, have designed an all-new Fast Track to Play introductory course from the ground up. This one-day course will teach you everything you need to jump start web application development with Play 2.0.

The course program is as follows:

• Play 2.0 philosophy and architecture
• Introduction of the application to be created
• Getting started with Play 2.0
• The controller and routing
• Views and templates
• Forms
• Caching
• Working with JSON in Play
• Ajax
• Building non-blocking web applications

We are very excited to offer this new course for the first time on Monday April 16, the day preceding the Scala Days 2012 conference in London. More information and online registration for this course is available on the training section of the Typesafe web site.  We'll be adding more open enrollment sessions worldwide in the coming months.

Typesafe also offers dedicated on-site training for Scala, Akka, and now Play.  If you are interested in hosting a training for your team or company on-site at your facility, please contact us. 

We look forward to seeing many of you in London.

Scala Days offers a unique annual opportunity to engage with the Scala community, hear keynote speakers, be exposed to cutting edge research related to Scala, and compare notes about commercial applications of Scala and related frameworks including Akka and Play.

Keynote speakers for Scala Days 2012 will include:

• Guy Steele - Guy is a Software Architect and Principal Investigator of Programming Languages in the Programming Languages group at Oracle Labs. He has contributed to the implementation and standardization of many popular programming languages and is currently heavily involved in Fortress, a high performance language designed to obsolete Fortran.
• Simon-Peyton Jones - Simon is a researcher at Microsoft Research in Cambridge, England. Best known perhaps for being the major design contributor to the Haskell programming language and the Glasgow Haskell Compiler (GHC). His main interests are in the design, implementation and application of lazy functional languages.
• Anthony Rose - Anthony is the Co-Founder/CTO of Zeebox and the technology visionary behind a revolutionary social TV concept that has attracted the attention of the whole television industry and 15 million pounds early investment from BSkyB. For many he is recognised for being the driver behind the extremely successful BBC IPlayer, a service replicated on many TV channels world wide. 
• Martin Odersky - Martin is the creator of Scala and co-founder of Typesafe, the commercial provider at the heart of the Scala ecosystem.

Talk proposals are still being accepted through Feburary 22, 2012.  Speakers receive free admission to the full conference.

Register now while early bird rates are still available.  We look forward to seeing you in London this April!

After 9 months of intensive work by open source community contributors, users, and the IDE project team at Typesafe, we are proud to release this new version with improved reliability, performance, and responsiveness. New features include error reports as you type, a project builder with dependency tracking, definition hyperlinking, inferred type hovers, code completion, better integration with Java build tools, and more.

A lot of effort has gone into this version of the IDE and we would like to recognize the people who have contributed so much time and energy to the success of the project.

A bit of history

The Scala IDE project began a few of years back, when Miles Sabin layed down the foundations of the open source project and an enthusiastic community formed around the effort to create a free, open-source, Eclipse-based IDE for Scala. In late 2010 the Typesafe team decided to support the open source project, and in September Eugene Vigdorchik became the first full-time engineer to work on the project. At the same time, Typesafe founder and Scala creator Martin Odersky led a reimplementation of the Scala presentation compiler, the engine behind the IDE semantic actions.

Version 2.0

For version 2.0 we had some tough decisions to take, and development started with a very limited number of features, aiming for a very reliable core. Naturally, this raised the need for early and frequent feedback from our users: on March 28 we had the first beta of the upcoming 2.0 release. This was followed by a stream of betas (12 in total), packing around 300 closed tickets over the next months. As Eugene moved on to other projects, two other Typesafe engineers joined the IDE team: Iulian Dragos and Mirco Dotta, followed by Luc Bourlier in September. Together with the great community (Mirko Stocker and Matt Russell just to name a few), the IDE took great strides to reach its first production-ready release.

Diversity

As things moved forward and the 2.0 branch became the main version in use, it became clear that we needed to have more than one IDE version: 2.0 remained the rock-solid branch, where only bug-fixing happens, while 2.1 is the place where new features, such as semantic highlighting or implicit highlighting are developed.

Besides the two IDE versions, we support three versions of the Scala compiler: 2.8.x, 2.9.x and 2.10 (Scala trunk), with nightly builds for all of them, so you can choose what suits you the best: the latest IDE developments on a stable Scala compiler, the stable IDE on the bleeding edge Scala compiler, or even the latest and greatest of both -- like the core Scala team, who uses the Eclipse IDE for their daily scalac development! The choice is yours.

Community

While the IDE always had a vibrant community around it, contributing to the project itself was sometimes challenging for newcomers. On October 4 we moved the project to Github, leading to a much simpler process for contributors. In just a few weeks we had 17 forks, some of which are extremely interesting developments in their own right (for example, check out ScalaGWT, which brings Scala to the GWT framework).

Web site

Today we also release a redesign of the Scala IDE web site, along with reworked documentation, including screencasts. Thanks Heather for the awesome work. We believe that the new site is not only pretty, but makes it much easier to find documentation, both for users and contributors (and everyone is a potential contributor). The web site is backed by Git too, so you can contribute by using the awesome Pull Request button!

A look at the future

Even though it's been a long ride, today's release is not the end of the road, but rather a beginning. We can now look at adding new features on a solid base, and great things will come, such as improved compilation speed, find references, and a Scala debugger. Suggest your favorite feature, and help us build the next great IDE.

After the 2.0.0 release we will continue to support the 2.0 branch with maintenance releases including important bug fixes. However, the focus will shift to the 2.1 development stream, and concentrate on the upcoming features. Also, 2.0.0 will be the last version to support the 2.8 compiler. This decision was not taken lightly, but the effort to support 2.8 is substantial and detracts from our ability to innovate on newer releases. We believe that 2.0.0 is a solid release that can help people who cannot upgrade to 2.9.x in the immediate future.

Features

Scala IDE version 2 improves developer productivity through a large number of features. Below we highlight the main ones, but don't forget to check out the full list on the web site, and watch the screencast to see them in action.

• Report errors as you type - The IDE saves you time by type-checking your program as you type, and notifying you of errors before you build. This greatly reduces the number of times you need to build your project during development.
• Project builder with dependency tracking - The IDE saves you time even when you *do* have to build your project: by using sbt's engine for tracking dependencies between source files (and even between dependent projects), the IDE builds only the necessary sources. This is often many fewer than all the source files in your project.
• Definition Hyperlinking - Ctrl-click on an identifier to navigate to its definition. This allows you to concentrate on your program, since you don't need to remember in what source file a certain definition lies. Try it out by surfing through the Scala collection library!
• Content assist - Hit Ctrl-space to see a list of all members you could invoke at a certain point in your program. Even members added through *implicit* conversions are available. Moreover, you can find any class on your classpath, even if it hasn't been imported in your file yet (and the completion engine takes care of adding the import).
• Inferred type hovers - Hover with the mouse over an identifier to see its type. This comes in handy when the compiler infers a different type than what you expect.

And there is more! Check out the full list of features, and download Scala IDE 2.0 today at www.scala-ide.org.

We are proud to announce the first pre-release milestone of Akka 2.0, which will be part of the upcoming Typesafe Stack 2.0.

Akka is an event-driven middleware framework, for building high performance and reliable distributed applications in Java and Scala. Akka decouples business logic from low-level mechanisms such as threads, locks and non-blocking IO. Your Scala or Java program logic lives in lightweight actor objects which send and receive messages. With Akka, you can easily configure how actors will be created, destroyed, scheduled, and restarted upon failure.

Typesafe and the Akka open source community have been hard at work laying the foundation for Akka 2.0 for many months now. In this post, we’d like to highlight some of the changes made relative to Akka 1.x, and look a bit behind the scenes at why we made those changes, and how you can benefit from them.

Modular Configuration

In Akka 1.x, configuration, registry, and logging settings are all global, which poses challenges when running multiple Akka applications with different settings within the same class loader. In Akka 2.0, all global shared state has been removed so that multiple actor systems can co-exist. An Akka application is now contained within an ActorSystem class. This allows more flexibility in deploying Akka applications and is particularly useful for testing actor systems.

Mandatory Supervisor Hierarchies

Akka achieves fault tolerance in large part by using a supervisor hierarchies, inspired by Erlang’s OTP framework. Fault tolerance and error recovery strategies are fundamental to the success of Erlang systems. In the supervisor hierarchy model, a supervisor actor is responsible for starting, stopping and monitoring its child actors.

Akka has always had support for supervision hierarchies but now includes this supervision automatically. Error recovery is built-in to all actor systems and can be configured and refined easily. Actors naturally form tree structures based on parent actors creating child actors. Parent actors are now the supervisor for any children created, handling all errors and failures in the children.

Actor systems get much simpler to reason about when every actor has a supervisor. Among other benefits, this removes the need for maintaining a central registry—a global point of contention—and replaces it with local registries arranged in a hierarchy. If this sounds like a file system to you, you are on the right track: with these features, every actor in a system can be identified by giving the names of its ancestors, with the root provided by the ActorSystem itself. This enables path look-ups of actors, even relative to a reference point (i.e. “../joe” would be the current actor’s brother named “joe”). One positive side effect is that instead of opaque UUIDs, you will find meaningful names in your log messages.

The “Error Kernel” or ”Onion Layer” pattern has been used to great effect in platforms like Erlang to structure applications in a fault-tolerant way, and with Akka’s new mandatory parental supervision this design comes naturally. With mandatory supervisor hierarchies, you’re encouraged to design for fault tolerance from the beginning, rather than as an afterthought in your application.

Location Transparency

One of the key features of actor-based programming is that actors are naturally distributable. Actor-based systems are distributed systems by design. A lot of restructuring has taken place in Akka to make the most of this “distributed by default” approach. The internals of Akka have been completely reworked so that they only use asynchronous message exchanges, laying the foundations for improved remote and distributed actors. With every actor identified by a URI—with remote protocol, host, port and path—it becomes very easy to refer to actors across node boundaries. The implementation of actor supervision has been simplified so that it works the same whether parent and child are on the same or different nodes. And since this distributed approach lends itself so well to scaling out, we made it even easier by allowing the deployment of actors to be specified purely by configuration, instead of through APIs as was the case in Akka 1.x. Consider the following example:

akka {
  actor {
    deployment {
      /serviceA/retrieval {
        remote = “akka://app@10.0.0.1:2552”
         # “app” is the ActorSystem’s name
      }
      /serviceA/aggregation {
        router = “round-robin”
        nr-of-instances = 10
        target {
          nodes = [“akka://app@10.0.0.2:2552”, “akka://app@10.0.0.3:2552”]
        }
      }
    }
  }
}

With a configuration snippet like this, given an actor named “serviceA”, the child named “retrieval” will be deployed on a specific host, while the child named “aggregation” will be cloned 10 times, and evenly distributed across the two given target nodes. (The ability to be routed needs to be declared in the code to avoid surprises, but the configuration can override all properties).  To support the new configuration model, configuration file handling has been split out into a no-dependencies Java library which you can also use for your own projects; it is also used also by Play 2.0 so that you can configure an Akka & Play application with a single configuration file.

Additional Refinements

The three big features mentioned above have spawned a lot of other changes to make them possible. For example, the “ask” operation was reimplemented by creating a one-off actor for handling the reply so that replies to Futures work like normal message sends. All these changes have made the API more consistent, generally removing methods while adding features. We also made an effort to make actors even more light-weight: currently the overhead is around 350 bytes per instance, which translates to about 2.7 million actors per GB in heap size. We also invested in removing blocking synchronization wherever possible, making Akka more scalable than ever: there is not a single “synchronized” in the Akka hot paths and current benchmarks yield 24 million messages processed per second on a standard quad-core MacBook Pro.

With Akka 2.0, Futures and Promises have also received a major overhaul. This effort has been in coordination with the Scala team from EPFL in order to unify these concepts between Akka and the Scala libraries, with the aim of moving towards one common interface and implementation for these important constructs.

In summary, this release represents a true version 2 of Akka. While adding new capabilities, the Akka development team took advantage of the clear version step to weed out code which would impede future improvement. The improvements were done especially with cluster support in mind, which will be the primary focus for the subsequent 2.1 release.

This pre-release milestone presents the new face of Akka in a mostly feature-complete form, but without all of the refinement that will be present in the final release. For example, we will provide a migration helper kit which contains bridges in the form of a global default ActorSystem to ease the transition from Akka 1.x. At the same time, we hope that you will try out the this early pre-release of Akka 2.0 and provide your feedback via the Akka project issue tracker and mailing list. You can download the pre-release milestone from the Akka project Maven repository or download page, and documentation for this release is on the Akka project site. Happy hAkking!

Typesafe is all about creating a pragmatic, modern development stack for building software that scales. The Scala programming language is at the core of that stack.

Since the inception of Scala, it has never suffered a shortage of opinions and feedback. This has been a tremendous advantage! If anything, we have noticed discussions about commercial applications of Scala accelerating in various forums, online and offline, in the past few weeks.

At Typesafe, we take feedback about practical applications of Scala seriously. Experiences from real world commercial applications play a large role in our planning and prioritization.  Our ambition is to continually improve Scala and the rest of the Typesafe Stack so that it is accessible to an ever broader audience of developers.

In this spirit, we thought it would be a good time to summarize a few of the areas where Typesafe is working to ease the adoption of Scala in commercial settings:

• IDE Support -- Historically, inconsistent Eclipse IDE support had been a frequent complaint from early adopters of Scala. Recognizing this challenge, Typesafe led a major refactoring of the community-initiated Scala IDE for Eclipse starting in early 2011. This has culminated in Scala IDE for Eclipse 2.0, with greatly improved stability and performance, currently available as a release candidate. After the final IDE 2.0 release, Typesafe will continue to invest in adding new IDE features, such as improved refactoring support.

• Learning curve -- Scala builds on many familiar concepts from Java and other languages, but introduces powerful new elements to the mix. In order to get commercial development teams up to speed quickly, Typesafe has developed dedicated training courses including Fast Track to Scala (for newcomers to Scala) and Advanced Scala (for experienced Scala developers) that are delivered in conjunction with our growing network of partners. Complementing Typesafe’s efforts are free resources like Twitter’s Scala School and Cay Horstmann’s excellent Scala for the Impatient. Recently, Typesafe partnered with leaders of the Scala community to launch an exciting new collaborative Scala Documentation site. And for those looking to ease into the Typesafe Stack, both the Akka middleware framework and the Play web framework offer native Java APIs in addition to Scala APIs.

• Build times -- There’s no question: because it does more for you, the scalac compiler has more work to do than javac. At Typesafe, we are working to address build times through a holistic approach that considers not only raw compile times but also techniques like incremental compilation and parallel builds. Core to this effort are build tools like sbt, where we are pushing improvements aggressively.

• Binary compatibility -- To ensure a stable platform for commercial deployment, Typesafe has introduced the Typesafe Subscription, which includes long-term, commercially supported and maintained releases of Scala and the rest of the Typesafe Stack. This means you can put your application into production with the confidence provided by ongoing technical support and binary-compatible fixes for key issues that may arise.  To support this effort, we are working on the Migration Manager, a tool that checks binary compatibility across releases, which was recently used to verify that Scala 2.9.1 was compatible with 2.9.0. Finally, we are exploring opportunities to provide a larger set of core libraries that are continuously built together with new releases of Scala, including common libraries for testing, IO, and transactional memory, among others. This is intended to reduce the dependency synchronization challenges for developers moving between major versions of Scala.

• Performance -- We take application runtime performance quite seriously, and target continual performance improvement based on feedback from real world applications. At the same time, we are cautious to avoid premature optimization. As a high-level language, Scala encourages developers to take advantage of scalable software architectures (such as Akka’s distributed actors) that would be more difficult to implement in a lower-level language. And as a statically typed language running on the Java Virtual Machine, Scala benefits from a natural performance tailwind when compared with many alternative commercial languages.

• Frameworks -- It’s no secret that much of our focus at Typesafe has been on higher level frameworks including Akka event-driven middleware and, more recently, the Play web application framework. Our effort goes beyond the Scala language to these frameworks that use Scala to make it easier (and more fun) for developers to build applications that solve real world problems, at scale. Look for more to come from Typesafe on this front.

• Community -- The Scala community is much broader than Typesafe.  We’re honored to work alongside a broad, diverse, talented, opinionated, and downright quirky group of individuals. We’re trying to do our part by collaborating on projects like moving the main Scala repository to Github (completed today!), where it joins many other projects built with Scala.

No doubt, there’s tremendous room for improvement in Scala, on many fronts. And we are hard at work. But at the same time, Scala is used in production today, with great success, by many major companies ranging from global financial services firms to web leaders like Twitter, LinkedIn, and -- yes -- Yammer.

We welcome your feedback on Typesafe and Scala. Please get in touch with us through our web site, in the open source community forums where we do our work, or at info@typesafe.com.

Earlier this year, we announced the Typesafe Stack, an integrated open source distribution of the Scala programming language, Akka middleware, and supporting development tools. Today, we’re excited to announce a major new addition to the Typesafe Stack: the Play web application framework.

The open source Play framework was created in 2007 by Guillaume Bort, who sought to bring a fresh web development experience inspired by modern web frameworks like Ruby on Rails to the long-suffering Java web development community. Play follows a familiar stateless model-view-controller architectural pattern, with a philosophy of convention over configuration and an emphasis on developer productivity. Unlike traditional Java web frameworks with their tedious compile-package-deploy-restart cycles, updates to Play applications are instantly visible with a simple browser refresh. With its distinctive focus on developer experience, it’s no surprise that the Play framework quickly took the Java web development community by storm, earning a place in the hearts of developers and on forward-looking platforms like Heroku.

In many ways, the Play team’s willingness to challenge the status quo with a fundamentally new approach echoes the spirit of the Scala language and Akka event-driven middleware. So it’s natural that the Play community soon began experimenting with a Scala add-on module in early versions of the framework. These experiments have culminated in Play framework 2.0, the next major version of the framework announced by the Play community earlier this year, which leverages Scala at its core while providing native support for both Java and Scala.

Play framework 2.0 builds on Scala, Akka, and sbt to deliver superior asynchronous request handling, fast and reliable type-safe templates, and a powerful build system with flexible deployment options. Developers can use Play 2.0 to add a simple HTTP layer to existing projects; or can build full-featured web applications that take advantage of the integrated support for database persistence, form validation, testing, authentication, caching, and RESTful web services.

While it adds native support for Scala, Java remains a key focus for Play Framework 2.0. Just like Akka middleware, the Play Framework will continue to provide native Java APIs that allow Java developers to leverage the power of Scala and the Typesafe Stack without writing a single line of Scala code -- though we find that once you’ve tasted Scala, it’s often too tempting to resist.

With the addition of the Play web application framework, the Typesafe Stack becomes a complete web platform. Typesafe is contributing new development resources to the Play framework open source community to work on a common roadmap coordinating Scala, sbt, Play, and Akka into a unified, coherent platform for application development. Our goal is to offer dramatically improved productivity over traditional application platforms, from the lowest-level features all the way up to the web framework.

Typesafe will offer commercial support, maintenance, systems management and deployment tools for Play framework as part of the paid Typesafe Subscription offering. We’ll also be introducing training and consulting services around Play framework, in conjunction with partners including Zenexity, the web oriented architecture consultancy where Play was born.

Finally, we’re honored to announce that Guillaume Bort, creator of Play framework and co-founder of Zenexity, has joined the Typesafe advisory board to ensure a seamless collaboration.

The Typesafe Stack is an open platform, and developers will continue to have many excellent choices for Scala and Java web frameworks including Spring, Wicket, Lift, Scalatra, Unfiltered, and many others. At the same time, we suspect that many of you will find the polished development experience of Play framework, and its deep integration with other components of the Typesafe Stack, as irresistible as we do.

Play framework 2.0 is under active development and will be packaged with upcoming releases of the Typesafe Stack. In the mean time, you can download a beta release at the Play community project site, starting today.

If you are at the Devoxx conference this week, be sure to stop by the Typesafe booth to talk about Typesafe and Play framework, and don’t miss the Wednesday session on Play 2.0 and the Thursday sessions on Akka and Scala.

Akka is an event-driven middleware framework, implemented in Scala, for building high performance and reliable distributed applications.  Akka decouples business logic from low-level mechanisms such as threads, locks and non-blocking IO. Your Scala or Java program logic lives in lightweight actor objects which send and receive messages. With Akka, you can easily configure how actors will be created, destroyed, scheduled, and restarted upon failure.

This article will give you a deeper understanding of how Akka actors are related to threads. It illustrates how bad resource utilization your application may have if you use actors in a blocking fashion, and what to do instead of blocking.

The example we will use is a translation service that delivers two things as response to HTTP requests:

• translated text
• word count

The translation takes 100 ms to perform, and so does the word count.

We are only allowed to use 8 threads for the actors. That is indeed a low limit, but in the end you will have an upper limit somewhere of the number of threads that can be used.

The application must be able to handle 4 concurrent client requests with an average response time of less than 110 ms.

We use Akka’s support for async HTTP request, which means that we don’t block the incoming request thread.

To be able to handle 4 concurrent request we must create at least 4 frontend actors and use a dispatcher with 4 threads.

Let’s start with the wrong way of doing it and then change to a better solution.

object Frontend {

  val frontendDispatcher = Dispatchers
    .newExecutorBasedEventDrivenDispatcher("frontend-dispatcher")
    .setCorePoolSize(4)
    .build

  def loadBalanced(poolSize: Int, actor: => ActorRef): ActorRef = {
    val workers = Vector.fill(poolSize)(actor.start())
    Routing.loadBalancerActor(CyclicIterator(workers)).start()
  }

  class WebEndpoint(root: ActorRef) extends Actor with Endpoint {
    self.dispatcher = frontendDispatcher

    val translate = loadBalanced(10, actorOf[TranslateHandler])

    override def preStart() = {
      root ! Endpoint.Attach(hook, provide)
    }

    def receive = handleHttpRequest
    def hook(uri: String) = true
    def provide(uri: String) = translate
  }

Above we have created 10 instances of TranslateHandler actor, managed by a round robin router. The TranslateHandler looks like this:

class TranslateHandler extends Actor {
    self.dispatcher = frontendDispatcher

    def receive = {
      case get: Get =>
        val text = get.request.getParameter("text")
        (translationService ? ranslationRequest(text))
          .as[TranslationResponse] match {
            case Some(TranslationResponse(translated, words)) =>
              get.OK("Translated %s words to: %s".format(words, translated))
            case None =>
              get.Timeout("Timeout")
        }
  }

It asks the translationService to perform the translation and count the words. It blocks until the result is available, and then completes the HTTP request with OK.

For the backend TranslationService we also define a dispatcher and pool of service instances:

val backendDispatcher = Dispatchers
    .newExecutorBasedEventDrivenDispatcher("backend-dispatcher")
    .setCorePoolSize(4)
    .build

  val translationService = loadBalanced(10, actorOf[TranslationService])

The TranslationService and the workers looks like this:

class TranslationService extends Actor {
    self.dispatcher = backendDispatcher

    val translator = actorOf[Translator].start()
    val counter = actorOf[Counter].start()

    def receive = {
      case TranslationRequest(text) =>
        val future1 = (translator ? text)
        val future2 = (counter ? text)

        val result1 = future1.as[String]
        val result2 = future2.as[Int]

        for (translatedText <- result1; words <- result2) {
          self.reply(TranslationResponse(translatedText, words))
        }
    }
  }

  class Translator extends Actor {
    self.dispatcher = backendDispatcher

    def receive = {
      case x: String =>
        // simulate some work
        Thread.sleep(100)
        val result = x.toUpperCase
        self.reply(result)
    }
  }

  class Counter extends Actor {
    self.dispatcher = backendDispatcher

    def receive = {
      case x: String =>
        // simulate some work
        Thread.sleep(100)
        val result = x.split(" ").length
        self.reply(result)
    }
  }

In the receive method of the TranslationService you can see how the text translation and word count is done in parallel.

Running this with JMeter and one client thread the result looks fine. Average response time of 103 ms. When increasing to 2 client threads the response time goes up to 193 ms. What is wrong? The blocking consumes threads, and we only have a few. In this case each request eats 4 threads.

Obviously we can do better. Let’s change the TranslationService to this:

def receive = {
      case TranslationRequest(text) =>
        for (replyTo <- self.sender) {
          val aggregator = actorOf(new Aggregator(replyTo)).start()
          translator.tell(text, aggregator)
          counter.tell(text, aggregator)
        }
    }

It creates a new actor, Aggregator, which is used as sender for the one-way tell to translator and counter. This will not block at all. The Aggregator looks like this, and doesn’t consume any resources until the response from the workers are handled.

class Aggregator(replyTo: ActorRef) extends Actor {
    self.dispatcher = backendDispatcher
    self.lifeCycle = Supervision.Temporary
    self.receiveTimeout = Some(1000)

    var textResult: Option[String] = None
    var lengthResult: Option[Int] = None

    def receive = {
      case text: String =>
        textResult = Some(text)
        replyWhenDone()
      case length: Int =>
        lengthResult = Some(length)
        replyWhenDone()
      case ReceiveTimeout =>
        self.stop()
    }

    def replyWhenDone() {
      for (text <- textResult; length <- lengthResult) {
        replyTo.tell(TranslationResponse(text, length))
        self.stop()
      }
    }
  }

The same thing can be done in the frontend. As an additional optimization, the frontend and backend can share the same dispatcher with 8 threads. With these changes we can run JMeter with 4 client threads and the average response time is 102 ms.

Another solution is to use Akka futures, but that is another story.

The conclusion is that you should be careful with blocking operations and don’t be afraid of creating temporary actors that continue the message flow.

Full source code for the example above is available at https://github.com/patriknw/akka-playground/tree/master/web-to-backend.  

For more about Akka, visit the Typesafe web site and the Akka community project site.

Bringing the Typesafe Stack to Heroku

We've been working with a team at Heroku to support the Typesafe Stack, including Scala, Akka, and Simple Build Tool on Heroku's Cedar platform. Today the service goes live.

Heroku introduces the new support over on their blog with an emphasis on telling newcomers to Scala about the Scala community.

Readers of this blog may be familiar with Scala and Akka already, but may not have tried out Heroku. You should! And we've built a handy sample app, "Web Words," in case you need something to deploy:

• Web Words sample app on GitHub
• Article describing Web Words

Following the instructions in the README, you can deploy Web Words to Heroku in a matter of minutes. It runs with the free pricing tier so there's no cost to try it.

Heroku could not be easier to use. A nice feature is that you can run any main() method, instead of uploading a .war file; giving you total control of your application. Heroku also offers an ecosystem of add-ons, allowing you to add hosted services such as RabbitMQ or MongoDB to your application with a single command. Both features are shown off in the Web Words sample app.

Adding "stage" to sbt

As part of the Heroku support, we developed a new Simple Build Tool plugin to generate a 'start script'. This plugin exports sbt's knowledge about your main class, your classpath, and so on into a shell script. Then you launch the app with that script. It's like `sbt run` except that it doesn't keep sbt itself in-memory. Find xsbt-start-script-plugin on GitHub. Once the start script is generated, on Heroku it goes in the Procfile; you can also use it to run an app by hand on your local machine.

The start script plugin is not necessary to use Scala on Heroku, but it does save you some work. It also introduces a convention, a task name `stage`, which we're defining to mean "prepare the project to be executed in-place." For xsbt-start-script-plugin, `stage` means to generate executable scripts to launch the app. But you could define it differently, or add your own steps to the task in addition to generating a script.

Heroku's Cedar platform has no knowledge of the start script plugin, it just runs `sbt stage` when it identifies an sbt project and does whatever `stage` has been defined to do.

An intro to Scala, Akka, and Play

By the way, if you missed Dreamforce 2011, I gave a talk introducing Scala, Akka, and Play to Java developers, and teased the upcoming Heroku support at the end of the talk. (Which is why we didn't post the talk until today.)

Here are the slides and a video from the talk.

Slides:

Video:

Free e-book!

If the talk convinces you to learn more about Scala, one place to start is the PDF excerpt of Cay Horstmann's upcoming book Scala for the Impatient we're giving away on the Typesafe web site.

We look forward to seeing what you build with Scala and the Typesafe Stack on Heroku!

Starting today, Typesafe is proud to offer a free preview of Cay Horstmann's new work, Scala for the Impatient, when you sign up for the Typesafe e-mail newsletter. Cay describes the book as such:

"I wrote this book for impatient readers who want to start programming with Scala right away. I assume you know Java, C#, or C++, and I won't bore you with explaining variables, loops, or classes. I won't exhaustively list all features of the language, I won't lecture you about the superiority of one paradigm over another, and I won't make you suffer through long and contrived examples. Instead, you will get the information that you need in compact chunks that you can read and review as needed."

The free PDF includes a subset of the book, suitable for a beginning application developer (or the A1 Scala Level, if you prefer). Chapters include:

1. The Basics
2. Control Structures and Functions
3. Arrays
4. Maps and Tuples
5. Classes
6. Objects
7. Packages and Imports
8. Inheritance
9. Files and Regular Expressions

If you enjoy this sampling, we hope you'll purchase Cay's full book where he further addresses intermediate and advanced Scala topics.

A practical book for a practical language -- it's a pairing we couldn't resist. Download your free copy from Typesafe here.

Futures are a neat way to use multiple cores without having to worry about managing specific threads or tasks. If you have some work that you want to get done while you get on with something else, then you simply create one or more Future(s) and give them the work to do in the form of a function that returns a result. Later you can test the Future for completion and pick up the result. An elegant way to get work done that you need in the Future!

Akka, part of the Typesafe Stack, has had a Future implementation for a long time. It’s so useful we decided to put a major effort into enhancing the capability, making it faster, more scalable and more intuitive to use. Key parts of the underpinning code used locks and blocking to ensure the integrity of the multi-threaded execution. These do not scale well in multi processor environments, as processors must wait while contentions are resolved. So we spent a lot of time to create a not-so-obvious non-blocking alternative. With the new implementation, things scale better and execution time is faster.

Comprehensions are the way we Scala programmers tend to think about doing things on collections. It is one of the function styles that leads to concise and easy to read code. We re-thought the Futures library to facilitate using Comprehensions and the more typical Scala “foreach” pattern, You can now handle sequences in an intuitive non-blocking way. We have found it a whole lot more powerful way to express our intentions.

Now let’s take a detailed look how the changes look at the code level:

1. On akka.dispatch.Futures there are new, Java API methods named "future" to use Callables that are executed on another thread to produce the result in a Future. This means that they are non-blocking and you have the option to specify which Dispatcher will execute your callable.
2. Futures.awaitAll has been deprecated in favor of: futures.foreach(_.await)
3. Futures.awaitOne has been deprecated in favor of: firstCompletedOf(futures).await. Because firstCompletedOf is non-blocking, and await is blocking, it's better if this is not encouraged by the API
4. Futures.awaitMap has been deprecated in favor of: futures map { f => fun(f.await) }. This is because Future now supports a non-blocking map, which wasn't the case before, so you'd have to await before mapping
5. There is now a Java API version of Futures.reduce.
6. New! The Futures.sequence method takes a Traversable[Future[T]] and non-blockingly returns a Future[Traversable[T]].
7. New! The Futures.traverse method transforms a Traversable[A] to a Future[Traversable[B]] using a provided function from A to Future[B]. This is a great way of performing "map" in parallel.
8. Future has now transformed into being isomorphic to dataflow variables. In recognition of this, we've added the key methods of DataFlowVariable to Future. This includes:

   apply:
   val f: Future[Int] = ...
   val i = f() // Logically f.await.resultOrException.get
       
   <<:
   val f: CompletableFuture[Int] = ... // Write side of Future, compare with the concept of Promise, or DataFlowVariable
   f << 5 // Sets the value 5 into f, since CompletableFutures can only be written once, they act like dataFlowVariables
   f << otherF // You can also set the value to the value of another Future, this will be done when that Future is completed
               // same behavior as CompletableFuture.completeWith(f: Future[...])

   The above two methods are intended for usage within the Future.flow method, like this:

   import Future.flow
   def add(a: Future[Int], b: Future[Int]): Future[Int] = flow { a() + b() }

   This uses Continuation Passing Style with Delimited Continuations under the hood, to be able to write code that looks like it's blocking but it reality it isn't.
9. New! Future now sports a couple of new methods:

   get: //Warning! Blocking
     val f: Future[Int] = ...
     f.get // Semantically f.await.resultOrException.get but for use in a non "flow" context
       
   value:
     val f: Future[Int] = ...
     val v: Option[Either[Throwable, Int]] = f.value // The current value of the Future, None if no value, and Left(error) or Right(result) otherwise
   
   onResult:
     val f: Future[Any] = ...
     f onResult {
       case "foo" => doSomething
       case 6 => doSomethingElse
       case SomeRegex(param) => doSomethingOther
       case _ => doAnything
     } // Applies the specified partial function to the result of the future when it is completed with a result
   
   recover:
     val f: Future[Any] = ...
     val result = f recover {
       case n: NumberFormatException => 0
     } // Returns a new future that when the first future has been completed with an exception, will contain the transformed result"     
   
   onException:
     val f: Future[Any] = ...
     f onException {
       case npe: NullPointerExcep => doSomething
       case 6 => doSomethingElse
       case SomeRegex(param) => doSomethingOther
       case _ => doAnything
     } // Applies the specified partial function to the result of the future when it is completed with an exception
   
   onTimeout:
     val f: Future[Any] = ...
     f onTimeout {
        future => doSomethingWhenTimeout(future)
     }

10. New! Future is now fully monadic so it can be used in for-comprehensions; all methods: map, flatMap, filter and foreach are non-blocking

These are exciting times. With Typesafe and Akka, the Future is here!

In this post I'll talk about the updated dispatcher strategy that is new with Akka 1.1.

For those of you who don't know what an Akka Dispatcher is - it's the engine of Akka, the thing that makes it tick, the thing that makes sure that the available CPU resources are optimally divided between the things that needs to be executed. In other words, it's at the heart of Akka's concurrency model.

Here's what is new in Dispatchers with Akka 1.1:

1. All Dispatchers in Akka core are now built on top of the ExecutorBasedEventDrivenDispatcher, which is a very versatile and high-performance dispatcher implementation. This means that any performance improvements that are made in that will cascade to all the others.
2. A ThreadBasedDispatcher is a dispatcher that only has one Thread in its thread pool, and every ThreadBasedDispatcher can only be used by one actor instance. This ensures that the actor will not be CPU starved by other actors. Also, it will deallocate its thread after a specified timeout, and will require it when needed, so as not to hog scarce resources.
3. The ExecutorBasedWorkStealingDispatcher now redistributes work to actors that use the same dispatcher and that do not currently have any messages the mailbox.
4. HawtDispatcher has been moved to a compatibility JAR in Akka modules, for those who want to keep using it. Worth noting is that the ExecutorBasedEventDrivenDispatcher is more performant and way more tunable, and HawtDispatcher does not support some of the methods in the MessageDispatcher contract, like getMailboxSize.
5. There is a new dispatcher, called PriorityExecutorBasedEventDrivenDispatcher, that allows you to supply it with a Comparator that will determine the processing order of messages sent to actors that use this dispatcher.
6. As a consequence of having all dispatchers in akka-actor use the same base, they all support the same basic configuration options.
7. You can now write your own dispatcher, or extend any of the built-in ones, and be able to configure it from the Akka configuration file, by creating a class that extends MessageDispatcherConfigurator and then in the conf file, instead of

   type = "GlobalExecutorBasedEventDriven"

   or similar, you enter

   type = "my.own.dispatcher.configurator.FQN"

   And then Akka will load your dispatcher configurator and will use that to create the dispatcher instance.
8. Dispatchers can now be used to execute blocks of code that will compute the result of a Future, which is very low in overhead.

   object Future {
     /**
      * This method constructs and returns a Future that will eventually hold the result of the execution of the supplied body
      * The execution is performed by the specified Dispatcher.
      */
     def apply[T](body: => T, timeout: Long = Actor.TIMEOUT)(implicit dispatcher: MessageDispatcher): Future[T]
   }

   Scala example:

   val f = Future(someThunk)/*(someDispatcher)*/

   Java example:

   import static akka.dispatch.Futures.future;
   Future f = future(someCallableThatReturnsInteger/*, someDispatcher*/);

9. There has been a lot of effort made to optimize the ExecutorBasedEventDrivenDispatcher, so just by upgrading to Akka 1.1 you'll get an extra performance boost versus previous versions.

To sum things up: Faster, stronger, smaller, and more flexible.  One dispatcher to rule them all.

A major benefit of using the Typesafe Stack, including Scala and Akka, is that it simplifies the process of writing concurrent software.  This article discusses how the Typesafe Stack, and Akka in particular, approaches shared memory in concurrent applications.

The Java Memory Model

Prior to Java 5, the Java Memory Model (JMM) was ill defined. It was possible to get all kinds of strange results when shared memory was accessed by multiple threads, such as:

• a thread not seeing values written by other threads: a visibility problem
• a thread observing 'impossible' behavior of other threads, caused by instructions not being executed in the order expected: an instruction reordering problem.

With the implementation of JSR 133 in Java 5, a lot of these issues have been resolved. The JMM is a set of rules based on the "happens-before" relation, which constrain when one memory access must happen before another, and conversely, when they are allowed to happen out of order. Two examples of these rules are:

• The monitor lock rule: a release of a lock happens before every subsequent acquire of the same lock.
• The volatile variable rule: a write of a volatile variable happens before every subsequent read of the same volatile variable

Although the JMM can seem complicated, the specification tries to find a balance between ease of use and the ability to write performant and scalable concurrent data structures.

Actors and the Java Memory Model

With the Actors implementation in Akka, there are two ways multiple threads can execute actions on shared memory:

• If a message is sent to an actor (e.g. by another actor). In most cases messages are immutable, but if that message is not a properly constructed immutable object, without a "happens before" rule, it would be possible for the receiver to see partially initialized data structures and possibly even values out of thin air (longs/doubles).
• If an actor makes changes to its internal state while processing a message, and accesses that state while processing another message moments later. It is important to realize that with the actor model you don't get any guarantee that the same thread will be executing the same actor for different messages.

To prevent visibility and reordering problems on actors, Akka guarantees the following two "happens before" rules:

• The actor send rule: the send of the message to an actor happens before the receive of that message by the same actor.
• The actor subsequent processing rule: processing of one message happens before processing of the next message by the same actor.

Both rules only apply for the same actor instance and are not valid if different actors are used.

STM and the Java Memory Model

Akka's Software Transactional Memory (STM) also provides a "happens before" rule:

• The transactional reference rule: a successful write during commit, on an transactional reference, happens before every subsequent read of the same transactional reference. This rule looks a lot like the 'volatile variable' rule from the JMM.

Currently the Akka STM only supports deferred writes, so the actual writing to shared memory is deferred until the transaction commits. Writes during the transaction are placed in a local buffer (the writeset of the transaction) and are not visible to other transactions. That is why dirty reads are not possible.

How these rules are realized in Akka is an implementation detail and can change over time, and the exact details could even depend on the used configuration. But they will build on the other JMM rules like the monitor lock rule or the volatile variable rule. This means that you, the Akka user, do not need to worry about adding synchronization to provide such a "happens before" relation, because it is the responsibility of Akka. So you have your hands free to deal with your business logic, and the Akka framework makes sure that those rules are guaranteed on your behalf.

• Scalathon, The International Scala Hackathon will be held July 16-17 at the University of Pennsylvania in Philadelphia, PA. Scalathon will feature a variety of short talks focused on helping Scala developers contribute to the language and its libraries, as well as two solid days of group hacking. Typesafe is a sponsor of the event, and Paul Phillips and Mark Harrah from Typesafe will be giving talks on scalac and sbt.
• OSCON Java 2011, a new sub-conference devoted to the Java ecosystem co-located with the OSCON conference July 25-27 in Portland, OR. Typesafe founder and Scala creator Martin Odersky will deliver the a keynote on Scala, and there will be presentations on Akka and Scala throughout the day.  A 20% discount on your registration is available with code "os11fos".

We hope to see you in Philadelphia, Portland, or other Scala community events this summer!

Recently the revamped version 0.10 of the Simple Build Tool (sbt) was released. We are also closing in on a final 2.0.0 release of the Scala IDE for Eclipse that will hopefully bring the age of limited IDE support for Scala to an end. Having these two great tools at hand, we certainly need integration capabilities. The sbteclipse project aims at that very goal by providing a plugin for sbt that makes it possible to create Eclipse project files from an sbt project.

The current version 1.1 of sbteclipse, which requires sbt 0.10 or later, provides the additional sbt command eclipse which automatically creates Eclipse .project and .classpath files. Using the optional argument create-src will additionally create the source folders of the sbt project, e.g. src/main/scala. Of course this also works for multi-module projects. In such a case the root project often is just a folder and not a “proper” project. Therefore the optional argument skip-root can be given to prevent the Eclipse project files for the root project from being created.

As soon as the Eclipse project files are in place, the “Import...” wizard of Eclipse can be used to import “existing projects into workspace”. It is strongly recommended not to copy these projects into the workspace, i.e. simply leave the relevant checkbox unchecked. Otherwise the projects will be duplicated and possibly diverge on the long run.

In order to “install” sbteclipse as a general plugin which is available to all sbt projects, the following build.sbt file has to be created in the directory ~/.sbt/plugins:

resolvers += {
  val typesafeRepoUrl = new java.net.URL("http://repo.typesafe.com/typesafe/releases")
  val pattern = Patterns(false, "[organisation]/[module]/[sbtversion]/[revision]/[type]s/[module](-[classifier])-[revision].[ext]")
  Resolver.url("Typesafe Repository", typesafeRepoUrl)(pattern)
}

libraryDependencies <<= (libraryDependencies, sbtVersion) { (deps, version) => 
  deps :+ ("com.typesafe.sbteclipse" %% "sbteclipse" % "1.1" extra("sbtversion" -> version))
}

We hope that you find sbteclipse helpful and are looking forward to your comments. Please report any issues or enhancement requests via the project’s issue tracker.

It's been a busy ten days in Palo Alto. I gave the Advanced Scala course for Typesafe at Stanford, was in a lot of meetings and met a great number of interesting people. Interest in Scala and Akka is growing at a very rapid pace. You can literally feel it in the air.

The highlight of this visit was clearly Scala Days 2011, which was organized in the Stanford Alumni Center. The environment was better than almost any conference I have been to: Large lecture theaters, generous spaces to hang out and chat, catering around the clock. Of course, the most important part of a conference are the people attending it. There were 260 this time; the conference was sold out at that number (the previous Scala Days 2010 conference at EPFL was also sold out at 150 attendees).

The program this year consisted of four tracks of talks, which made it very hard to choose what session to attend at any one time. Quite often, super interesting talks in similar domains were scheduled at the same time. For instance, I had to choose between Jonas Bonér's talk on clustering in Akka and the talk by Josh Suereth and Daniel Mahler on Cascade, an integration of Google's FlumeJava in Scala collections. Which one to pick? Both are exciting developments in distributed computing. In the end, I went to the Cascade talk, and came away deeply impressed. The full power of Scala collections extended to tens of thousands of nodes via MapReduce. Not bad at all. Fortunately, all talks have been shot on video, and I am looking forward to catch up with the talks I missed once the videos are posted online.

Another talk by Googler Robert Hundt was a performance benchmark comparing C++/Scala/Java/Go, which got quite a lot of press attention and reddit comments

The trends of the conference are captured well in James Iry's tweet: "multi-core; distributed; applicative; and we're hiring". There was a lot of activity in parallelism and distributed computing. Three talks on Akka, three talks on parallel DSLs embedded by Stanford's pervasive parallelism lab in Scala, parallel and distributed collections, and several others more. A highlight of the conference was Doug Lea's keynote on JVM concurrency trends. He stressed the importance of dynamic scheduling as found in both microprocessor hardware and processors schedulers and the difficulty of static scheduling in GPUs.

Another difference from last year to this year concerned the number and quality of tech talks. Last year, many talks were about initial explorations of a Scala project; this year most talks reported on some aspect of a sizable projet that was in production, or close to it. And those projects are growing, and spawning off new ones. It's a very good job market for Scala developers, and an exciting time to be part of the Scala community.

The Typesafe Stack includes the latest version of Akka event-driven middleware, version 1.1.  For those of you who have been part of the Akka community for some time, I'd like to highlight some of what's new since Akka 1.0.

Enhancements with the Akka 1.1.x series of releases include:

• akka-actor now has 0 external dependencies. This means you can just pop it into any project you fancy without worrying about bloating your code base.
• Many fewer dependencies in total for the akka modules.  We've tried to remove as many external dependencies as possible, to keep a slim profile.
• Dataflow API for Futures using delimited continuations, so you can write seemingly blocking code that will not block at runtime.
• The Futures in Akka are now fully Monadic which means that they are ready for for-comprehension goodness.
• Futures can now be executed natively on all the Dispatchers, avoiding the overhead of creating, starting and stopping an actor just to execute the body of a Future.
• The dispatchers in akka-actor are now all based on the same foundation, and have received even more tuning, to provide extreme performance and reliability.
• It is now possible to have priority of delivery of messages if needed.  Just look for PriorityBasedEventDrivenDispatcher.
• Akka now doesn't use any logging library internally, but publishes a lot of events to the EventHandler, so you can use whatever logging library you desire.
• akka-remote has received a lot more love, tuning and hardening.
• Akka now has a TestKit module that includes tools to aid in testing actor-based applications.
• Tons of performance enhancements, fixes and new documentation.

If you're an Akka veteran, we're sure that you'll appreciate many of these enhancements.  If you're new to Akka (or Scala), check out our guide to Getting Started with the Typesafe Stack for a head start.

Happy hAkking!

Over the past few years I've had the opportunity to teach quite a few Scala courses, most recently alongside Martin Odersky and Paul Phillips as part of the team at Typesafe. A consistent theme in the feedback from these courses has been the value of immediately applying Scala concepts in hands-on programming exercises. Soon after I finished writing my German Scala book "Durchstarten mit Scala,” Martin and I realized that the structure and depth of the topics in the book, and the consistent step-by-step case study used, would provide an excellent basis for a revised course.

And here we go: "Fast Track to Scala" is the all-new introductory course for Scala from Typesafe. It puts a strong focus on hands-on exercises – you will be writing code at least 50% of the time – and covers tooling like sbt and the Scala IDE for Eclipse, as well as test driven development with the specs2 framework. The core topics covered are:

• Overview
• First steps with Scala
• Basic object-oriented features
• Testing in Scala
• Collections and functional programming
• For expressions and for loops
• Inheritance and traits
• Pattern matching
• XML support

For fast-paced audiences, there are also additional modules for advanced topics like implicit conversions and parameters, (tail) recursion, upper bounds and view bounds as well as real-world applications like writing to a relational database with ScalaQuery or using the Scala API for MongoDB.

I am very excited to give this new course for the first time on Tuesday May 31 and Wednesday June 1, the two days preceding the Scala Days 2011 conference at Stanford University. More information and registration for this course (as well as an advanced Scala course and a fast-track Akka course offered in the same venue) is available on the training section of the Typesafe web site.

I look forward to seeing many of you at Stanford.

by Phil Bagwell

Scala Days 2011, coming up in just a few weeks on June 2-3, 2011 at Stanford University, is one of the most exciting Scala community events of the year.  Nearly all of the Typesafe team will be there, and we’re eager to connect with a broad subset of the Scala community, old and new.  The Scala Days 2011 list of accepted talks and speakers read like a “who’s who” of the Scala world.

Members of the Typesafe staff will be talking about the new version of the Scala IDE for Eclipse and other components of the Typesafe Stack. We’ll tell you what we are doing at Typesafe to make Scala and Akka adoption easier and faster. And you’ll have the chance to tell us what you think we should be doing to make it even easier still.

On May 31 and June 1, the two days preceding the conference, Typesafe will be offering training courses nearby on the Stanford campus.  Martin Odersky, Heiko Seeberger and Viktor Klang will be giving introductory and advanced courses on Scala, as well as a fast-track course on Akka. If you or your colleagues want a fast introduction to Scala or Akka, or are starting advanced library design, this is a great opportunity for in-person training from the individuals at the center of the Scala world.  Learn more about the courses and register online at the Typesafe web site.

The new Scala parallel collections to support concurrent and parallel processing are easy to use and offer a real boost to performance for many common applications. The designers, Alex, Tiark and I, will be at Scala Days to explain how they work and give tips on how to use them.

Speakers from many of the industry giants will be giving talks on their applications of Scala in commercial settings. The talks are being given by the "movers" who successful took Scala into new applications and are now sharing how it was done. As an attendee, you’ll get to hear what works – and what doesn't – and join the conversation yourself. 

On the research side of the agenda, you won’t want to miss the talks on DSLs for heterogeneous computing. Speakers will introduce new concepts in this area, and report on the first practical applications. Already, impressive performance gains are becoming apparent, along with a startling reduction in lines of code. For developers in the multicore world exploring mixed use of CPUs and GPUs to crack big applications, this is the technology to watch. It shows big promise for the future and it is starting to pay off now.

Of course, Stanford is a beautiful and exciting setting for the training courses and conference.  We look forward to seeing you there.

Twenty years ago, when people needed to solve a software scalability problem, the solution was almost always to “scale up” by purchasing an expensive multiprocessor server from Sun or IBM. Then, as commodity hardware grew cheaper and more powerful, the trend shifted towards “scaling out” by using clusters of less expensive servers. Today, with the arrival of commodity multicore CPUs and cloud computing, we face the dual challenge of scaling “up and out” at the same time.

I've been writing middleware systems for most of my career, through the transitions from “scale up” to “scale out” and back again, applying concurrency and distributed computing to solve scalability problems. Along the way, I've always felt that there must be a fundamentally better way to build scalable software. Finally, about three years ago, I decided to do something about it. 

I created the Akka project with the vision of a runtime and programming model that would address the challenges of both multicore and distributed computing. Akka gives developers a unified way to build scalable and fault-tolerant software that can scale up on multicore systems, and scale out in distributed computing environments, which today often means in the cloud. Akka makes it possible to build software systems with reliability and high performance, without sacrificing developer joy and productivity.

In short, Akka is open source middleware for building highly concurrent, distributed and fault-tolerant systems on the JVM. Akka is built with Scala, but offers both Scala and Java APIs to developers.

At the heart of Akka is the concept of Actors, which provide an ideal model for thinking about highly concurrent and scalable systems. Writing concurrent systems using traditional low-level mechanism such as locks and threads is difficult. The resulting software is often hard to understand and maintain. The Actor model provides a higher-level alternative that is much easier to reason about. Actors also provide location transparency, in the sense that the user of an Actor does not need to know whether that Actor lives in the same process or on a different machine. This makes it simple to write software that can scale with the needs of the application. It also gives the runtime the freedom to provide services like adaptive load balancing, cluster rebalancing, replication and partitioning.

Importantly, Akka embraces Erlang’s model for fault-tolerance, colloquially known as “let it crash.” This fault tolerance model works by organizing the various Actors in a system in a supervisor hierarchy such that each component is monitored by another, and restarted upon failure. The model has been used to great effect in the telecommunications equipment industry for years, as the foundation of highly available systems that can adaptively heal themselves while running.

The Actor model alone, while great for many use cases, do not solve all concurrency and scalability problems. By decomposing state into many discrete Actors, the model can introduce challenges for applications that require global consistency. To address this problem, Akka uses Software Transactional Memory (STM), which makes it possible to modify the state of many objects at once, reverting all changes if the transaction fails. In addition to STM, Akka provides several other concurrency abstractions such as Agents and Dataflow Concurrency.

Since the introduction of Akka, the project has attracted a tremendous community of users and contributors. In the past year, Akka has matured with a rich and cohesive set of modules that can be composed to solve a wide variety of business requirements. Now, as part of the Typesafe Stack, we intend to take Akka to the next level with enterprise grade features and supporting commercial services.

We have big plans for Akka. This is just the beginning. And we look forward to partnering with the rest of the team at Typesafe to write the next chapter in software development.

The central drive behind Scala is to make life easier and more productive for the developer -- and that includes me. Scala does this with three principal techniques: It cuts down on boilerplate, so programmers can concentrate on the logic of their problems. It adds expressiveness, by tightly fusing object-oriented and functional programming concepts in one language. And it protects existing investments by running on the Java Virtual Machine and interoperating seamlessly with Java.

I have been involved with Java very early on, from Spring 1995, when it was still in alpha. My main contributions were the Espresso compiler, which became the core of Borland's JBuilder, the Pizza language which led to our work on GJ and ultimately to Java 5 generics, and the GJ compiler, which became Java's reference compiler javac, and which is used by almost every Java developer today. 

About 10 years ago, I decided to take a step back and investigate what needed to be done to meet the next challenges in software development. Java was explicitly intended to be state of the accepted art when it came out in 1995: An object-oriented language with C-style sytax, single inheritance and interfaces. Since then programmers are increasingly facing new challenges for high-level domain modeling, rapid development, and, more recently, parallelism and concurrency. It seemed to me that a unification of the traditional object-oriented model with functional programming concepts was feasible and highly desirable to address those challenges. We first experimented with those concepts "in the lab", using an experimental language called Funnel. Once we were convinced we had the right mix of concepts, we decided to build a practical language on them, and that was the birth of Scala in 2003. 

Scala took a risk in that, before it came out, the object-oriented and functional approaches to programming were largely disjoint; even today the two communities are still sometimes antagonistic to each other. But what the team and I have learned in our daily programming practice since then has fully confirmed our initial hopes. Objects and functions play extremely well together; they enable new, expressive programming styles which lend themselves to high-level domain modeling and and embedded domain-specific languages. Whether it's log-analysis at NASA, contract modelling at EDF, or risk analysis at many of the largest financial institutions, Scala-based DSLs seem to spring up everywhere these days.

Scala's unique combination of features also made it an excellent basis for concurrent, parallel, and distributed computing, which is widely thought to be the next big challenge in software development. Scala has a lot to offer in that space: from implicit parallelism in parallel collections to explicit concurrency using actors, it offers a toolset to write scalable concurrent applications simpler and with more confidence in their correctness. Scala's functional programming genes are an advantage here, because every bit of mutable state is a potential liability when it comes to parallelism, concurrency, and distributed computing. Scala does not prevent traditional imperative solutions, but its design encourages users to search for more scalable functional alternatives.

But the language is also a joy to use outside these advanced domains. It lends itself to any programming task, from one-line commands in the Scala shell to large mission-critical systems. In a nutshell, why do we do Scala? So that people like Graham Tackley, at The Guardian can keep saying "We've found that Scala has enabled us to deliver things faster with less code. It reinvigorated the team."

Typesafe is a company that takes Scala and Akka to the next stage. In this blog I explain a bit why we founded the company and what role we see for it in the world of open source and enterprise software.

Scala has made a phenomenal progression from a research project to a rapidly expanding open source ecosystem that supports many mission critical applications in industry. Ten years ago, I started the design of the language that would become Scala. It was released in its first experimental version in 2003. Five years ago, a vibrant open source community started to form around the language, with projects such as Lift, sbt, ScalaTest, specs, ScalaQuery, squeryl, Scalate, and Kestrel, to name just a few. Three years ago, high profile industrial adoption started, with Twitter migrating their core messaging queue to Scala. Today, there are more than 100,000 Scala users, and the technology plays a strategic role in a rapidly growing number of enterprises.

Akka was conceived just three years ago, and has seen explosive growth since. Jonas Bonér started it as a fresh new approach to address the difficulties of writing scalable concurrent and distributed systems in enterprises. It grew to an extremely active open source project with many core contributors in just a couple of years. Akka clearly addresses a real need, because it is already being deployed by many companies, including some of the largest financial institutions, as a distributed computing backbone.

So far, both projects have been supported largely by volunteers, who have done an amazing job developing and delivering high quality tools and middleware. But given the increasingly strategic role of Scala and Akka in industry, we saw a need to put the effort on a more stable foundation. Scala and Akka users need the assurance that professional support for their systems will be available when they need it. Core contributors need to be given a stable setting where they can concentrate 100% on delivering steady improvements to the code base. That's why we decided to form Typesafe.

Typesafe essentially develops two types of software. On the one hand are the Scala language, core libraries, and Akka middleware. On the other hand, we are delivering a professional development environment, which includes the Scala IDE for Eclipse 2.0 and the sbt built tool. The Scala and Akka runtimes and development tools are bundled together in the Typesafe Stack, which provides an integrated package with one easy install. Each version of the stack will be supported as a certified, stable build via the Typesafe Subscription. The aim is that, together, these efforts will complement the great language experience provided by Scala and the high performance architecture provided by Akka with first-class developer tools, simple deployment, and assured support. Typesafe also provides training and consulting to help users develop and deploy systems written in Scala or Akka.

Typesafe is very much an open source company. Everything we release today is open source, and we want to maintain and grow the open source communities supporting Scala and Akka. The aim is to bring these technologies to the mainstream, and I am confident that we have brought together a great team of people to help in doing that.