Claudio Lassala in Software Development

In case you haven't heard of it, check out information about Houston Alt.NET Geek Dinner #3. Topics we're likely to be babbling about are:

• Code Clarity / Fluent Interfaces / Code without comments
• Model View Presenter pattern
• Continuous Integration

If you feel like eating pizza and talking with other geeks, make sure to join us there.

Back from my visit to Brazil, and ready to start blogging again.  :)

During this last trip I've read the following book:

C# in Depth: What you need to master C# 2 and 3 by Jon Skeet Read more about this title...

I decided to read it because of JP's review. After reading a few pages, I knew I had to read the book cover to cover, and that's what I did. The book covers briefly some key aspects of C#, important things introduced in v2.0 (such as Generics, anonymous delegates, etc.), and then the new features in v. 3.0.

For me, the book was a great refresher for things I already knew, as well as it gave me a lot of insight on things I certainly didn't know (such as a more thorough understanding of expression trees, lambda expressions, etc.). I'll definitely have to go back to a few chapters in order to fully grasp some of the things presented there.

I believe this is a must-read book for any C# developer.

I'll be speaking at the Houston .NET User Group on August 14. This is the abstract:

Refactoring, Patterns, new language features, code quality, and more!

Command design pattern, Lambda Expressions, Extension Methods, fluent interfaces, refactoring, test-driven development, writing elegant code, and more. This session will cover a little bit of many things learned from projects I’ve been working on. We expect every attendee to learn a few tricks that can be applied immediately, and also to feel encouraged to go out and research more on whatever area appeals the most. Besides learning those things, we really hope attendees will start thinking and approaching their code in a different way.

I like this talk a lot, and got some pretty good feedback from people who have seen it before, so I'm certainly looking forward to it. See you there!

P.S.: Now back to my "vacation" in Brazil.  :)

I think the presentation last night went pretty well, and I get some great feedback from the attendees, so that's always good.  :)

We’ve covered a LOT of ground:

Refactoring, separation of concerns, test-driven development, Command design pattern, Action delegate, multi-threading, lambda expressions, fluent interfaces, object mappers, extension methods… Of couse, everything in small doses, just trying to raise awareness about those things.

It all started with a simple WinForm app, going through the cycle of adding code to Click events on buttons, and then refactoring things out of the UI, extending it to support keyboard binding, designing a shortcut controller in a test-first style, doing more refactoring and using the Action delegate and refactoring the code to the Command pattern, then improving things a bit so to support asynchronous commands… then I’ve quickly covered object mappers and lambda expressions, and finally how to improve test code using extension methods and fluent interfaces.

The source code can be downloaded here.

Some people asked me how they can learn more about this stuff, and where to go find resources about it. Here are a few links to some of my previous blog entries that may help:

Good Resources on Test-Driven Development (TDD)

Learning in spiral

The whole testing thing...

Test-Driven.NET: a great little tool

Next week I'll be speaking at the Hal-PC C# SIG in Houston. This is something that came up last minute. Markus was booked to present there but won't be able to, so I was asked to fill in for him.

The session is going to be a "C# Tips and Tricks", where I'll be covering a bunch of things. The abstract is:

Claudio will cover a number of tips and techniques he has used in recent project work, including the command design pattern, Lambda expressions, extension methods, fluent interfaces, refactoring, and more. His objective is to present a few tricks that attendees can apply immediately and to inspire them to learn more about the other, more extensive topics covered.

Hope to see some of you out there!  :)

I've just spent about 30 minutes checking out the recently announced Microsoft Source Analysis for C#. I definitely love the idea, but I'm not sure I'll be using it just yet. Here are some of my impressions (again, I haven't spent a lot of time on it yet)...

All using directives must be placed inside of the namespace

Hmm, but VS itself violates that rule on every class we create...!

The property must not be placed on a single line. The opening and closing curly brackets must each be placed on their own line

Huh? But that an auto-implemented property. What would we want to split that into multiple lines?!

Variable names must not start with 'm_'

Hmpf, that's the standard with have here at the company...

A closing curly bracket must not be preceded by a blank line

Ok, this one I like.

Tabs are not allowed. Use spaces instead

Huh? Thanks, but no, thanks. I've seen a lot of people complaining online about this one too. What's the problem with using tabs??

The call ... must begin with 'this.'...

Ah, I like that one. This is something we've made as part of our guideline here, but couldn't use FxCop to trap for that, since the 'this.' doesn't make into the IL.

Now, the problem here is that, again, the code that VS generates violates this rule all over the place, such as on the example below:

I'll continue to use this tool to see if it's going to stick with me. I've tried it on a very small project, and got 246 violations; the vast majority where produced by code generated by VS. On a big project, I'd probably end up with a LOT more violations, so I'm not sure I can live with that. I believe there is a way to disable some of the rules, but haven't looked for it just yet...

Anyway, I do appreciate Microsoft releasing tools like this one. Hopefully, more and more developers will start paying more attention to how they write code.

As an MVP, I got offered a license to InnerWorkings training material. I've been checking out some of it, and it looks pretty interesting.

I noticed they had some material on Domain-Driven Design Patterns, Enterprise Patterns, and some related topics that I'm always interested on, so I decided to try it out.

There is a "Developer Interface" app, where we keep all the material purchased. Each course has a number of tasks, and each task presents the scenario to be solved, the challenges, and reference material (with links to chapter of great books such as Eric Evan's on Domain-Driven Design).

The task provides a way to launch the sample project in Visual Studio. Once in VS, we get an "InnerWorkings" Tool Window that gives us quick access to the problems we need to address in the solution, and the useful links.

You can either try to address the problems by yourself, or cheat and see the solution. Once you're done with it, you may click the 'Judge Project Code" button that gets added to VS to have your code analyzed to see if you've implemented things in the way that was expected.   

I'll certainly be checking out some of the other courses they have available (I need to catch up with some stuff such as WCF, WPF, Silverlight, LINQ to XML, etc.).