My Silicon Valley Code Camp Wrap-up

We are living in the Golden Age of Software Engineering, so it’s a special fate to be living and working in the Bay Area connected to this industry. Do you want to have this conversation in your old age as you bounce your grandchild on your knee?

“Grandpa, what did you do during the Golden Age of Software Engineering?”

“Well…I wired-up CRUD apps in Milpitas.”

Get out there and benefit from the learning and socializing opportunities in our craft!

A couple weekends ago was the 7th annual (but my first) Silicon Valley Code Camp. I’ve been missing out, and so are you if you didn’t go. It’s two days of hundreds of technical presentations by informed speakers and the fellowship of over 3,000 techies, mostly from the Bay Area, but I met attendees from as far away as Germany.

This is my personal retrospective of the event, covering the sessions I attended and the one session I hosted.

A special shout-out to Peter Kellner for not only organizing SVCC, but being the inspiration behind it.

Scala for Java Developers

Ramnivas Laddad

My main interest was learning enough about Scala to compare it and the Java environment to F# and .NET, my area of interest. I learned Scala has a flatten operation useful as a catamorphism, for instance, for extracting values from the Some option and eliminating None from a list. This would be useful in F#, where you would have to write your own function over a fold to do this. There also is a specific operation for tail recursion that will give a compile time error if your operation is not tail recursive. It takes experience to easily recognize the difference, so I can see the usefulness of this especially for beginners.

Coming from an F# perspective I was surprised to see so much emphasis on the OO aspects of Scala at the beginning, however it has been years since I first started learning functional programming. Ramnivas’ introduction was well-structured and effective. As I expected the lack of “white space as syntax” in Scala jumped out at me. Anyone designing a new language should really consider this feature. In our information overloaded lives extraneous symbols are noise providing no utility.

Why ‘Friends of Friends’ matters: Applying graph databases to much more than social

I’ve wanted to learn about graph databases for a long time. David Montag’s session was a much better “intro” than focusing on nuts and bolts Neo4j operations to would have been. I’ve wanted to learn about graph databases for a long time, and jumping right into real use cases for the entire session was a very effective introduction to the technology.

Improving your .NET build process with Nant and CruiseControl.NET

I wanted to wrap my head around .NET build/deploy again, and Joe Enos provided a good session concentrating on CruiseControl.NET, which I have used before, but I learned Team City is perhaps the more modern way to go.

Working with Functional Data Structures, Practical F# Application

At least 8 (no more than 10) people showed up for my talk, which wasn’t too bad considering the somewhat esoteric nature of an intermediate F# topic, and my time slot was paired with the only other F# talk of the entire conference. It was, however, the only talk attended by two pigeons (more on that below).

First, what went wrong

This was the first time I gave this talk, in fact the first time I spoke at any conference. I needlessly worried my session wouldn’t last long enough. So I got off-plan and babbled through the first several slides. I apologize to my audience for that.

Next, there was one early slide where I intentionally mis-used a technical term intending to make a point. Bad mistake. A presentation is no place to try to pull that trick…so that slide gets reworked.

Third thing that went really bad was the first demo code session. I rarely use fsi, and this demo relied heavily on fsi. By the time I put the finishing touches on the presentation and demo code I was really tired, and opted for a good night’s sleep before the conference (right choice) instead of working through the entire presentation one more time. Everyone wants to see code demos, but to pull it off really takes a lot of practice, and/or they have to be kept really simple. My plan now is to change the first two of three demos into additional slides, which will keep the story moving.

Then the pigeons. Two pigeons flew in and roosted at the back of the room right at the end of what felt like a horribly botched first code demo. They continued ruffling their feathers and generally making a nuisance for what seemed like about two-thirds of my talk. Finally a member of the audience, with much trouble, managed to encourage them back out the door they flew in.

Because I didn’t stay succinct enough time ran out on the finale of my presentation, but not by much.

Then, what went right

I think I perfectly judged the amount of material to present in an hour and a quarter. I just babbled too much. Next time I will be confident in staying succinct.

As a whole my material and the presentation tells an interesting technical story that flows to a good conclusion. With a little reworking the next time, still unscheduled at San Francisco Bay Area F# User Group, should be a success.

{For Those About to Mock](

Mathias Brandewinder provided an effective session conveying an understanding of unit test mocking and dependency injection by working through an example unit test situation. Dependency injection is surrounded by obfuscation in the literature. This session cleared it up for me. Not a lot to say other than this was a very worthwhile session.

The Art & Science of Managing a Web Presence

As Alyson Harrold predicted at the beginning of her presentation, assisted by colleague Massimo Paolini, I only paid attention to 7% of Alyson’s words. The rest of my attention was reflecting on my efforts at building a web presence and personal brand.

This Blog

One of my first motivations for starting this blog was a way of organizing notes for myself. In terms of branding, this is rather appalling.

My second motivation was learning by teaching. Most of the topics I blog about I have just learned myself, or I am in the process of learning. Writing an article deepens my understanding. The trade-off is I proceed in covering new material at a snail’s pace. Teaching is not a natural instinct with me. It has required a lot of effort, and I believe I have progressed moderately at improving the quality and interest of my articles.

But all in all I find improving the quality of my blog is a slow laborious process.


I think I do a good job of controlling my Twitter presence. Just factual tweets with content on a consistent range of tech topics, no politics, culture, or blah-blah about how I’m feeling right now. Massimo was adamant that a tweet without a link is worthless.

Still looking for a Twitter client. I think I’ll write a whole post on this topic.

Google+ … or my lack of presence on Google+

Google is and will continue to be for the foreseeable future the dominant external force in shaping my web presence, and I had absolutely no presence on Google+ and never used it. This is probably the right venue for on-line note publishing (not my blog).


SQL Design Patterns

Just learning from Jim Bears about in the TDD session would have been worth the price of admission (had it not been free of course) to both his talks for me. He could have just powered through more design patterns, but I did at least find course material on his website.

Sensor Fusion on mobile devices for Lifecare

I could say I enjoyed attending a “blue sky” session as a fitting finale to SVCC, except the exciting material Siamak Ashrafi presented about applications using the sensors in your smart phone is already reality today. The night before at the speakers and volunteers dinner I sat with some mobile developers who were positively excited about developing mobile sensor apps that benefit mankind, and this session made me understand that feeling. The session ended with lively discussions among speaker and audience. Very exciting stuff.

SVCC F# Working with Functional Data Structures Bibliograpy

Bibliography for my presentation, Working with Functional Data Structures, Practical F# Application, October 6 at Silicon Valley Code Camp.


Companion F# Demo

Purely Functional Data Structures (1996)
Purely Functional Data Structures (1998)
Purely Functional Stepchildren
Benchmarking F# Data Structures — Introduction
Benchmarking F# Data Structures — Loading Data
Double-ended Queues for F#
Eric Lippert’s Comma Quibbling
Nick Palladinos Comma Quibbling
GC Performance Counters
Are functional languages inherently slow?
The benefits of purely functional data structures
Functional Pearls Red-Black Trees in a Functional Setting
F# vs Mathematica: red-black trees
Red-Black Tree Remove
Implimenting IComparable in F#