The final talk will be about Scala puzzlers, which is always a crowd pleaser. I have a plane to catch so I’ll only get to see the first half.
I’m calling it a day for the liveblog. Finally just let me say a huge thanks to all the speakers and Scala Days staff for a great event. Already looking forward to the next one!
The roadmap to sbt 1.0 basically involves implementing the missing parts of sbt server and spinning out various parts of sbt into separate modules. No release schedule yet for 1.0, but modules will be released individually when they are ready. sbt-io and sbt-serialization are already available.
Compiler support for value types is already partially implemented, but there are still a lot of unanswered questions about how their semantics should work. They will be more powerful than Scala value types, as they will support multiple fields.
Only two talks left. Next up, Josh and Eugene from Typesafe will be talking about the roadmap for sbt 1.0. I spoke to Josh at the party on Monday, so I already know what they’re going to say.
Next up is Simon Ochsenreither talking about value types in the JVM. Value types are tentatively scheduled for Java 10.
He gets a tough question from Martin Odersky, but fields it with aplomb. “Actually I have some backup slides to deal with this question...”
Scalan is a generic framework for automatically rewriting code, allowing you to write code in a high-level domain (e.g. linear algebra using Matrix and Vector traits) but execute it using a performant implementation (e.g. a sparse matrix class and a dense vector class). You need to manually define the isomorphisms for any new domain you want to ‘Scalanise’.
“...And now it is magically 10 times faster.” (deadpan)
This talk is an introduction to a tool called Scalan. It appears to be a compiler plugin that can rewrite your functional code to make it more amenable to HotSpot optimization. I don’t really understand what’s going on but it’s awfully clever.
Noel’s talk turned out to be a really good explanation of the Reader and Writer monads and Scalaz’s ReaderT. The Reader monad is something I’ve never fully understood, so a thorough worked example was great. The slides are here.
It’s a lovely day here in Amsterdam. During the lunch break I escaped the confines of the conference venue and went for a wander around town.
Continuing the functional programming theme, the next talk is “Program Functionally, Execute Imperatively: Peeling abstraction overhead from function programs” by Alexander Slesarenko. He has an excellent Russian accent, which always improves a software talk.
Noel’s presentation is completely executable and is running in sbt. Very cool. I’ll have to find out what sbt plugin he’s using.
Next up is Noel Markham from ITV, talking about “A purely functional approach to building large applications.”
Jon makes it look easy, but you can tell a lot of work has gone into making his Rapture APIs so easy to use. As they say, simplicity is complex.
“I want to open your minds to possibilities of imports.”
Jon makes the point that currently nobody agrees on how we should handle errors in Scala. The possible approaches include try/catch, scala.util.Try, Option, Either, Future, Scalaz Validation, Scalactic’s Or.
I agree with him that exceptions in Scala are inadequate, and it’s good to see someone trying to tackle this.
The keynote was a very intense, fast-paced tour of the machine learning landscape. To be honest it was a bit much for me, first thing in the morning.
Next up is Jon Pretty with the impressively titled Delimited, Monadic, Dependently-typed, Accumulating, Checked Exceptions. His slides are as beautiful as always.
Good morning and welcome to the final day. Today’s keynote is Adam Gibson, co-creator of Deeplearning4j, talking about the future of AI.
Kamon looks like a very useful tool, and a lot of thought has gone into the design.
That’s it for today. My brain is very full. See you tomorrow.
The last talk of the day is about using Kamon to generate metrics. This is a tool that I’ve been wanting to try on some of our work projects, so I’m looking forward to it.
Function-passing style is an “inversion of the actor model”. Data remains stationary, and you pass functions around using asynchronous messaging. They call the stationary data “silos” and the functions “spores”.
Interesting presentation style based on the two speakers constantly interrupting each other.
The State of the Meta talk was really interesting.
The scope of the scala.meta project is much bigger than I thought. They’re building a very generic framework for inspecting and transforming Scala programs. The idea is to build things like macros, as well as many other types such as refactoring tools, on top of that.
There’s a syntactic API, which takes care of parsing Scala source code, and a semantic API that understands what the program means (types, methods, variables, etc.). The APIs are much easier to use than those found in scala.reflect.
Next up is Function-Passing Style.
I’m flagging a bit. Only two more sessions until beer.
My plane dropped like a stone.
The next talk is State of the Meta, Summer 2015. As a macros nerd, I’m really looking forward to this one. The last I heard, Eugene Burmako and his team were in the middle of rebuilding reflection and macros from scratch, so we should get a progress update on that. The slides for the previous version of this talk, in Spring 2015, are here.
Getting ready to fire my little foam aeroplane towards that white dot on the floor. Whoever gets closest wins a drone!
Next up, Joe Kutner from Heroku talking about how the Twelve Factor App principles apply to Scala applications.
One subtle reason why we want to minimise the number of methods in the bytecode: the more methods you have, the less time HotSpot can spend on optimizing each method (because the HotSpot optimizer’s execution time is bounded).
The essence of the talk: by including the TASTY encoding for a piece of Scala code in the classfile, we get access to a lot more information than the Java bytecode can give us. This lets us do things like smarter specialization, dead code elimination, infer more precise types, other optimizations.
Finished lunch, and now listening to the Dotty linker talk.
Wifi is getting a bit flaky, so the liveblogging may be sporadic this afternoon.
Apparently Apple has a 75,000+ node Cassandra cluster storing 10s of petabytes.
“All of a sudden we have an alien attack! But don’t worry, Cassandra is still up.”
Cassandra: “the one thing in your infrastructure you can always rely on”
A GitHub repo is worth a thousand words. Here is the reference application for the Lambda Architecture talk.
Next up: Lambda Architecture with Spark Streaming, Kafka, Cassandra, Akka, Scala. Helena Edelson from DataStax is presenting. The room is packed.
I’d never got around to looking at scala-offheap properly, but it’s really cool. Clever use of macro annotations.
Depending on your use case, using this library to move your hottest objects off the heap could dramatically reduce GC pauses.
They are currently implementing support for the jemalloc allocator, which should speed up allocation time.
I forgot to mention that the venue is AWESOME. Look at this stained glass!
The room for the Actors vs Types talk was full, so I’m watching Denys Shabalin (of quasiquotes fame) talk about his off-heap memory management library, scala-offheap.
After the keynotes, a code-heavy deep dive was just what I needed.
Here’s my tentative plan for the rest of the day.
- Project Galbma: Actors vs. Types
- Lambda Architecture with Spark Streaming, Kafka, Cassandra, Akka and Scala
- Making your Scala applications smaller and faster with the Dotty linker
- Options in Futures, and how to unsuck them
- State of the Meta, Summer 2015
- Function-Passing Style, A New Model for Asynchronous and Distributed Programming
- Kamon: Metrics and traces for reactive application
Phew! I think I’ll need some coffee to get me through all that. Alternatively I could try the suspicious Scala-branded energy drink I found in my swag bag...
Quite a philosophical keynote from Jonas about the concept of time and how we should model it and deal with it in our systems. Interesting stuff. Also touched on some of the computer science theory that influenced the design of things like Akka and event sourcing.
@jboner getting philosophical at #ScalaDays. pic.twitter.com/xoAcfYJXUY
— Banyú (@banyuken) June 9, 2015
"The present is a merge function of multiple concurrent pasts" @jboner keynote #Scaladays
— Jean Helou (@jeanhelou) June 9, 2015
Morning everyone. I’ve just enjoyed an excellent continental breakfast and I’m raring to go. Jonas’s keynote has just kicked off.
Party time! I’m off to load up on free beer so I’ll step away from the keyboard for today. I’ll be back bright and early tomorrow to start the conference proper.
Good question: “How will TASTY and dotty affect compilation speed?”
Answer from Martin: “Hopefully for the better.”
That’s a wrap for Martin’s talk.
It was pretty much the same talk as he gave at Scala Days SF earlier this year, and we didn’t get much more detail on DOT/dotty/TASTY.
I was hoping to get a few details on what progress is being made on solving some of the hard problems that Nada Amin touched on in her talk about DOT last year, but of course a keynote is not the right place for that level of detail.
So far nobody has mentioned the elephant in the room, the renaming of Typesafe.
New research directions for the Scala language:
- Less boilerplate for implicits, e.g. support implicit function types
- Better treatment of effects, but not using monads! Use implicits to model effects as “capabilities”.
“Should have a [dotty] alpha release by Scala Days Amsterdam” according to the slide, but unfortunately it’s not quite ready yet.
Here’s a cool demo that performs sentiment analysis on conference tweets and displays them in real-time. It’s running on Spark.
Martin claims that he never waits for the compiler when working on his 50 kloc project (Dotty, I assume). Progress has been made not on making the compiler faster but on making it smarter, i.e. only compiling things that need to be recompiled. Compilation speed is about 500 lines/second for an average codebase.
Martin is giving his blessing to Scala.js. He seems very keen on it.
Martin just changed the title of his keynote, live on stage. So agile!
Bill Venners is announced as the winner of this year’s Phil Bagwell award.
The official Scala Days Android app is written in Scala and the source is available on GitHub.
Updated
Josh kicks things off with some healthy dissing of other programming languages.
Typesafers spotted so far: Odersky, Dick Wall, Josh Suereth. Odersky should be on stage in a few minutes.
I’ll be liveblogging here throughout the conference. I’ve never attempted liveblogging a conference before, so this is a little experimental. Please bear with me and we’ll see how it goes...
I’ve just arrived at the Scala Days venue and picked up my T-shirt and swag.
I’m looking forward to Martin Odersky’s keynote. He usually saves his most interesting announcements for Scala Days keynotes, so I’m hoping we’ll get some details on the progress of Dotty and TASTY. And maybe we’ll find out the new name for Typesafe?
Updated
