prose :: and :: conz


ÜberConf Days 3 & 4: Hits and Misses

The last two days I hit some great sessions and some blah sessions. As I mentioned in my last post, my favorite part about this conference has been the people I’ve met and not the sessions as much. The third day I really saw that it can be tricky because although you can respectfully bail within the first five minutes of the presentation, I haven’t been able to decide if it is a miss until I’m in too far to make a switch.

Fortunately the day started off awesome with Matt Stine applying Uncle Bob Martin and Michael Feather‘s SOLID OOP principles to functional programming. As Matt pointed out, principles are universally true, and hence there should be no reason we cannot apply SOLID to functional programming. He did a fantastic job of demonstrating these principles with some Clojure code that I was able to mostly understand. The coolest part of this presentation was towards the end when he brought up the notorious Simple Made Easy keynote by the venerable Rich Hickey, and defined each of the SOLID principles in terms of complecting stuff that should be separate.

After such an outstanding talk, I thought I’d hang around and enjoy Matt’s next talk, Programming with Immutability. I should have read the overview/slides before this one started because it was all Java. Granted I still enjoyed the topic, I probably could have found something more relevant for me. Once he got into some details of different libraries to aid Java developers in adopting more immutability, I caught a severe case of disinterest and worked on yesterday’s blog post.

The next talk I attended was another dose of Nate Schutta titled You’re an architect… Now what?. I thought this would be a good one given my previous experience with Nate and my still-recent entry into the world of architecting. I came out of this talk quite reassured about how I’ve been approaching my opportunity.

After lunch I caught Rob Spieldenner showing off some of Netflix’s cloud goods. As much as I really enjoyed hanging out with Rob and Dan Woods from Netflix, this was not the talk for me. In a nutshell, it was a workshop on AWS using stuff that Netflix built because they don’t use Elastic Beanstalk. Although Rob did a fine job with the workshop, it just brought me back to how much I don’t enjoy the AWS aspects of my job.

I had no qualms skipping the second half of the AWS action for some scaling agile action with Esther Derby. This talk was probably better than I realized, but the exhaustion of the conference was building quite strongly by this point. I wasn’t able to focus very well, although I did live tweet a handful of good nuggets. Other than my general interest in agility, my primary motivation for attending this talk is to be prepared for when my team grows or our project gets other teams working on the code base. The problems we have at our tiny size will be very different from the ones we’ll have when (not if) those things happen. The biggest point that resonates with me is her suggestion to not divide teams up by component/function. Each team should be full-stack and able to deliver working pieces of functionality without depending on another team for the rest of the vertical slice. Beyond that I mostly came away with more reinforcements for what I’m already learning at work and through other resources such as This Agile Life.

I started the next day watching Rob talk more about Netflix, but this time it was about continuous delivery. Although I like where my team is on this front, I know we could get better. One of the most interesting things I discovered is that they don’t just deploy application code like we do. Their teams build out (or “bake” as they like to call it) the application code along with a machine image which eventually gets dropped and deployed on the cloud. I also learned that there are a lot of monkeys running around their cloud. The have scripts they’ve given monkey names that randomly kill off machine instances in production, in addition to scheduled drops of availability zones and regions.

Next up was some JavaScript patterns with Raju who I’ve found is yet another fantastic No Fluff presenter. Even though we use CoffeeScript at work for all of our JavaScript, I expected much of the patterns to translate. I came home with some new tricks of my sleeve. Unfortunately as you can guess, most of what he showed was things to keep you from dying in the wild world of JavaScript, many of which are handled for us in Coffee.

And then, there was Venkat. I must say that the schedule set up to save the best for last. I hung out with most of the speakers at the conference, and every single one of them would back me up when I say that Venkat is a rock star developer, teacher, presenter, anything software. This first presentation of his that I attended was on Nashorn, the JVM JavaScript engine which ships with Java 8. Although I left the talk still not sure how I should use JS on the server, I learned that it is a well-designed/smooth tool in the JVM tool belt. The FFI interop with Java is very impressive. I also found it quite interesting that it actually has a “script mode” which gives you a handful more tricks to use in your JavaScript. I also didn’t know that it is packaged as an executable with the JVM so that you can get a REPL or pass it a JS file to execute. As a result, you can shebang the top of your JS scripts and now you have executable scripts like any other. The sickest feature I saw was how you can define a Java interface to match the functions you have in your JS, and on the fly it will provide an instantiation of that interface which is wired up to the underlying JS. As I’ve said before, I’m particularly excited to see the JVM really embracing its emerging role as a polyglot runtime environment. Overall very cool stuff, very well presented.

And then, there was Venkat on Haskell. Finally, I sat down and learned me a Haskell for great good. Over my career, I’ve learned that there is only one way that I really uptake another language. That is, I have to watch someone walk me through the first steps. Until that happens, I’m all talk. I learned C, C++, and Java at my university (yeah, notice the embarrassing lack of functional languages there? I’m still nudging them over that problem). I picked up Scala from Martin Odersky’s free online course. Dave Lee exposed me to CoffeeScript while presenting a JS library at HuntFunc. I picked up Clojure earlier in the conference, and now Haskell. The two exceptions to this is JavaScript (necessity and deceptive ease) and Groovy (as a super-set language, I didn’t need to learn much to get started). I believe the biggest thing that slows me down from starting a new language is the fear of how much time I will invest before realizing any productive gains. For some reason in my mind, I feel I’ll get over that hump more quickly if there is someone showing it to me. Anyway, I digress. On to Haskell.

Haskell is every bit of bad ass I expected. I was pretty comfortable with many of the concepts because of my work in Scala. As much as I love type inference in Scala, I didn’t realize how much I was missing. Haskell will look at the body of the function and infer output AND input types. I’ve been doing Java and Scala so long, that it hadn’t even occurred to me that such a thing could happen. I really love the ideas behind having an IO monad and all that good stuff, and it was cool seeing it in action. One thing I didn’t expect to see is how the inputs to a function can be pattern matched right there at declaration time, reminding me of what I’ve seen in Erlang. I also had forgotten how every function in Haskell takes at most one argument. More arguments just means that you’re really returning another function with the next argument. Unfortunately, I’m in the same place with Haskell as Clojure… I don’t know what I should aim for next. I need to dream up something I can build with each one.

So that was the rest of the sessions I attended. As I’ve said many times, the best part is the stuff I’m not bothering to write up: Hanging out with other developers. Although I enjoyed a lot of talks at this conference, I would gladly return only to hang out. I’ve made some great connections that I’m excited about and I look forward to what some of us might be cooking up in the near future. Stay tuned.

Leave a reply below, or send me a tweet.

Tagged with: functional-programming (31), java (22), agility (7), clojure (5), conferences (5), cloud (4), uberconf (4), haskell (3)