Overall, it was awesome.  Really. Awesome.  What blew me away was that the groups this year were laser-focused; they had their idea and they executed.  I felt a little guilty that our Roll Play team was so blitheringly good.  It seemed unfair.  With almost the entire RocketFuel team on our side, the majority of people had mind-melded before we even started.  Add to that some of the best business development people I have met and what a mix.  In 2 days, we really had a company and a product — www.therollplay.com.  The coordination was impressive, our fearless leader kept tabs on everything so that we were all informed without having to constantly ask the status of other people’s stuff.  Even had a promo video, which was oddly fitting to the product.  The team is continuing, and the pace has slowed; we all have real jobs, after all.  But, it didn’t die. It’s moving on and seems to have found a niche.

As always, I learned a lot from everyone there — new technologies, concepts, techniques, etc.  And, just like last year, no one had to think about all the basics; LaunchMemphis really does a great job of just taking care of so many things that participants just do what they are there to do — food magically shows up, Red Bull magically appears when needed, coffee ready for the gulping.

Can’t wait til the next one, but I have to say, this one’s gonna be tough to beat.

If you want to do this right now, get ready to be sliced on the cutting edge.  For example, it can be done using SproutCore, Ruby on Rails, and Google Gears, but whew — it’s hard.  All of these are evolving, so keeping up with rapid change in all three can be very exhausting.  And there are very few resources in terms of best practices for security, etc.

To focus on the UI aspect for a bit, the two frameworks that I find really exciting right now are SproutCore and ExtJS.  Both of these offer tremendous layout managers and excellent data management.  Unfortunately, I find both to be very hard to develop in, especially ExtJS.  So far SproutCore has been more manageable, but that may just be a personal preference.  The downside is that it is really, really young; no way is a core business application going to be accepted yet.  And what is still frustrating is that none of these provides anything close to the developer experience of, say, WinForm development in Visual Studio.  And the IDE’s have simply not kept up with these technologies.  In order for people to start building real application-like web experiences, there will have to be IDEs that provide the WYSIWIG functionality you really need (imo) for form-based application development.

But, keep your eyes on SproutCore — I’ve only recently learned of it (a nice side-benefit of participating in Startup Weekend), but me likey.

Now, what makes this really cool is that I can namespace my views.  So I have

com.mysite.views = { }; // in javascripts/views.js

com.mysite.views.users = { }; // in javascripts/views/users.js

com.mysite.views.users.add_user = { }; // in javascripts/views/users/add_user.js

And in my add_user view, I can store values in the js object or have methods that I know will be defined.  In other words, I get the same scoping that I would if I were calling views in namespaces in RoR, allowing for very straightforward refactoring of my javascript.

Each js file only contains what is needed for that view or for views in the same package; common functionality is in the overall views.js file, which is always included (from the app layout).

So, temporary storage, smaller js files, unpolluted global namespace, better organized js files.  That’s a lot to get out of a rather simple plugin.

(Before anyone posts that this won’t work if the user has JS disabled, no it won’t, but in the site I am working on, having JS enabled is a requirement to even logging in.)

And, I was proud.  The reason was not that we met some social expectation of diversity, but that we are able to bring a totally  unique perspective to startups that most cities cannot.  When you bring together such a diverse crowd, you will get diverse opinions.  When these different backgrounds are brought to bear on new web applications or social networking strategies, they will be very, very different from a group of young all white male coders.  And, I can’t wait to see where it leads.  One thing I know for sure is that it won’t look like the gatherings that take place in DC, the Valley, or Austin.

AIR isn’t perfect, but there are some aspects that it addresses that are enthralling:

1. It runs on WebKit, so I don’t have to test on 5 browsers and 3 platforms (not entirely true, depending on how you deal with menus and filesystems in AIR, but basically accurate).

2. It can run connected or disconnected.  Perfect if you are facing a project that has a need for both online and offline functionality, as I currently do.

3. It has excellent support for javascript libraries like Yahoo YUI and JQuery.

4. If planned well, one can re-use much of the development in a web version of an application (not exactly, write once, run anywhere, but closer than any alternative I’ve seen).

5. Access to local file system and SQLite database.  Try that in your web app.

Of course, the downside is that an AIR app gets installed.  This is an obvious requirement for such an application, but it is a downside relative to running a Flash swf, since corporations would have to allow admin priveleges.

So, if you haven’t given it a fair shake, I’d strongly suggest you do.  One could easily argue that it is also the worst of two worlds–it requires an installation like a WinForm app and it is not quite as easy to ensure everyone has the right version as it is with a Web app.  However, if you are facing an offline/online requirement, you are not doing yourself a favor by ignoring the potential of this framework.

But, what I realized today is that it kinda makes me think differently.  My browser is nothing but an environment to use applications that have data on the web.  Well, maybe even that is too strict–it is an environment to run applications.  Period.  For some reason, I’ve never thought of my trusty old Firefox that way.  Hmmm…  One of the areas that I have been doing a fair amount of research on is disconnected clients.  Silverlight and Air have been the two I’ve been spending the most time with, but the ability to house them in the browser and let Chrome create the shortcut creates some nice UI aspects.  Maybe it isn’t a web browser but an application host.  (Not that Firefox and, God forbid, IE aren’t, but they just don’t lend themselves to thinking that way as much.)  I guess the big question is what is the adoption going to look like.  If its big, then it really opens some doors in the corporate market to distribute apps that can really have the screen real estate they need (and deserve).

But one of the most ironic things was that I remember back in 2000 when I worked for a company that built a browser-based ActiveX control that used SOAP for the communication with the COM+ server using ISAPI on IIS.  Now, that was bleeding edge.   And the funny thing is that people wanted web sites to look like applications.  Somehow, this is now a negative in almost all cases — people want the thing in the browser to look like it is supposed to be in the browser.  Ok, so I can have context menus using this framework.  That’s awesome, but users don’t expect them.  How many times have you accidentally right-clicked in Google app and gone ‘wait–that’s not the normal context menu.  nice!’ only to wonder how many users ever bothered to right click?

Well, I guess I’ll keep watching from the sidelines until the right application comes along (and the framework matures).

P.S. VWG guys — if you happen to read this, please clarify what the licensing model is.  Incredibly confusing right now, and no one wants to get excited about something if they can’t figure out if it is free or has a cost per server.  I don’t bother going to the Ferrari dealer, because I know I’ll just want something I can’t have.

Testing the UI

In my web.config, I’ve got connections for Dev and Test.  In my Unit tests, I’ve got an app.config pointing to a local test database (I’ll add a demo database later). Following the rails model, there are methods for creating an entity — things like “TheJonesFamily” that are static and return an entity.  These get used throughout all the tests.  I categorize my tests as follows:

• Model tests – building blocks for testing models and combinations of models (ModelTest)
• Direct insertion of data and verification of data in the database (DirectDataTest)
• Controller tests for create actions (UICreateTest)
• Controller tests for view (show) actions (UIViewTest)
• Demo tests – these are the tests that are used in building the demo data (DemoTest)

I’m using Migrator.net, so I’ve got separate proj files for dev and test.  One of the nice things is that in some of my tests, I’ve got TearDowns that reset the database, essentially migrate down then back (also a nice double-check that the migrations are in good shape both up and down the chain).  But I can keep whatever data is lying around in my dev db without any impacts.  This also lets me run MSBuild (to move to NAnt later) to update my demo site by running the tests with that category.  So, in one step, I update the system, test it, and load demo data.  Much happy.  Obviously, things are a little more complex for production, but that’ll be another post.

At the end of the day, I’m on my way to a very usable infrastructure for development — the cycle is this (so far):

• Create migrations
• Run the PLINQO Codesmith Templates (with some modifications I’ve made) to generate the DBML, update the generated entities, and update the managers
• Update unit test entities (essentially stubs that can be saved to the database — mocks will get used later for external services, etc.)
• Update unit tests for the models, controllers, and views
• Update logic in the models, controllers, and views
• Test

It ain’t perfect, but it’s a heckuva lot better than what I would have done if I hadn’t met Rails.

I’m a big believer in model driven development.  I think developers should spend their time on the logic and the value add, not the rote mechanisation of creating classes and mapping them to tables and creating sql scripts.  Unfortunately, I can’t say that Microsoft is there yet.  Progressing, to be sure, but simply not there.  Everything gets you only halfway, and then it is all set up to regenerate on top of itself, so you can’t really even hand modify the code.  I’m trying to build a framework for a team-based development project, and I wanted to evaluate using newer MS technologies for this project.  But, I gotta say that I call treuce.  I’m going to give up on single table inheritance (wah) and go back to the PLINQO approach.  Frankly, giving up on these really sucks, because I was excited about where things are going with both LINQ to SQL and LINQ to Entities, but it just isn’t primetime.

If anyone out there has used these technologies in a real world application, please let me know–I always want to know if I am just doing it wrong, but I can’t see how either of these technologies can work out of the box.  And last, but not least, the whole reason for this trek was to make my life easier, not to spend 3 fruitless days playing with crap (ok, promising crap, but crap nonetheless) that doesn’t work in the real world.

class Relationship
{
public ICollection<RelationshipNote> Notes {get; set; }
}

class RelationshipNote : Note
{
public Relationship Relationship {get; set;}
}

class Note { }

I want to be able to traverse from both ends of the relationship.  In LINQ to SQL, you apparently cannot have this setup.  To be perfectly honest, I’m not clear where in the model it breaks down.  All I know is that it doesn’t work, and it took me 8 different tries and about 10 hours to figure out that the only way you could do this type of setup is if you maintain the RelationshipNote in its own table and use it as a type directly.  And if anyone has an answer about a way to make it work, please do post a comment.  Clearly, I don’t want to have to add a new table whenever I want to associate a note to a new object, so this wasn’t going to cut it.  Maybe I’m crazy, but this doesn’t seem like such a complex or far-out approach to modeling the database or the classes–why it isn’t supported is beyond me.

However, I am using Migrator.Net to create the tables, and so it should be relatively painless to run the migration locally, update the entity data model, update the tests and go.  This is still on the right track, but I didn’t enjoy the detour very much.

And now on to LINQ to Entities.  I’m just now installing VS2008 SP1, so I expect that my next post on this journey will be on whether it does what it supposedly does in the context of my real-world project.