Crisis in Open Source Land

Crisis #1 – WTF Happened to the Git Reference

For those of us who have not had the “aha” Git moment, and do not have every Git command memorized, a complete reference is indispensable. For G_d knows how long more topics in the only known complete reference have been broken than I care to count. Looking up every Git issue we encounter on Stackoverflow without a reference to put it all in context is a helluva way to come up to speed. This is like the Git cognoscenti putting a big sign on their clubhouse, “Hey, we learned it on our own”.

UPDATE: Github fixed this October 30. Thanks Github!

Crisis #2 — Microsoft Research Abandons Power Pack Collections Documentation

And the same goes for the Collections.Tagged documentation page. For now you can still get collections and collections.tagged on the Way Back Machine.

OK, not that many people care about F#, but if you come to my blog there is a good chance you do. MSR has probably been intending to take this page down for a long time. It was documenting an old release of the Power Pack Collections, but still better than nothing.

HashSet – Who cares. I think this got deprecated to something in the .Net generics collection.

HashMultiMap – Seems no one cares about this one either. Even though it is not a functional data structure, someone might find it useful, if only it were documented.

LazyList – <hyperbole>Everybody</hyperbole> uses LazyList. In fact, I’m baffled why the FSharp Team hasn’t integrated LazyList into FSharp.Core. It is in the Microsoft.FSharp.Collections namespace. So it’s bad enough F# newbies wonder why they can’t call up the docs in Visual Studio Help Viewer.

The Unifying Crisis

What I consider a bigger deal is the difficulty in formatting open source project documentation. Let’s face it. People who like to code open source projects like to code, and generally dislike writing documentation. My interest here is primarily .NET open source projects (my wish list applies to .NET projects), and admittedly I have not dug very deep into the solution. Open source authors and consumers would benefit greatly, and make project adoption much easier, if there were good tools for generating nicely formatted documentation outlines.

Ideally a markup language to generate Visual Studio Help Viewer format. (And ideally a way to integrate it into VS Help Viewer.)

Ideally a tool to generate a reference skeleton from the project code.

Less ideal would be generation and markup for any decent pseudo-standardized reference format. (There is probably something already available that will do this into Java Docs format, but really, do we have to?)

And I am sure there are some who are thinking “Unix man pages are just fine”.

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](http://www.siliconvalley-codecamp.com/Sessions.aspx?ForceSortBySessionTime=true&AttendeeId=583)

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.

Twitter

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 TDD

SQL Design Patterns

Just learning from Jim Bears about tSQLt.org 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.

Slides

Companion F# Demo

Purely Functional Data Structures (1996)
Purely Functional Data Structures (1998)
Purely Functional Stepchildren
DS_Benchmark
Benchmarking F# Data Structures — Introduction
Benchmarking F# Data Structures — Loading Data
FSharpx.DataStructures
Double-ended Queues for F#
Eric Lippert’s Comma Quibbling
Nick Palladinos Comma Quibbling
GC Performance Counters
LazyList
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#
Catamorphism