Last week I was privileged enough to attend the Tulsa TechFest. This was a great event with a wide range of technical topics and speakers. It was organized by volunteers and the $2.00/day entry fee went to a charity to fight hunger. How much better can it get?
I met up with several developers, including Michael Paladino, and shared some good stories and discussions. The keynotes were pretty good but one in particular stood out from the rest (see the bottom of this post for more details). I also made it a point to stop by each of the vendors at their booths and thank them for sponsoring the event because they all donated a lot of time, personnel, and money to make the event possible. The sponsors also donated tons of prizes like HD TVs, laptops, software, books, and more. But the best part of the conference, for me, was the series of break-out sessions. There was a lot of variety and it was hard to choose which ones to attend, but here's a break-down of what I saw. Hopefully several of the speakers will post some of their notes and examples on the TechFest web site.
Better Application Design with Practical Loose Coupling
Caleb Jenkins gave a high-energy talk about design patterns and specifically about broadening your development practices by creating re-usable, more generic class structures. His example started with a knight using a sword to slay a dragon (sounds a little corny, I know, but the example fit well and the way he presented it really made you pay attention and get into the topic). The problem, as he points out, with such a specific mindset is that you don't have the built-in capability of re-use or changing things around. Instead, ideally you would design your system to utilize a hero who uses a weapon to complete a quest. Then he demonstrated how to break these pieces into various classes such that the quest doesn't care what the weapon is or who the hero is and vice versa so that you could change the hero to be an elf or the weapon to be a crossbow or the quest to be saving a damsel in distress (referred to as dependency injection). You get the idea. I'm looking forward to reviewing his code examples again to see how I could better implement the practices he discussed.
WinForms User Controls
Les Pinter, the original developer of what has now become Microsoft Word, spoke on the basics of inheriting from the standard toolset provided in Visual Studio and creating user controls to group re-usable pieces such as a login screen. Interestingly enough, I found his many side-topics to be much more interesting than his core presentation. He spoke about his history with Bill Gates, his love/hate relationship with Microsoft, the current economy, and various other topics. But as for his core discussion, our company had already implemented some of the same techniques that he touted and we have reverted back to using out-of-the-box controls in a lot of cases because of some significant issues we experienced with our deployment methods and application code bloat weighed against the benefits of being able to change the font in one place. We ran out of time before I could ask him any one-on-one discussion questions but I plan to follow-up through email.
Intro to C# 3.0
Tim Rayburn went through an all-code discussion of the various new things available in the 3.0 framework for C#. Although I'm a VB developer, I found it very informative and it even helped me get a better grasp on the syntax differences and see what you can do in C# specifically. Extension methods (which are also available in VB) are a very handy way of adding methods, properties, etc. to common objects such as the String object. Populating a class can be a lot easier with a single line of code. The "var" definer has been introduced, which is still a strongly-typed object but is used when you are hydrating the object on the same line of code, so you can say var myString = someObject.MethodThatReturnsAString() instead of having to type string myString = .... This is particularly handy if you have long class names but is specific to C#. Ambiguous types are also very handy, particularly in conjunction with LINQ. You can return a strongly-typed object (generated at compile time) without ever specifically defining the type, only defining what it will contain. This is another session that I look forward to reviewing the notes and code examples of.
Becoming a .NET Jedi with Resharper
Ben Scheirman gave an all-code discussion of using some of the great features available in the third-party Visual Studio add-in tool, Resharper. He admits that he spent a fair amount of time getting used to the commands and training himself to use it, but he can really fly through the code and refactor and reorganize it really well. Although Resharper is a lot more beneficial to C#, since VB has a lot of those tools built-in, I think there is a fair amount that can be leveraged in VB. I took more notes in this class than I did in all the others combined, by far.
Being able to type the name of a new class and then have Resharper generate the code to define the class (and the same for properties and methods) would be a HUGE time-saver. Resharper also gives you shortcuts to adding new files and various other tasks that would typically require loading a Visual Studio dialog (which can tax the system and takes extra time for the developer to sit and wait, then choose what they want, when typically you have a subset that you deal with, and have to sift through a long list of things you don't ever use). Its main benefit is probably the ability to analyze code and help you modularize it and refactor it. I love the tool, and after several sessions with C# examples I'm digging the language more and more.
Ben admits that you will probably need a decent amount of memory to run Resharper without it slowing down Visual Studio but I could see how it would be worth it. Ben also uses all keyboard commands, which can be very quick once you know them, but I would probably start out with some of the menu options just to help explore what is available in the tool.
Getting Started with LINQ
Rob Vettor gave a code-and-concept discussion on LINQ, the new data source interface tool (for lack of the correct term) in the 3.0 framework. LINQ is similar to SQL but with IntelliSense, namespaces, and compile-time error checking (hallelujah!). It integrates best with SQL Server but also works with other databases and my favorite part is that it works with XML and with IEnumerable objects. The latter is where I could see the most benefit in my daily development. You can query your own objects, pull out aggregates, perform subselects, and a whole bunch of other cool stuff. Although I'm not a big fan (at least not yet) of removing your hard-coded SQL queries and using LINQ entirely, largely because of portability for checking and modifying those queries outside of Visual Studio, the XML and IEnumerable object support is a huge plus.
Bulletproof Web Design
Mark Watson gave a code-and-concept discussion on how to develop web sites to tailor to a user's needs and preferences without distorting your design. He talked about using variable font sizes, utilizing CSS as much as possible, using fluid layouts, and more. I was already familiar with a lot of the topics he mentioned but it was great to see how others implemented it. His discussion was based largely on a book called Bulletproof Web Design, written by Dan Cedarholm. It looks like a great book (and full-color, so that always helps) and I hope that Mark posts some of his examples. I had a few follow-up questions for Mark as well but I will probably just read the book and then contact Mark or Dan afterward.
Closing Keynote: Improving
Jef Newsom gave what I felt was the best keynote of the event. Not only was it lively and fun (he impersonated Sean Connery and Matthew McConneghy (spelling?) and had simple, trendy slides with good stock photography and clean, easy-to-understand graphics/charts to keep up interest) but it was a great speech on project management and development practices that can help make you more agile. He talked about the importance of working on one project at a time and making sure you get the information you need in a timely fashion so you don't get strung out for days, weeks or even months trying to get a deliverable product out.
In practice at his company, every employee has the ability to "stop the line" (taken from Toyota's practices) and halt development on the project if something isn't going correctly or if they don't have what they need so that it prioritizes getting information to the developers and developing things correctly the first time. If your users know you aren't doing any work on any other projects and have to have some piece of information from them before you can continue on the current one, they are a lot more likely to get things together in a timely manner (same for project managers and other developers).
He had a particularly interesting chart depicting two ways of developing three projects: one working on them incrementally but all at once, and other working on them one at a time. Working on them incrementally will get all three done closer together but in a longer timeframe than it would take to get the first two done, when you could have been allowing your customer to utilize the first two projects while you are developing the third and could be getting helpful feedback from them for your fourth project (which may be revamping project #1 or #2). Obviously this is a blue sky example and things don't always work that way, as he admits, but it's a solid concept.
He also discussed iterative development and a "pull" methodology rather than a "push" methodology for development, where you concentrate on the end result and develop what you need in small increments to get small results that eventually add up to the full requirements of the project but give you the ability to have positive feedback (and by positive he is referring to feedback that is helpful in your next iteration of work, not necessarily happy-go-lucky yay we love our product feedback). He talked a lot about user stories and how they can be beneficial when determining the scope of the project iterations and focusing on the goal rather than how to get the user to the goal. He talks about, and I've seen it myself as well as many others, how too often software is developed with the "what" in mind rather than the "why" and ultimately you get software that will do "what" the user wants but is difficult to reach the user's ultimate goal.
Thoughts
While we may not be able to, at least not easily, implement in our environments all of what the various speakers discussed, it was great to hear what others are doing and what concepts are thought of as good practices these days. And it certainly gives us some insight and challenges us to try to evolve with our development practices, not to mention all of the cool new techniques and third-party tools that are available for us to utilize.
This was a great event and I was really glad I was able to attend. I really hope to go back next year and encourage anyone who is in IT to take a look at it.