I saw a lot of great sessions, but I focused mostly on a couple of topics. I really enjoyed the sessions on algorithms, parallel programming, and Netflix’s use of AWS. I attended an evangelical (in a good way) session by @jonkruger on Ruby on Rails from a .NET developer’s perspective. I also worked through a bunch of Ruby Koans during the PreCompiler. This is the year I’m going to build some Ruby on Rails projects.

Another favorite session was Functional Programming for Everyday .NET Development by @jeremydmiller. I met him the previous CodeMash in an Open Spaces session on FubuMVC. This year, his presentation on applying functional programming techniques to everyday C# programming was among the most informative and useful for my day job.

An early session on the first day, Asymptotics and Algorithms, by @garyshort was a lot of fun. I dredged up old CS undergrad knowledge as he walked through Big-O notation and measuring some sort algorithms. In fact, his presentation was better than the one I remember receiving in school.

Of course, the @chadfowler keynote was interesting. I never thought a talk that uses examples from Six Sigma management strategy for 1/3 of the material would be so entertaining.

The other keynote I loved was by Scott Chacon (@chacon) of GitHub on what he called the “Developer Driven Development” philosophy of GitHub and why it works. It was an inspiring talk with the core being that the three things that motivate creative work are autonomy, mastery, and purpose and the Open Source way of doing development with decentralized, autonomous developers who can choose when, where, and what to work on is a great model for emphasizing those motivators. It works for GitHub and it an work for you.

I may have more detailed write-ups later, but I wanted to get some initial wrap-up thoughts down while they were still fresh in my mind. I highly recommend this conference. This was my fifth year attending and next year will hopefully be my sixth.

Once again, I will be attending CodeMash. I’ll blog about anything I find particularly exciting or interesting. It should be fun. Look me up if you are attending.

Topics at CodeMash are varied and atendees are encouraged to attend sessions outside their comfort zones. I see CodeMash as a valuable way station on the raod from journeyman to master, a place where the pragmatic meets the esoteric and the everyday programmer can be exposed to ideas and practices that illuminate the deeper nature behind and practices of software engineering. I certainly had that experience this year.

The first day was packed with events. Our first keynote was delivered by Neal Ford, Software Engineering & Polyglot Programming. The takeaway was a vision of the future of programming where the language is separate from the platform and we take advantage of solid runtime platforms like the JVM or .NET CLR while casting aside the cumbersome languages traditionally associated with them in favor of more productive, more dynamic languages. For example, Groovy on the JVM or IronPython on .NET. In Ford’s view,

Testing is the engineering rigor of software engineering.

By combining dynamic languages on solid runtimes with rigorous testing practices, software “engineering” can begin to live up to its namesake.

Joe O’Brien’s Ruby Testing Mandatory talk was one of those “outside my comfort zone” talks, as I know very little about Ruby. But, the testing support Joe showed was quite impressive. It is a mandatory practice because:

1. It’s included in the language
2. It’s easy & you can make it easier
3. There is nothing you cannot unit test in Ruby

With a powerful, dynamic language like Ruby, you can easily do stupid things, but testing can help you catch problems earlier, mitigating the risk. This conclusion sounded, unsurprisingly, like Neal Ford’s keynote. But, I was sold on the importance of testing last year. The take away from this session for me was seeing how awesome the Ruby tools are. I think I briefly experienced the Reality Distortion Field that seems to be increasingly turning otherwise rational programmers into Ruby zealots. I’ll definitely be making some time over the next few months to play with Ruby.

Continuing on my non-.NET language tour, I stopped by Catherine Devlin’s, Crash, Smash, Kaboom Course in Python session. It was a very code heavy session and I surprised myself by already knowing much of what she discussed as she introduced Python programming via the development of a solar system modeling program, complete with realistic gravitational forces and exploding planets. It was a fine introduction to the language and I was relieved that the example project was not yet another Web app. Yes, Python can do more than Web pages.

After lunch, I had the great pleasure of seeing the best keynote of the conference, Mashing it up with IIS7, delivered by Scott Hanselman. The talk of the conference was actually the first ten minutes of his presentation which was, basically, stand-up for geeks. When the keynote presenter uses LOLCat slides in his presentation, you know you are in for a good time. The presentation itself was on hosing PHP on IIS7. Despite some technical difficulties during the presentation, it was great. I wish we were upgrading soon because I was sold on the new feature set. I am actually starting to gain a little respect for the IIS folks. I’m not ready to give up my beloved Apache, but IIS7 looks sharp and I hope I get to play around with it soon.

As an aside, the highlight of CodeMash for me was talking with and rocking out with Scott playing Rock Band during the Day 1 party. He seems like a very nice guy, knowledgable, and a quick study on the drums. I actually think many people found Rock Band to be a centerpiece of the event. You could always find the most interesting people hanging out around the game as well as the funniest moments. I have a grainy cellphone video of a “cowbell” incident that I’ll post in the near future for those that were there. The funniest thing about the Rock Band setup was that there was a real band playing next door.

I skipped the first of the vendor sessions in the afternoon due to being really tired by this point. In the afternoon, I checked out Kevin Dangoor’s, Introducing the Dojo JavaScript Tool talk. Being a complete JavaScript novice, I found it very informative. The feature set is huge and the care taken in making the core libraries as compact on the wire as possible really impressed me. The quote of the session:

The great thing about Dojo is that you don’t need to know JavaScript well.

The final session of Day 1 was Dustin Campbell’s Putting the Fun into Functional with F#. This was my favorite session and I heard many other atendees remark that it made their head spin. As Dustin explains, F# is a HUGE language developed by Microsoft Research that fully implements the three major programming paradigms we have today: functional, imperative, and object-oriented. The talk focused on the functional aspects. I think I learned more about functional programming from this one talk than from all the intermittent reading of Lisp websites I’ve done over the past few years. Since the language comes with the full source code, I’m really excited to download and play around with it. Dustin also appears on the latest Hanselminutes podcast and does a good job explaining some of the points he made in the talk. I listened to it on my way home tonight. I think F# is going to be a big deal in the .NET community once people wrap their minds around the functional aspects. There is so much power there, yet the language is also very accessible to current .NET/C# programmers.

After dinner, the Attendee Party commenced where the aforementioned Rock Band rocking out occured. Great times were had by all. I was originally going to summarize my entire CodeMash 2008 experience in this entry, but as it is already getting late, I’ll end it here. Stay tuned for my summary of Day 2, which included an utterly fascinating keynote by Brian Goetz on concurrency programming and some Perl bashing from Bruce Eckel.

Mike and I decided to try making some quick and dirty podcasts of each day using a new microphone that he obtained. The result of our first attempt for Day 0 is linked below. The quality isn’t great, but it was our first attempt and done with nothing more than Audacity, a Macbook, and a microphone.

The real events start tomorrow. I’m not sure if I will live blog like last year. That’s pretty hard and my battery is unlikely to last the entire day, but I will at least take some notes and post when I can.

CodeMash 2008 (HTML)

CodeMash 2008 (RSS)

CodeMash 2.0.0.8 is coming in January. If you missed last year’s inaugural conference, check out some of my posts from last year to get a feel for the event. If you are interested in attending, early-bird registration is about to end this week. The session list for this year is shaping up to be even better than last. Last year there was a lot of .NET and a significant amount of Ruby. This year, it looks like a lot of .NET and a bunch of Python. I guess I better brush up on my Python skills before January.

The big themes of the conference were definitely DSLs and SOA.  I particularly liked the Joe O’Brien sessions on Ruby and Rails in the Enterprise.  Scott Guthrie was a very dynamic speaker.  Everything with him was “super.”

I now have some ideas for things to implement back at work.  After the conference, both Chas and I bought Programming Ruby and From Java to Ruby.   The later book was recommended as a good source of business case arguments for some Ruby adoption in the Enterprise.

I can’t wait for CodeMash 2008.  I’ll probably have more to say about these topics and even perhaps the conference itself later this weekend.  For now, I’m tired and we have a long drive ahead of us in the morning.

These are “live” notes and necessarily rough.

Today’s Problem: Data != Objects

Traditional data access includes a mixture of languages (SQL and native code), arguments loosely bound, results loosely typed, compiler cannot help catch mistakes and queries in quotes within the code.

In LINQ, classes describe data. There is encapsulated business validation. A query is a natural part of the language and the compiler provides intellisense and type-checking.

LINQ can query against objects, relational, and XML. Also, LINQ enabled ADO.NET – LINQ to Datasets, LINQ to SQL, LINQ to Entities. Plugin architecture, can create new “LINQ to” modules.

LINQ Basics

Query operators can be used against any .NET collection (IEnumerable)

• Built-in examples: Select, Where, GroupBy, Join, etc.
• Extensibility model supports adding/replacing them

Query Expressions can operate on information sources and apply query operators against them to return IEnumberable sequences. Chain operators together.

Projections

• Take results from expression and modify it in a different way
• Enables “data shaping” in query expressions

Projections w/ Anonymous Types makes the compiler create an object with the properties of the type on the right-hand assignment of the first assignment. Still strongly typed at runtime. Very cool.

LINQ to SQL

• Maps .NET classes to relational SQL data
• translates LINQ queries to SQL execution
• Supports change tracking for insert, update, delete operations
• supports entity-level validation rules
• built on top of ADO.NET and integrates with connection-pooling and transactions

Associations

• Usually expressed with PK/FK
• Relationships inferred from FK

LINQ can implement server-side paging and complicated joins.

LINQ different from embedded SQL in that it is strongly typed and can also query against different data sources, not just relational databases.

LINQ for SQL Architecture Services:

• Change tracking
• Concurrency control
• Object identity

db.SubmitChanges() will generate SQL code to update database. Can drop down and put in your own SQL or stored procedure, but really shouldn’t do this unless really necessary.

Implicit or explicit transaction scope.

BLINQ

• UI scaffold
• Point to DB and it will create CRUD pages
• Generates LINQ for SQL data model
• Easy way to quickly build CRUD pages against data models
• Free download today

LINQ for Entities

• Entity Data Model (EDM) enables rich conceptual modeling of data
• Entities can be split across multiple tables, and support rich inheritance
• Higher level of abstraction
• Full LINQ support over EDM definitions

LINQ to XML

• Declarative construction of XML document
• Support for language integrated queries
• Cleaner, simpler, smaller and faster XML API
• Does XML TextReader for you

There was lots of stuff in this presentation, so check out the slides, especially for the code samples.

Fin.

These are “live” notes and necessarily rough.

Three Step Process to Get Ruby into the Enterprise

1. Developer’s Helper
2. Enterprise Glue
3. Application Development

Developer’s Helper

• Ruby the language
• Rake
• Capistrano

Ruby the language

• every developer needs a scripting language
• repeated tasks are automated
• mouse clicks become scripts
• IRB rocks! Interactive shell environment for running Ruby

• Ruby is cross-platform, so you can call up IRB in various systems
• Can run scripts from within IRB

Rake

• “Make done right…finally”
• DSL for automating tasks
• Dependency based programming

What about ANT?

• Works well to a certain size of project
• Not a scripting language, but you start needing scripting language features on larger projects

Capistrano

• a sysadmin’s dream come true
• deployments become:

• standardized
• remote
• easy

• cap setup
• cap deploy
• cap rollback
• cap update_code

Enterprise Glue

• XML with REXML and Builder
• Faster CSV
• Watir (for testing)
• ActiveRecord

REXML

• Processing XML
• Tree parsing
• Stream parsing
• Can generate XML, but very API focused, so Builder is better for generation

Builder

• DSL for creating XML files
• Uses the power of Ruby to generate XML from code
• No sharp pointy brackets

Faster CSV

• Library for CSV file parsing
• Nice clean interface
• The CSV in Ruby trunk is very slow, use “Faster CSV”

Watir (Very Cool)

• Testing community has harnessed Ruby for testing
• Web App Testing In Ruby
• DSL for ‘driving’ your web app
• Now works on more than IE

ActiveRecord

• ORM for Ruby on Rails
• Can be used stand alone
• Flexibility and stability in data migration
• Nice DSL for accessing your data
• Classes represent tables
• Objects represent rows
• Attributes of objects represent cells

ActiveRecord opinionated software

• Convention over configuration
• no XML needed
• give up a little control
• gain speed of development
• gain consistency
• Can use it without conventions, can configure if you want to
• Uses metadata in database to infer datatypes of columns and creates methods for itself, on the fly, named after the columns

In  glue scenario, it could be taking logs and putting them into a database.

ActiveRecord also has good validation and clean way to define relationships between tables.

• i.e. migrating data from old database to new schema

• setup ActiveRecord for both databases, read them in as one, interact with them as objects and the validation is there to help you avoid problems.

Application Development

Digression: Get Enterprise Integration Patterns book.

Digression: SOA requires well-defined boundaries down to the DB level, app databases, not integrated databases

Digression: “Starbucks does not do a two-phase commit.”  — Find the article with this quote

The digression about SOA (some notes are marked above) is very interesting.  Check out the slides.

And, we’re back from the digression…

• ActiveMessaging
• RESTful Rails

ActiveMessaging

• Rails, Java, and JMS
• JMS as middleware (see slide)

• messaging queue that uses STOMP
• Don’t have to convert all the legacy code
• Model goes to database or JMS in MVC pattern

REST

• Standardizing CRUD in Rails
• Extensible presentation formats
• Allows you to harness logic
• App treated as a service

Standard actions

• index
• create
• update
• delete
• destroy
• show
• new

Can create your own types!

Summary – Ways to Get Ruby into the Enterprise

• As a Developer’s Helper
• As Enterprise Glue
• For Application Development

This session was great.  I’m excited to start using Ruby and especially ActiveRecord and ActiveMessaging at work.

Fin.