I go to a fair few (probably too many), tech conference and meetups. A passing observation, is that if code samples are shown a proportion of the audience will try to run them while following along. Initially, this seems counter intuitive (to try and both listen and absorbing information while also trying to perform actions as a background task), though my own experience is that this works suprisingly well for practical activities, (maybe the multi-sensory exposure helps learning and retention ?).
With every new year comes a sense of reflection and soothsaying for the year ahead.
I’ll dispense with too much commentary on the past, suffice to say it was a period fraught with duck aligning and preparing foundations to enable more interesting technical possibilities this year.
Given the need to furrow a number of disparate technology channels as part of my day job, has meant a number of personal technology areas of interest have had to be suspended for a time, but hopefully 2012 should renew my vigour and possibilites to return back to the breach.
So, from the last years experience, here’s my thoughts on what looms in 2012, driven by either interest or more likely necessity. I don’t assume these will be general trends, but if past experience is any indicator, my direction tends to reflect that in the general [web] technology landscape.
This post was prompted by a conversation with a good friend, who is an experienced Java developer taking their first, tentative, steps towards becoming a Scala programmer. Basically, the conversation went as follows:
“…Immutability seems good and like a goal I should aim for. How can I get this in my domain objects without having to provide a multiplicity of constructors to do partial updates ? Is it really that big a deal ? I’ve rarely had to worry about this stuff in Java at all !”
Both fair question, which I’ll try to address in the remainder of this post. Continue reading
After many years of Java development, discovering Scala’s type system and related features was something of a departure for me. Suffice to say GADT wasn’t my first four letter utterance when learning about pattern matching on types, let alone what, when and how to use variance annotations and generalized type constraints. To kick things off, here’s a ‘small but powerful‘ few lines of buzzword bingo on the type system:
…Scala is a statically, strongly, typed language, with implicit type inference and support for structural and existential types. It also features parameterized types, abstract and phantom types and is capable of implicitly converting between datatypes. These core capabilities are utilized by context and view bounds and complimented by generalized type constraints, to provide powerful compile time contracts. Furthermore, Scala supports declaration site type annotations to facilitate invariant, covariant and contravariant type variance…
In a word, Ouch !
In the remainder of this post, I’ll try to demystify these concepts and sew the seeds of intrigue for further investigation.
Something I had been meaning to post for a while, was a simple snippet showing the use functions as values and/or variables in Scala and how expressive this is at conveying intent within the code. Continue reading