Fluent Conference 2013 videos (review)

Conferences can be costly, especially when travel, lodging and food are considered. Many companies cover these expenses for attending employees, but many people still pay out-of-pocket. If you’re like me you have to make strategic decisions about which conferences you want to attend in a given year, and which tracks or sessions you want to attend while you’re there. Unfortunately I missed O’Reilly’s annual Fluent Conference this year, but my joy was palpable when I learned that all conference keynotes, sessions, and workshops were recorded. As a member of O’Reilly’s user group program, I was given a set of Fluent Conference videos to watch and review. The complete set includes over fifty-five hours of video that may be streamed or downloaded to a computer or mobile device. (I use a Roku player and a USB drive to watch Fluent Conference videos on my television.)  Each video is professionally recorded, and the sessions are produced in split format so that you can see the speaker and their presentation slides or demos at the same time.

Presently I have viewed all keynote presentations and over a dozen individual sessions. Every speaker has been competent and articulate, and the topics have all been interesting, and some, surprisingly in-depth. I have not yet evaluated the workshop sessions, though if the tenor of the general sessions is any indication, I fully expect the workshops to share the same qualities.

These are the keynotes I found particularly interesting.

  • Brenden Eich (Mozilla) talked about the maturity level that JavaScript has reached over the last eighteen years. He covered ECMAScript 6 features that will bring JavaScript into adulthood. He also demonstrated that, through libraries like emscripten and ASM.js, JavaScript can be used to run applications at near-native speeds. To illustrate, he played a round of Epic Games’ Unreal Tournament, which had been ported to JavaScript and WebGL, right in his FireFox browser.
  • Paul Irish (Google) talked about new Chrome web development tools, including developer workspaces that map browser assets to files on the file system and source maps that track changes between generated CSS and SASS files.
  • Bill Scott (PayPal) relayed his experience porting portions of PayPal’s checkout process to node.js, specifically how he was able to integrate a node solution into an existing Java environment in a piecemeal way to combat regression.
  • Breaking from technology and delving into practice, Kate Matsudaria (popforms) discussed how skill mastery requires an understanding of all abstractions involved in any activity, and why developers should understand the “magic” behind the tools that they love so much.
  • Mike Hostetler (appendTo) encouraged audience members to re-think their definition of “work”. Mike runs a completely distributed company in which “work” relates to goals and activity, not location. This subtle but fundamental thought shift creates enormous benefits for companies, employees, and even the world at large.
  • Lea Verou (W3C) walked the audience through the lifecycle of a web standard and discussed the different people and organizations involved in the standardization process.

These are some sessions I particularly enjoyed.

  • Todd Kloots (Twitter) spoke about the power of HTML5 pushState and the challenges that his team had to overcome while simultaneously supporting modern and antiquated browsers, specifically reconciling URL hash changes with pushState routing.
  • Trevor Burnham (Hubspot) deconstructed promises into their constituent parts and showed how they can be use to aggregate callbacks to fulfill async tasks.
  • Ralph Whitbeck (appendTo) talked about the current state of the popular jQuery Mobile framework, how the jQuery Mobile release cycle works, and what users can expect from upcoming releases.
  • Steven Sanderson (Microsoft) presented an overview of his MVVM UI library, knockout.js. Not to be outdone, Misko Hevery (Google) presented his popular alternative, angular.js. Both libraries specialize in view/logic segregation and provide bi-directional data binding mechanisms, though they differ in template implementation.
  • Eric Elliott (Adobe) discussed the prototypal nature of JavaScript delegation and contrasted it with classical language inheritance. He made a compelling case for rejecting classical thinking and embracing prototypes as a superior means of reuse.
  • Ben Vinegar (Disqus) warned about the dangers of cross-site scripting and demonstrated how the proposed Content-Security-Policy header can curtail XSS abuse by whitelisting scripts.
  • Eric Bidelman (Google) demonstrated how the new HTML5 web component specification will help developers sandbox custom, reusable elements that have their own markup, styles, and scripts. He showed how much of the proposed (but yet unimplemented) web component behavior can be achieved with the Polymer library in modern browsers.
  • David Bruant (freelance) compared two theories of garbage collection in memory-managed languages (like JavaScript), showed how each has its own pitfalls, and discussed what JavaScript developers can do to prevent memory leaks.

I’ve been to many conferences and plan to go to many more. Maybe I will even get to attend Fluent Conference 2014. But until then I can get the learning benefit from a world-class conference in my own home or a favorite coffee shop. The Fluent Conference videos are quality tools for developers and teams to keep skills current and ideas fresh.

The community on STL ALT .NET

STL ALT .NET members were recently given the chance to win free tickets to the St. Louis Days of .NET conference in August by writing (and tweeting) a blog post about the group, what they have learned, and why they enjoy attending.  Here are the winners!

Strange Loop 2011

During the weekend of September 18th, St. Louis became a geek mecca for three days while the third annual Strange Loop conference was in full swing.  The Ballpark Hilton was stormed by nine hundred code slingers who came from the four corners of the earth to revel in the aura of their heroes and vigorously engage in religious wars about their favorite technologies.  It was pretty damn glorious.  Strange Loop is the brainchild of Alex Miller: gentleman, community leader, founder of Lambda Lounge, and parentheses parser extraordinaire.

Here is a brief recap of the best sessions I attended, and my overall impression of the conference this year.


Sunday was broken up into two three-hour workshops, followed by a dinner with conference speakers.

  • Introduction to Clojure.  Clojure gets a lot of love at Strange Loop.  It’s a functional language in the Lisp family that runs on the JVM.  The workshop was conducted by Stuart Sierra, co-author of the Apress title Practical Clojure.  A three hour introduction to anything is bound to be pretty intense, and this workshop didn’t disappoint.  I felt like I was drinking from the Clojure firehose the entire time.  Stuart did a deep dive into language syntax, types, conventions, etc. while attendees followed along in their REPLs.  Stuart is a very good presenter, and in general I found the session to be quite informative.  My only critique is: he spent too much time on data deconstruction, and I believe it cost him time at the end of the workshop, so he was unable to cover all of the material he had prepared.  I think it would have also been nice to see examples of Clojure programs “in the wild”–demonstrations of what can really be done with the language (beyond a slide deck).
  • Introduction to Django.  There are two OOP scripting languages that Strange Loop folk aren’t afraid to admit they use: Ruby and Python.  Of the two, I am more interested in Python, and so I decided to attend a workshop on Django, a popular Python web framework.  Of all the sessions at Strange Loop, I probably learned the most from this one, primarily because I had been working through the Django tutorial already, and also because Jacob Kaplan-Moss is a great presenter.  He walked attendees through the creation of a small Django application, from start to finish, while explaining every key concept in detail as we worked.  It was well-paced, everything was very clear, and really illustrated how Python is simultaneously unassuming and powerful.  Django is similar to other MVC frameworks (Rails, ASP.NET MVC, Symfony) but, more than any other, favors simplicity over, well, anything.  It has no “controllers” per se–each HTTP action is mapped to a Python function that invokes the model and renders a view.  It reminded me of Sinatra in some ways, but with a bit more plumbing.  The configuration cascades, so things defined at the global project level can be overridden in each module (or “app”).

The speaker dinner was very nice — I sat at a table with Bill Odom and Mark Volkmann, local Midwest speakers whose sessions I attended on Monday.  The food was good, the bar was open, the company was nerdy, and a good time was had by all!


The problem with Monday was that there were too may good concurrent sessions, and I could only choose one to attend for each time slot.  This seemed to be a common lament for tweets adorned with the #strangeloop hashtag.

  • Category Theory, Monads, and Duality in (Big) Data.  Erik Meijer (Microsoft) opened the conference with a keynote about the “duality” of noSQL systems and traditional RDBMS storage architectures.  Duality, in this context, does not refer to the Slipknot song (that would have made the talk far more exciting), but rather to the mathematical concept wherein two things share a special relationship because one is a reflection of the other, but with inverted properties.  Meijer’s point was that noSQL systems and RDBMSes share a similar, fundamental approach to storing data, but differ about how dependent data is referenced (think: foreign keys).  In an RDBMS, dependent data points to its principle, but in noSQL systems, the principles point to their dependents.  Meijer’s conclusion was, therefore, that noSQL should be re-branded as “coSQL”, because it is complimentary, not antithetical to, RDBMSes.  I’m not entirely sure what I think about his conclusions.  I am not as mathematically literate as I would like to be, but whenever I hear someone claim that: “you know, X is really just a special case of Y” I get a little nervous, mostly because abstractions can be easily frozen.  Because we have been dealing with RDBMSes for so long, it is easy to slip into a pattern of seeing all data storage as a variation of the relational pattern, and possibly missing the unique things that noSQL solutions offer.  But I don’t think this was Meijer’s intent, nor do I think most people would come to this kind of conclusion.
  • CSS3 and Sass.  In this session, Mark Volkmann talked about the new CSS3 features added by the W3C in recent years.  CSS is the mainstay of web design, and some of the additions to the CSS specification are quite exciting.  More importantly, Mark also talked about the Ruby gem Sass.  Sass does for CSS what jQuery did for JavaScript — it creates a thin abstraction layer over CSS that supports nifty things like variables, mixins, selector inheritance, selector nesting, functions, and even the ability to do away with curly braces in CSS files forever!  Sass files are syntactically very similar to CSS–in fact, pure CSS can be placed in a Sass file and Sass will work just fine.  The Sass executable accepts the Sass file as input and generates a normal CSS file as output.  It can even be set up to “watch” a directory, and any changes to Sass files in that directory will trigger automatic CSS generation.
  • Building Applications with jQuery UI.  I’ve used jQuery for a while, and I’ve used jQuery UI on a number of projects, so much of this session was a refresher for me.  Scott Gonzalez, development lead for jQuery UI, talked about effects and widgets libraries, covering each in brief.  A significant amount of time was spent demonstrating how a developer could tap into the jQuery UI API and make custom widgets, which was particularly interesting to me because I had not yet tried my hand at it.  I was delighted to discover how simple and elegant the widget API is.
  • A Tale of Three Trees.  Last year I took a job at Fpweb.net.  Until that time I had only worked with centralized version control systems, but at Fpweb, the development team uses git.  It took me several weeks to become comfortable with the git workflow, and a few months before I actually began to understand git internals.  In this presentation, Scott Chacon explored the git –reset command; specifically how it impacts the user’s working directory, the index, and the current working branch.  Reset takes one of three arguments for manipulating source files: –soft, –mixed, and –hard.  Previously I had only used –hard to nuke changes that I knew I didn’t want.  This effectively forced my working directory and index to reflect the HEAD pointer in git.  The –mixed argument removes commits from the git index (but leaves the changes as uncommited), and the –soft argument allows you to move the HEAD pointer without destroying changes in the working directory or the index.  Scott talked about several interesting (and somewhat terrifying) things you can do with reset, like create “phantom” commits of files that never existed in the working directory, or magically materialize branches by directly manipulating the git index.
  • Vim: From Essentials to Mastery.  Since I’m a .NET developer I don’t use vim daily, but I’ve been making a concerted effort to use it for side projects and learning new languages on the *nix platform.  Vim is undoubtedly a powerful editor; it supports a massive variety of language syntaxes, and has more plugins than you can shake a stick at.  The initial learning curve is steep, since there are lots of keyboard shortcuts that have to be committed to memory, but the shortcuts all follow intuitive conventions and the productivity gained by never removing your hands from the keyboard is significant.  In this session, Bill Odom covered a handful of “must-know” commands, talked about some very useful plugins (like NerdTree), and took general-use questions from the audience.  When Odom started talking about registers, he quickly went over my head, but the “essentials” were great stepping stones in my journey.
  • We Really Don’t Know How to Compute!.  Gerald Sussman is pretty much the patron saint of functional programming.  His seminal work Structure and Interpretation of Computer Programs is a classic text in computer science.  I’m pretty sure he invented parentheses.  The general demeanor of attendees in his presence was a mix of awe and adoration, sprinkled with a side of childlike hero worship.  Dr. Sussman’s keynote presentation began with the observation that the human genome is a supremely compact collection of information that is used to create complex life.  Modern computation, in comparison, is painfully inefficient and inaccurate, and is used to produce wonders like Angry Birds (my words, not his).  Unfortunately, that is about all I got from his keynote, as the remaining hour or so was a high-speed roller-coaster ride through electrical engineering, physics, and LISP.  But at least I wasn’t alone–the live tweets during his presentation consisted of two basic reactions: “OMG what a genius!” and “Owwww my head!”  I realize that Dr. Sussman is used to speaking to graduate students who are steeped in the halls of higher education, but I do wish he would have tempered his presentation for a lay audience that could have gotten more out of it.  Still, I take his presentation as a personal challenge to improve my understanding, and perhaps if he speaks again in the future I’ll be better prepared.


  • Teaching Code Literacy.  I had the privilege of sharing a lunch table with Sarah Allen on Monday, and our brief conversation about programming and education piqued my interest in her session.  I’m glad I attended; it was easily one of the best sessions at Strange Loop.  As an experiment, Allen created a game called Pie Bakery to teach students the basics of programming.  The game framework is written in Ruby, but she created a Ruby-based DSL called Pie that students use to create their own game instances.  Pie is a stripped-down, simplified language that focuses on core programming concepts and makes it very easy for students to grasp what the program is doing.  While working with students, Allen made two key observations that I thought were very interesting.  First, students were far more likely to continue programming when feedback from their code was immediate.  The Pie Bakery application can run a game as soon as its basic structure is defined, so students could see the results of their effort immediately.  The second observation she made was that students were more likely to persevere when errors were encountered if they were programming in a group setting.  The social aspect of programming made the debugging activity less tedious.  These two observations, I think, can be roughtly translated into the Agile principles of immediate feedback via continuous delivery, and pair programming.
  • The Future of F#: Type Providers.  The (handful) of .NET developers at Strange Loop were very excited about this talk, as it was the only Microsoft-oriented session at Strange Loop.  Yes, we had a small room, and yes, everyone tried to slip in unnoticed to avoid the mocking glares of the Haskell and Clojure fanbois, but we learned a lot and had fun doing it.  Joe Pamer, development lead for F# at Microsoft, talked about F# Type Providers, a new way to query data from nearly any source, in a strongly typed way, without using reflection or code generation, and with all the benefits of Intellisense.  If it sounds like magic, it pretty much is.  Basically, a data source (such as a database, web service, OData feed, etc.) defines a data “schema” which can be understood and deconstructed into objects, properties, namespaces, etc.  Type providers can read this schema, and provide data to the IDE at design-time that will make it appear as if strong types based on that schema have been generated, but in reality, only IL will be generated when the project is compiled.  Pamer also talked briefly about the F# tooling improvements in VS2011; sadly, there will be no refactoring support, but the language remains a first class citizen in the IDE, so we can expect a better integration experience.
  • “Post-PC Computing” is not a Vision.  Allen Wirfs-Brock, Mozilla Research Fellow and member of the ECMAScript standards committee, talked about the “post-PC computing” mantra, and how it is really a simple statement of future change, but not a statement of vision at all.  Apple and Microsoft didn’t have a “post-mainframe computing” vision; they had very specific ideas about bringing computers into the home, into the hands of normal people.  It was this specific vision that allowed them to succeed.  The future of computing, Wirfs-Brock argued, is definitely a web-centric vision, at the core of which will be a shared, ubiquitous language: JavaScript.  He spent the latter half of the talk reviewing new changes to the ECMA standard, and how JavaScript is finding a home, not only in the browser, but on the server as well.
  • Simple Made Easy.  If Gerald Sussman is the patron saint of functional programming, Rich Hickey is at least a Bishop.  Maybe even the Pope.  His homage to LISP, the Clojure programming language, was definitely a pet favorite of attendees and presenters alike, and for good reasons–it is terse, powerful, and has a pretty sweet logo.  Anyway, Hickey talked about the concepts “simple” and “easy”, and how they are really two different ideas that often get equivocated in software development.  He talked about the etymology of each word: “easy” refers to the comfort level a person feels when doing something they are familiar with, whereas “simple” refers to a thing and its complexity (or rather, lack of complexity) in relation to other things.  Hickey contends that developers are too focused on things that are “easy”, that they feel more productive with things they are already familiar with, or that have lower barriers to adoption (fits within an existing environment, team-mates already know the technology, already approved by the authroitah!, etc.).  Unfortunately easy things are not necessarily simple things.  The word “simple” emerged as a way to describe a rope which only had a single strand, in contrast to a complex rope which consists of multiple strands that are entangled in a braid.  Simple software should avoid complex entanglements; it should do one thing, and one thing well, and it should be carefully decoupled from its dependents.  This not only makes software maintainable and extensible, it also makes it easier to understand.  The human brain can only focus on a handful of ideas at one time, so when software is complex (i.e., tangled, intertwined), a developer is more likely to forget essential pieces of information when writing or changing that software.  By carefully thinking about the nature of the software we write, and by choosing languages and tools that promote “simple” development (not necessarily “easy” development), developers can write better, more maintainable software.

Closing Remarks

Strange Loop is definitely becoming one of the premier software conferences in the country.  The conference cost is relatively low compared to the quality of sessions, speakers, keynotes, networking, and tangential events that attendees get every year.  If I could only attend one conference a year, it would be Strange Loop.  It challenges me to look beyond the things I am familiar with, and expands my knowledge of tools, processes, and approaches to being productive and solving software problems.  So, to Alex Miller and every speaker and attendee at Strange Loop 2011, I say thank you, and I’ll see you next year.

Ruby Hoedown V – Friday Afternoon

After lunch on Friday, there were four remaining sessions to go before day’s end.  All were good, but I’m only going to recount the two that left the biggest impression on me.

Alan Johnson talked about his project Handlebars.js, an open source project for templating data in views with Javascript.  It is a spiritual ancestor to mustache but simplifies some of the more convoluted mustache conventions and introduces a slick set of “helpers” that make templating ridiculously easy.  The premise of both Handlebars.js and mustache is that view data should be just that — only data — and that the view should be responsible for organizing that data into meaningful patterns.  In traditional web architecture, this has always fallen to the server (at least on initial page load).  This is fine until you start introducing Ajax calls that are going to load up additional data from the server and use it to populate your views client-side.  At that point, you are probably creating partials on both the server and the client, effectively duplicating code.  Javascript UI frameworks like Handlebars.js and mustache move this all to the client, which means that views and view logic exist in one place.

Alan did a great job demonstrating this and giving the justifications for why this might be a legitimate approach in certain web application categories.  His explanation of why he chose to create a new project instead of simply extending mustache was also interesting (ultimately too much mustache code would need to change at too low a level).

The last session of the day was about debugging techniques in Ruby.  Jim Weirich talked about the Ruby gem Pry, which is like the Immediate window in Visual Studio jacked up on steroids.  He dropped some “pry” statements in his code and ran it through IRB, and whenever a pry statement was executed the interpreter would stop and generate a bunch of data about the current code being executed.  He queried object data much like you would in a traditional debugger, but then he demonstrated how, using traditional file system commands like “ls” and “cd”, one could traverse scopes of execution and examine data anywhere in the application.  Which was pretty damn amazing.  Being an Emacs fan, he also demonstrated how the Ruby debugger could be wired up to Emacs to give a much more “visual” debugging experience.

One thing I didn’t realize is that, in the Ruby community (and perhaps in other open source communities as well), there is a general antipathy toward debugging (tests should find all your bugs, right?), and when debugging is necessary, many ruby developers prefer to simply litter code with “puts” statements to see state changes in the application.  This method is simple, quick, and effective, but is also quite limited when non-trivial debugging is required.

On Friday night, everyone went over to The Red Door bar on Music Row for a fine party hosted by the Github reps who were participating in the conference.  A good time was had by all!

Ruby Hoedown V – Friday Morning

This weekend I’m in Nashville at the Ruby Hoedown V conference.  This is my first Ruby conference, and I am really enjoying it so far.  Mark, Josh and I arrived last night and had drinks and dinner at a local dive bar called Mojo’s.  The night cooled down a bit and outdoor seating was very nice.  I had a wonderful Stone 15th Anniversary Black IPA which is like the love child of a dark porter and a traditional hoppy IPA — very nom — and perhaps the best beer I’ve ever had.  We stayed up way too late talking tech and arguing politics.  It was a great start to the conference.

This morning we heard from Lance Ball at RedHat, who talked about their Ruby application server, TorqueBox.  It’s pretty badass.  It runs on top of JBoss and uses JRuby and the JVM to execute Ruby code.  Cluster management happens through mod_cluster running on an Apache proxy server, which can detect when TorqueBox nodes come online, and when they go offline.  The configuration is stupid simple.  It has a pretty hardcore messaging system, too, for queuing up messages on its internal service bus and delivering them reliably to subscribers.  The whole system is open source, including all of their performance tests (which were pretty impressive).

Before lunch Jon Distad gave a unconventional presentation which was only tangentially related to Ruby (well, programming in general).  He opened with an interesting description about what scientists believe about the nature of existence–how and why atoms form matter that ends up being awesome things like rocks and dinosaurs and humans and stars.  I don’t know about the science involved, but I certainly am interested in doing further research.  Anyway, his main point was that the basic nature of the universe is such that, at a certain level it seems to be chaos, but at another level it appears to be order, which he roughly translated into: don’t be afraid to try new things in life, don’t be afraid of failure, because out of the “chaos” of failure you can actually learn and produce something awesome.  In general I think he made some good points, and it was inspirational.

Over lunch we were treated to the music of The Farewell Drifters, a pretty kickass bluegrass band from Nashville.  They tore it up with a great acoustic set on stage, and all the geeks killed the wifi with downloads from the iTunes music store.  Of all the conferences I’ve attended, Hoedown had the best lunch.

Another post will come later…

St. Louis Day of .NET and Strange Loop sponsor STL ALT.NET

The two best St. Louis developer conferences, St. Louis Day of .NET and Strange Loop, have become sponsors of the STL ALT.NET meetup group!  Each will be donating one ticket to their 2011 events in August and September, respectively.  I’ve attended both of these conferences in past years–they are top-notch events that every St. Louis developer should attend.

See the events page for more details on each conference.

My Strange Loop 2010 Schedule

Here’s my schedule for Strange Loop 2010:

October 14

8:30 AM – 8:45 AM in Pageant
Alex Miller
Welcome to the conference and last minute announcements….

Machine Learning: A Love Story
8:45 AM – 9:45 AM in Pageant
Hilary Mason
Machine learning has come a long way in recent years — from a long-marginalized field so old it still has the word “machine” in the name, to the last, best hope for making sense of our massive flows of data. The art of ‘data science’ is asking th…

The Evolution of the Flickr Architecture, or I Love LAMP, 2010 Edition
10:00 AM – 10:50 AM in RAC Studio
Mikhail Panchenko
Flickr was created over 6 years ago – an eternity in tech years. While the site’s general architecture has has held up fairly well, some pieces have started creaking at the seams. A new crop of engineers has started evolving the site’s architectur…

Adopting Apache Cassandra
11:00 AM – 11:50 AM in Pageant
Eben Hewitt
The Cassandra database is distributed, highly-available, fault-tolerant, and offers an elastic scaling model—all of which make Cassandra a powerful proposition for mission-critical applications. It’s used by many of the world’s biggest web propert…

Civic Hacking
1:30 PM – 1:50 PM in RAC C/D
Luigi Montanez
How can software developers change cities, states, and countries for the better? Last year, we saw an explosion of interest around government transparency. The Open Government movement, spearheaded by open source developers, seeks to make governme…

Real World Modeling with MongoDB
2:00 PM – 2:50 PM in Apollo 11
Steve Smith
Learn to break out of the habits of relational databases and model your data in a better, more meaningful way using MongoDB. Find out where the flexibility of MongoDB can let you rethink how you interact with your data, and how this flexibility ma…

Parallel Programming with Node.js
3:15 PM – 4:05 PM in Pageant
Ryan Dahl
Node.js is inherently a single threaded, single process programming environment — a Node script can run on at most one CPU/Core at a time. This has lead some to comment that it’s an inappropriate technology for the our high density CPU reality. N…

How to Think about Parallel Programming: Not!
4:15 PM – 5:15 PM in Pageant
Guy Steele
Anyone remember the old days, when for good performance you had to worry carefully about which register should hold which variable, and when? Sometimes we still do this to get extremely high performance from critical inner loops, especially when u…

Strange Passions Party
7:00 PM – 9:30 PM in Pageant
Strange Loop 2010 will feature the return of the enigmatic Strange Passions track. Strange Passions is an opportunity for conference attendees to present short (10
minute) talks on non-technical topics. Passionate developers tend to be passionate…

October 15

Enterprise NoSQL: Silver Bullet or Poison Pill?
8:30 AM – 9:30 AM in Pageant
Billy Newport
NoSQL has become the latest darling technology. We will examine its roots, why it became popular in that context, and whether it can extend its reach into mainstream enterprise applications.

JavaScript Functions: The Good Parts – Idioms for Encapsulation and Inheritance
9:40 AM – 10:20 AM in RAC Studio
Scott Bale
Pretty much anything interesting in JavaScript happens with functions. Because of their peculiar properties, a number of unusual idioms have emerged around using them for encapsulation or inheritance. You may be surprised to learn of the possibili…

Classes are Premature Optimization
10:25 AM – 11:00 AM in RAC Studio
Justin Love
Classes are premature optimization, forcing the programmer to freeze method implementations and often memory layouts during the design stage in order to make things easier for the compiler writer. Classes are also accidental complexity forcing the…

Lunch benefiting ByteWorks
11:00 AM – 11:30 AM in Pageant

Lunch will be available (but not required) for $20 with all profits going to benefit St. Louis non-profit organization ByteWorks. Lunch can be purchased ahead of time through the registration system OR some lunches may be purchased on-site (but av…

Panel: “Non-Relational Data Stores
11:30 AM – 12:00 PM in Pageant
Rusty Klophaus, Roger Bodamer, Chris Biow, Steve Harris, and Mike Malone
This panel will be moderated by Ken Sipe and focus on the future of nosql and other non-relational data stores.

Panel: “Future of Programming Languages”
12:10 PM – 12:50 PM in Pageant
Guy Steele, Alex Payne, Josh Bloch, Bruce Tate, and Douglas Crockford
This panel will be moderated by Ted Neward and focus on the future of programming languages, language features, concurrency, and more.

Using F# To Solve Real World Problems
1:00 PM – 1:50 PM in Apollo 8
“Aaron Erickson, ThoughtWorks, and @AaronErickson
So you have seen a few sessions on F# that introduce the concept. Maybe you are now excited about functional programming – or maybe you need a little more convincing to really see how it is used in the “real world”. Come to this session, and see e…

Hidden Web Services: Microformats and the Semantic Web
2:00 PM – 2:50 PM in RAC Studio
Scott Davis
The hard line between web pages (pure presentation) and web services (pure data) is finally beginning to blur. Companies as varied as Best Buy, Twitter, Facebook, LinkedIn, Flickr, TripIt, O’Reilly, and even People magazine have decorated their we…

jQuery – RIA Miracle!
3:15 PM – 4:05 PM in RAC C/D
Mark Volkmann
Developing rich internet applications using HTML, CSS and JavaScript is now a common exercise. While it can be done using only those client-side technologies, JavaScript libraries greatly simplify the task. They also shield developers from most br…

Heresy and Heretical Open Source: A Heretic’s Perspective
4:15 PM – 5:15 PM in Pageant
Douglas Crockford
This whirlwind tour looks at software from the unlikely premise that there is goodness in JavaScript, and that Intellectual Property Law has drifted broadly away from its original purpose, becoming a significant obstacle to the Progrefs of Science…

To see the full conference schedule, visit http://strangeloop2010.com/calendar

St. Louis Day of .NET 2010

St. Louis .NET developers had a busy weekend last Friday and Saturday — over 650 of them attended the third annual St. Louis Day of .NET.  The conference, which began in a crowded WashU meeting room three years ago, has pulled speakers, attendees, and sponsors from all over the United States, and has even gained the attention of Microsoft.  For $200 (or $125, if registrants took advantage of the early bird special), attendees were treated to over 100 sessions on .NET-oriented technologies, open discussion sessions, a great party at Ameristar’s HOME nightclub, and a special keynote by Microsoft representative Brian Goldfarb.  Secondary perks like great swag, prizes, networking, and a used bookstore (that donated all proceeds to charity) added to the legitimacy of the event.  The Midwest is often eclipsed by the big conferences on each coast, but last weekend that didn’t matter — St. Louis developers had a solid, professional, mature conference to call their own.

I attended a number of interesting sessions, a few of which I will briefly enumerate here (IEnumerable<Session>?), although my mental saturation point was nearly reached late Saturday as I struggled to retain retain retain.  For a taste of what the event offered as a whole, check out the sessions and speakers pages on the official website.

WTF# – Ken Sipe

My exposure to F# has been pretty limited, mostly due to time constraints and no immediate reason to add it to my skillset, but Ken’s talk sparked my interest and convinced me that I need to invest some time in this new functional language from Microsoft.  I enjoy Javascript and LINQ, which are not pure functional language implementations but definitely have functional flavor; and a friend who shall remain nameless but who KNOWS WHO HE IS always bugs me to try Scheme, so perhaps this is a good way to ease myself into that world of out-of-control parentheses and alpha-geeks who mock IDEs other than Emacs.  F#, a derivative of oCaml, is a strongly typed language that can leverage .NET framework libraries.  Ken demonstrated that it is more performant than C# in parallel operations, and in many cases results in a smaller IL footprint when it is compiled.  Since parallelism is the Big New Thing, and since I want the most bank for my buck from the four cores idling in my beefy development box, the magnetism of F# is is multiplied.  Off to write some lambdas bitches!

Open Discussion: Entity Framework vs. NHibernate – Jesse Phelps

The open discussions were some of my favorite sessions at #STLDODN.  This particular session was very important to me because I have strong opinions about both EF and NHibernate, and it was good to let everyone know that NHibernate is the One True ORM… I mean, discuss the pros and cons of both ORMs in the context of specific business needs.  There were knowledgeable people present who had used each and had much to contribute to the discussion.  I was even further impressed that there were DBAs present who wanted to know what all the hullabaloo was about, and had very specific questions about the performance, the quality of ORM generated SQL, and the place for things like stored procedures in a system that uses an ORM.  Jesse did a great job guiding the discussion; additionally, no fist fights broke out.

NHibernate and Friends – Lee Brandt

I have been learning the NHibernate ORM for the last couple of months, so this session was a good refresher on some of the associated libraries that work with NHibernate.  Lee covered Fluent NHibernate, a library that allows a developer to specify mapping configurations via a fluent interface (method chaining) instead of those eeeevil XML files.  Personally I think the fluent interface can become a little messy with more complicated mappings, but that downside is offset by two key benefits: a) using fluent allows the developer to refactor both entity objects and affect the mapping directly (since the fluent interface is strongly typed code), and b) there is a performance gain because XML files do not need to be parsed when the application starts.  Lee also demonstrated LINQ to NHibernate, an open source LINQ provider that allows NHibernate sessions to be queried using LINQ syntax.  My favorite quote of the conference came from this session: “We take what the Java guys do and stick an ‘N’ on the front. That’s our originality.”

Open Discussion: Silverlight vs. WebForms vs. MVC – Kevin Grossnicklaus

Like the NHibernate open discussion, this session compared and contrasted three approaches to writing applications in a web-centric environment.  Kevin is an unabashed Silverlight enthusiast, and provided compelling reasons (ease of development, rich user experience, single programming language) for using Silverlight as a platform for internal web applications.  Many there, including myself, have jumped onto the MVC wagon, and argued that web technologies should not fight the web stack, but embrace it (i.e., Javascript should be in everyone’s toolbox, ViewState is evil, and id attributes should not be hijacked).  The WebForms developers were fewer in number than I expected, and were interested in understanding *why* the MVC developers had jumped ship.  Everyone had at least some experience with Webforms, so it was much easier to compare technologies.  Nik Kalyani, co-founder of DotNetNuke was present for the discussion, and provided some observations about the challenges he experienced using WebForms as a platform for the DotNetNuke CMS.

Going Independent 101: Lessons Learned from a Decade of Independence – Michael Eaton

By far my favorite session, Michael’s highly practical and highly personal talk about working for oneself was both entertaining and inspiring.  Michael started by telling everyone about his personal path from corporate cube dweller to independent software developer, being very careful to point out his mistakes along the way so those who might follow could avoid the traps he fell into.  He covered practical topics like time management, finding clients, self-discipline, hiring an attorney and an accountant, etc.  He talked about the tools he uses to successfully run projects, including his trusty notebooks for brainstorming and tracking client time (It’s not software! Heresy!).  He stressed the point that, above all, being independent gives him the flexibility to invest in his family and personal life, often a powerful motivation factor for those who want to be self-employed.  Michael’s hard work and success definitely lit many fires in the room.

There were many more great sessions that I was unfortunately unable to attend — nearly 11 sessions running in parallel every hour.  I was forced to pick and choose, and the decisions were difficult but I was not disappointed with the quality and variety of the sessions I attended.  A big thanks to all organizers and volunteers who made STLDODN 2010 a big success!