Devteach 2007

Devteach - TDD Workshop

Scott Muc — Mon, 21 May 2007 00:32:44 GMT

The workshop presenters were Scott Bellware and Jean-Paul Boodhoo. Both developers that I highly respect. There were also some amazing developers in attendance like Roy Osherove, Oren Enei, and Udi Dahan. I was hoping that the workshop didn't go over my head but I was happy to see that they introduced the concepts at an easy to follow pace.

Jean-Paul said that people who understand TDD usually have an "ah ha!" moment. I think I had that moment during Scott's session on Domain Driven Design. Everytime I saw TDD I just saw it as a bunch of tests that validate the business logic of the code. I did not grasp that it's a design practice not just validation testing. Understand this I suddenly became very self-conscious about the code I've written. It's not easy to test which is usually a sign of bad code. As a programmer you really need to check your ego out the door. I've still got code from years ago that I would cringe if I had to work with it today. I'm sure I'll cringe when I see the code that I write now five years in the future.

The most enjoyable part of the workshop and the conference as a whole was listening in on the conversations of the other developers. I was really happy to hear that their throught processes are similar to mine. I always feel that these developer blogs that I read make things sound so easy. Well, their posts are usually done after a lot of thought and discussion. It made me quite comfortable to see developers argue the merits of the method names they've chosen. Jean-Paul and Scott were doing pair programming in the workshop and even they disagreed on many coding schemes each other preferred. I'm glad to know I'm not the only one who loves to pick the perfect method names for their classes.

Without any fulltime developers at Radio 3 it's hard to see how my code measures up to other developers. My experience at this conference really helped me realize that I'm heading in the right direction with my coding practices, but it has also pointed out some areas where I need a lot of improvement which is exactly what I wanted to get out the conference. At first I thought I was dissapointed in the sessions because I was quite familiar with the material, but the conference is called Devteach for a reason. The insites from other developers on these subjects is where the value is and I definitely am not dissapointed from that perspective.

Devteach 2007 - Day 3

Scott Muc — Thu, 17 May 2007 16:57:47 GMT

The Ajax Revolution with Derek Hatchard

I was hoping to hear about some more advanced talk about the trials and tribulations of using Ajax in this session but it turned out to be a basic demo of the simple AjaxToolkit controls and some Script.aculo.us effects. Nothing was new to me so there's not much to talk about. If you've seen the AjaxControlToolkit demo page and the Script.aculo.us demos then you've seen it all.

Security Through Partial Trust with Don Kiely

Security is always an issue with web development and I always like to keep it in mind when developing. Partial trust is a layer of security that runs on top of managed code. Security in .Net involved Code Groups, Security Policies, and Trust Levels.

The default trust level for an application domain can be edited in the securityPolicy element in the machine.config. The trust element can be changed and will then follow the policies dictated in the policy config files. Primary benefit of medium trust is that it does not trust unmanaged code and also sandboxes the file IO to the Application Directory.

The permission sets are determined by the code group that is discovered via the evidence exposed by the assembly. Assemblies that get loaded must match a Code Group for the trust level.

Adjusting the trust level involved editing the web site web.config and changing the trustLevel element. This would be cool to add to our website but we deal with so many different directories that it would take a long time to change the security and get the website working again.

The permission files are simply serialized forms of the Permission object. This means you can write apps to create PermissionSets which gives you Intellisense if using an IDE. Get the resulting XML and add that to the policy file.

This stuff is freaking cool, but I can see why it hasn't gone mainstream. There's a lot of complicated setup and configuration involved that isn't obvious unless you really know what you're doing.

I managed to win a book which was nice as well!

Power ASP.NET Debugging with Don Kiely

The debugging features of VS are more impressive than I was expecting. I've used debugging when writing applications in school, but never realized that powerful debugging would be at such a level for web applications. Unfortunately it does mean switching my dev environment to VS, but I'll do some research to see if Sharp Develop can perform similar debug actions.

Introduction to MS Build with Claudio Lassala

I'm a big fan of NAnt and I heard MSBuild was similar so I thought this session would be interesting to see if there are any differences that would compel me to switch. At then end of the session I got the impression that MSBuild was almost exactly like NAnt except with some keywords changed around. I think I'll stick with NAnt as it works well in the Mono community. If two tools do something exactly the same and implement it just as well, the next thing I always use to measure the usefulness of the application is its portability. I probably should have asked about Mono and MSBuild support but I was getting groggy and I'm in no hurry to switch from a build framework that works great.

Devteach 2007 - Day 2

Scott Muc — Wed, 16 May 2007 13:40:43 GMT

Tips & Tricks to Boost Up Productivity with Claudio Lassala

The first set of sessions of the day didn't really interest me greatly. I enjoyed Camillo's style of presenting yesterday so I figured I would check out the session on productivity.

The first half covered many things that I already know and use. Using the quicklaunch bar, keyboard shortcuts, slickrun, sysinternal apps, folder organization were concepts/apps that I already follow/run.

There were a couple nuggets that I had never known though. One is great for capturing the text of a dialog box. So many times you see a cryptic error message and you want to copy the text and send it to someone. The text can't be highlighted, but you can still just hit CTRL+C when the dialog is active and the text in the dialog will go into the clipboard. Secondly, if you want to do a batch rename of files in a directory (common with images off of a camera) you can do a CTRL+A in Windows Explorer then hit F2. When you rename the first file, all files in the directory will be renamed with a counter appended to the name.

Behaviour Driven Design with Scott Bellware

Scott began the presentation emphasizing that Unit tests are documentation, and TDD is design. The rest of the session was spent explaining these points.

Keeping in mind that tests are documentation is something that must be thought about when writing tests. It was cool to see Scott go through some test code and clean it up so that its purpose was clear and concise. It was funny to see massive method names for the tests but it made sense. Instead of a test like GetOrderTotalTest it turned into A_10_Percent_Discount_Should_Be_Applied_To_All_Orders_Over_100_Dollars_Where_The_Customer_Has_Purchased_1000_Dollars_Of_Orders_In_The_Past. Who cares how long the method is since it's a test method not part of some API. It clearly states the business rule and the test will determine if the rule is being followed.

Another interesting point of about the testing approach is that it forces good code development. In order to make code testable it has to be loosely coupled from the data access code in order to be mocked and tested. With these ideas a little clearer I am looking forward to attempt some of these patterns.

Interaction based testing With Rhino Mocks with Oren Eini

This session went a little over my head. I've played with Rhino Mocks a bit a home but that was with the most trivial of examples. Oren is the author of Rhino Mocks so perhaps his pace was a bit fast because he knows it inside and out. Or it could have been that watching someone develop with Resharper was like watching a robot. The dude was that fast at using it.

Unfortunately I didn't get as much from this session as I would have hoped but that was because of my own limited knowledge in the area. The advantages of testing using mocks are the following: Dependency Injection, Inversion of Control, Programming to Interfaces, Separation of Concerns. The first two concepts are relatively new to me, but the second pair are things that I've been attempting to do but now have a better method of trying to design with those concepts in mind.

Table and Index Partitioning with Rick Heiges

Not really as practical as I had hoped for applications I work on but was interesting nevertheless. The session covered partitioning the data of a table for easy archive and potential speed optimizations. The discussion was more geared towards large databases so the tips didn't really pertain to Radio 3... unless we start adding billions of bands to our database.

Rapid development using Monorail with Oren Eini

I *heart* Monorail. The more I see Monorail in action and the more I play with it the more it seems like it's too good to be true. I'm ready to dump the page life cycle of webforms. Oren's first example of showing what was wrong with the whole Page_Load() event was something that I've sort of been questioning as well. Too much code goes there with too many different concerns.

Devteach 2007 - Day 1

Scott Muc — Tue, 15 May 2007 23:57:15 GMT

The Devteach conference has started, During breakfast I was seeing all the legends of the .Net world. It was pretty cool to be hanging out with the likes of Roy Osherove, Jeremy Miller, Jean-Paul Boodhoo, Scott Bellware, Oren Eini, Adam Machanic, Carl Franklin, Markus Egger, and Miguel Castro! Anyways, here's a synopsis of day number 1.

Agile Development with Ray Osherove

I was really excited to see the Agile development track in the conference. Roy came in the room wearing a shirt that said "Geek" on the front and began the session by playing his guitar and singing the countdown to the start of the conference.

This session was a Q&A period with Roy about Agile development. Even the session was done in an Agile fashion. People spoke out questions and then the group as a whole determine the priority of the questions. The top question was about Agile Estimation practices. Just like regular software estimation the Agile way is just as tough. Instead of looking at the long term, Agile tries to estimate the length of development for single tasks and make sure those estimates are as accurate as possible. We're talking about something that will span a weeks time. The other interesting comment was how estimation should be done by everyone on the team. If I say something will take 2 days, Rahim will say it will take me 6 days, and Nicole will say it will take me 4 days. The Agile way will have us discuss our rationale and adjust our estimations until there is some sort of consensus.

There was also a shorter discussion on distributed teams. The major thing I got from that is that anyone in remote locations should be using some sort of source control. The session discussed Continuous Integration, but that may be too much for the few developers we have.

Lastly the topic on getting managers to adopt agile techniques was discussed. The main point was that in order to these techniques adopted you have to have some sort of expert as a mentor or trainer first. The ultimate goal of Agile development is higher quality code. Agile might not be as fast at first to develop under, but in the long run you gain productivity due to the quality of your code. The less time fixing bugs means more time implementing new features.

Rules for Agile Design with Jeremy Miller

The session started off with some points that I really liked. Embrace change and write code that can change. Easier said than done! The session was a good reminder of the many faults in my programming. The biggest problem is not following the "Good enough design" rule. There are times where my implementation is good enough and I should move on to the next task, but part of me always wants to make my code perfect.

A couple themes that run through Agile practices are doing small tasks one at a time. No multi-tasking which goes into the next theme which is to minimize wasted motion, meaning that the focus is on the documented task and not dilly-dallying too long on extraneous programming efforts.

In order to make Agile programming work, you need to work vertically. This is one thing that I think I do already. This means that you write your DAL, BLL and UI at the same time. The more your UI uses the BLL and the BLL uses the DAL you will see deficiencies in each layer easier than if you write the entire DAL all in one go.

RSS, Podcasting and Syndication with Carl Franklin

I had high hopes for this session but my experience with the CBC Radio 3 podcast went over and above was was discussed in this session. It was disappointing to see the code samples used a search and replace template in an ASPX page. Our RSS is outputted with an XmlTextWriter in order to guarantee correctly encoded output and and uses an HttpHandler (for website RSS) since there's no reason to load up the entire System.Web.Page class to output some XML.

One thing that I did learn in the session was that Windows Vista has what is called a Common Feeds List. This allows Windows applications to share feed data between each other. Carl also talks about a web service call Feed Burner which was really interesting because it is a full featured feed publisher. It makes sure feeds are valid before going public and has stat tracking features and a stylesheet for the feed.

Designing Highly Concurrent SQL Database Applications with Adam Machanic

This was another session where nothing was really new. Adam went over the common concurrency control solutions that I learned at school. What was interesting about the session was the he implemented pessimistic, optimistic, and multi-version concurrency control in the data model. He also demoed an application call the SQL Stress Test which might be a tool that we could use to test load issues with certain queries!

New Features in C# 3.0 with Claudio Lassala

The last session of the day wasn't anything new but it's always good to hear material in spoken form rather than reading blogs and articles. Claudio put on a great presentation the highlighted all the aspects of C# 3.0 that were used to enable LINQ. These features are: Automatic properties, Type Inference, Extension methods, Lambda Expressions, Expression Trees, Object Initializers, Anonymous Types. Near the end he explained how in a 4 line LINQ expression it utilized 4 of these new features! I thought that was a pretty cool way to summarize the session. Claudio also had a great sense of humour which is best represented by this slide.