I've been trying to put together a link list of things that have helped me improve as a developer over the last couple of years. This is far from complete, but it's a start. I'm not saying this is an absolute "you have to know these things" list or that it will work for everyone out there, it's just things I've found to be really helpful for me. As always, your mileage may vary.
- SOLID Principles - These principles have helped me a ton. They aren't rules to be followed blindly, but I've found that understanding the reasoning behind them and trying to strive for code that adheres to them generally makes things easier (and also more fun) in the long run. Now when I’m faced with a design choice, I usually ask myself which alternative is more SOLID and go with that. Be sure to check out the SOLID “motivational” posters over at Derick Baily’s blog.
- Design Patterns – Certain types of problems tend to recur in software development. For these, we have design patterns. Getting a handle on design patterns is something that only comes with practice. You won’t be able to memorize and recognize even the “core” set of patterns immediately, but over time you will likely find yourself recognizing when to apply them more and more often. I strongly recommend Head First Design Patterns (yes, the code samples are in Java, but the patterns themselves are what’s important, and a C# dev should have no problem following along). It provides a very good introduction to design patterns.
- Test Driven Development – I think a lot of new developers hear “testing” and immediately glaze over, but I actually enjoy practicing TDD. It doesn’t just help me test my code, it helps me design my code. That’s a big advantage that a lot of people overlook. It also gives me confidence that the class I’m creating does exactly what it is supposed to do, and nothing more. If you aren’t sure how to do TDD, you can watch one of the various TDD Katas online, such as the String Calculator at Roy Osherove’s site or the Bowling Game at ‘Uncle’ Bob’s site.
- Resharper 5 - Resharper is essential for doing C# development in my opinion. Out of the box, it will suggest lots of little things that can help improve your code. It helped me learn LINQ by offering to convert ugly for/foreach loops into clean, elegant LINQ expressions, and it finally convinced me that ‘var’ isn’t always evil.
- NHibernate and FluentNHibernate - I prefer NHibernate to Castle ActiveRecord these days; the ActiveRecord pattern isn't as flexible or as extensible as an implementation of the repository pattern based on NHibernate, and I’ve run face first into that wall on more than one occasion. FluentNHibernate makes it a lot easier to get up and running with NHibernate since it hides the XML and provides other nice helpers to get you started.
- Lambda expressions - These are essential when working with C# 3.0 or later. They're a bit hard to grasp at first, but they open up very interesting re-use possibilities, and lots of APIs leverage them heavily. FluentNHibernate uses them to setup mappings, and StructureMap uses them for its embedded Domain-Specific Language (DSL).
- Generics - This is an older C# feature, but understanding generics is still just as essential today as ever. Beyond leveraging the built-in generic classes from the base-class library, learning to wield generics also opens up new avenues for creating clean, extensible, and reusable classes.
- StructureMap (including its AutoMocking container) - One of the biggest "lightbulb" moments I've had recently was adopting StructureMap and IoC-everywhere. This totally changed how I code. Now when I realize a class I'm working on is going to need some other 'service' to fullfill its responsibilities, I simply create a new service interface and add it to my class's constructor. This makes doing top-down development much easier. Once I’ve finished the tests and implementation for the class I’m working on, I can turn my attention to creating the class that fullfills the service interface.
- LINQ - A lot of people focus on LINQ to SQL, but LINQ is more than that. LINQ to Objects is incredibly useful. Instead of complicated foreach loops that filter or project objects, I find myself writing short, elegant LINQ queries instead. Be sure you learn about all the various extension methods and keywords, including things like ‘select…into’ and ‘let’.
- Moq – Mocking frameworks allow you to configure stubs or fakes that you can substitute for dependencies while testing your classes. While they can indeed be abused, they are still quite useful. Moq is my personal favorite for its fluent, lambda-based syntax. Combine it with the adapter pattern, and you can even use it to fake or stub dependencies on base-class library types.
- ASP.NET MVC and MVCContrib – If you are going to make an ASP.NET application, do yourself a favor and go the MVC route. While the drag-and-drop appeal of WebForms can be hard to resist, you will inevitably find yourself fighting its leaky abstractions and lack of flexibility as your application scales. Out of the box, ASP.NET MVC is still quite bare-bones, and you may find yourself having to focus on issues that are more “plumbing” and less “application”. Be sure to check MVCContrib before you start reinventing the wheel. With things like portable areas, fluent control builders, test helpers, and a slew of HtmlHelper extensions, it’s surprisingly easy to build maintainable, testable ASP.NET applications by leveraging MVCContrib and ASP.NET MVC.
Aside from that, I also follow numerous blogs on development. If I had to trim Google Reader down to only two dev blogs, they would probably be:
- Ayende @ Rahien – Creator of more open-source .NET software than probably anyone, Ayende is one of my “code heroes”. I’ve learned a lot from his blog and by reading the code of his various projects.
- Los Techies – The number of really smart people blogging here makes it a must-read. I’ve absorbed a lot of new ideas and information from this place.
I’m sure I’m overlooking something. Let me know what you’ve found most helpful in improving your developer chops in the comments.
About Matt Honeycutt...
Matt Honeycutt is a software architect specializing in ASP.NET web applications, particularly ASP.NET MVC. He has over a decade of experience in building (and testing!) web applications.
He’s an avid practitioner of Test-Driven Development, creating both the SpecsFor and SpecsFor.Mvc frameworks.
He's also an author for Pluralsight,
where he publishes courses on everything from web applications to testing!