Archive for March, 2008
Some of you know that I play guitar in a local band on what’s left of my spare time. Every once in a while somebody ask me how the band is doing, so I guess I’ll just post a general reply here.
Sometime last year we started recording 4 songs for our new demo. It’s been taking awhile because we’ve been on and off for many months (business trips, Holidays, etc.), but now we have a recent mix of the songs online. You can check it out here:
If you’re into Heavy Metal, let me know what you think. If you’re not, I already know what you think.
We’re currently working on a new song, which is going to be part of this demo. We’ve recorded some of it, and hopefully will finish it in the next few weeks. It’s more of a ballad type of song, but with very strong lyrics. Definitely something to add some diversity to our set list.
We’re still in our search for a drummer and a bass player, so if you know somebody in the Houston area that may be interested, please let me know.
As it turns out, I get a lot of great feedback regarding my posts around improving productivity. That to me is great, since this is a topic I feel very strong about, and I’m very passionate about it too. So I guess I’ll just keep doing it.
Today I was reading ScottGu’s "useful links" post (you don’t read Scott’s post? Shame on you…), and one of his links was to this post by John W Powell, with 10 tips to boost productivity. I’m glad to see that I’ve been using pretty much almost all of those tips (just one exception), even though in some cases I use or do something slightly different:
- For Build "solution" I use F6 (instead of Ctrl+Shift+B), and for Build "current project" I use Shift+F6, instead of whatever the default is. Notice that F6 and Shift+F6 are the default keyboard bindings in C#.
- For things such as creating auto-implemented properties, or doing refactoring, I use CodeRush/RefactorPro! (I think I’ve already said that many times in this blog, right?).
- Instead of the recently released PowerCommands for VS 2008, I’ve been using Cool Commands for quite sometime now. CoolCommands has pretty much all the things provided by PowerCommands, and more (for instance, there’s a "Find in Solution Explorer" option that I use a LOT, and I can’t find anything similar in either PowerCommands or VS. It’s unfortunate that the author of CoolCommands hasn’t updated it for VS 2008, but it still can be used regardless.
- I do NOT let VS generate unit test code for me. As Derik Whitaker commented, "…if you allow test to be generated you may not fully understand the intent of the test. Making it almost useless.". I agree with that.
- For mocking dependencies, I’ve chosen to use TypeMock. At the time I was evaluating mock frameworks, TypeMock was the one that seemed to be a better fit for me, and I’ve been happy with it.
- For data-driven tests, I’m not using a SQL Server database. I don’t like using SQL for this because if a developer just gets latest in source code and tries to run tests, everything would fail until the developer sets up his SQL database (unless the code is pointing to a server on the network, which I don’t like because then the developer couldn’t get any work done if not connected to the network). Instead, I’m using XML as the data repository. We have here a DAL that works against XML files, so it’s easy for us to create test data, put it in XML files, and put those in source control, which allows the developer to get latest and run tests immediately, besides being quicker to execute then going against a fat SQL Server DB. Granted, some people may say "if it touches the file system, it is not a unit test", so we also have the option to build the XML files as resources into the test DLL and our DAL will still use it, so there’s no file system touching going on if we want to.
Also, reading through John’s post’s comments, somebody mentioned SonicFileFinder, which I had never heard of before. I’ve obviously decided to check it out, and I’m loving it!! I’ll actually have another post related to that tool and the other ones I used around that area of productivity.
In case you don’t subscribe to Markus’ blog, we’re hiring here…
From Markus’ post:
We are hiring again, and this time on all fronts, from developers and consultants to designers and even sales and marketing, and much more. Here’s a quick overview of the types of positions we are filling:
- Windows Developers (.NET)
- Silverlight Developers
- WPF Developers
- ASP.NET Developers
- (Web) Designers
- SQL Server Developers
- Combinations of all the above
- People interested in creating .NET related content (writing, blogging, podcasts,…)
- Slightly lower priority: Sales and marketing staff for all departments, from consulting to magazine ad sales, to product sales people for products such as Xiine.
The skills we are looking for include .NET, C#, VB.NET, ASP.NET, WinForms, WPF, Silverlight, Design, Development, Visual Studio, Expression Studio (in particular Blend), WCF, Web Services, SQL Server, and so forth…
One position I am personally looking to fill right now is a developer who will work directly with me. I think this is kind of a cool position for someone who is early in his/her developer career and is interested in moving up and learning a ton of new stuff. The goal for this person is to work directly with me and assist me in various development related tasks. Fundamental C# and Win/Web development know how is required, but we are not looking for a superstar developer for this, but for someone who is motivated to grow into such a role over time. .
For those of you interested, send an email either to myself, or to firstname.lastname@example.org
Sometime around 2006 I’ve run across NDepend. The tool was already cool back then, but nowadays it is just outstanding!
From their website:
NDepend is a tool that simplifies managing a complex .NET code base. Architects and developers can analyze code structure, specify design rules, plan massive refactoring, do effective code reviews and master evolution by comparing different versions of the code.
I’ve been using FxCop for quite a while now, and I’ve run NDepend a few times over the last two years, but like I mentioned yesterday in my "Learning in Spiral" post, I was probably not ready to interpret the rich information the tool gives me. In fact, I’m still not ready. The tool provides a ridiculous number of metrics about the code (I say "ridiculous" just because that’s how I feel for not fully understanding all that information).
What’s cool is that I keep researching on software design, so every time I go back and look at NDepend reports I end up learning something else about my code base. Also, the tool provides links to information that explain a lot of the metrics being reported.
I won’t even bother including any NDepend snapshots here because there’s a lot of it at the product’s website. There’s also a number of online demos, so make sure to check it out! The video helps clarifying how we should interpret the metrics, and how we can use the tool in order to learn specific things about our code base.
The way the tool allows me to visually learn things about my code base is just amazing. I’m going through a process of refactoring and improving some parts of our framework, and NDepend gives me really insightful information regarding dependencies, from a top level view (assembly dependencies), all the way down to members; in other words, one can easily go all the way down to, say, a method or property, in order to find out why Assembly X depends on Assembly Y. I’ve been finding some dependencies in some assemblies that should probably not be there, and thinking how I could improve that.
This book has some great chapters that have helped me improve my understanding of coupling, dependency management principles, etc., so when I go back to NDepend, the things I see make a lot more sense than before:
|Agile Principles, Patterns, and Practices in C# (Robert C. Martin Series)
by Robert C. Martin, Micah Martin
Also, NDepend has integration with .NET Reflector, which is another one of my favorite tools.
At this point, I have to say NDepend is a must-have tool for any developer who cares about code quality. Even if you get overwhelmed by the amount of metrics it gives you, just stick with it, because it may take a while for things to sink in, but when that happens, if you’re like me, you won’t be able to shake that "wow" feeling.
Coming from a procedural language background, it took me a while to have a better understanding of OOP. At some point, just being able to create a class and then subclass it to extend behavior made me pretty happy. I thought I knew something, until I got to learn a little more about polymorphism, composition, and things like that. Life was good.
Eventually I heard about some OOD principles such as “Open-Closed principle”, “Hollywood principle”, etc., and realized that there was more to it than I had thought. The same happened when I heard about Design Patterns. Actually, let me say that a different way: I had probably heard of those things when I first started working with an OO language, but I wasn’t ready understand and apply those things.
A friend once told me that human beings learn in spiral. That applies to anything really, but I’ll focus on software development here.
The core idea is that a big part of what we learn is not something new, but instead, it’s an improvement to what we had already learned.
For instance, many years ago, I’ve learned a little bit about databases (what tables and columns are, how to create simple databases, etc.). Then, I learned a little bit about classes. As life goes on, I learned about SQL, T-SQL, and that kind of stuff. At that point, I was revisiting my knowledge of databases, but at a higher level then I was when I first looked into it. Eventually I got to learn something about abstraction, so at that point I was revisiting my knowledge of classes.
I’ve tried to put together a visual representation of this, as represented by the image on this post. If you read it from the bottom up, you’ll probably get the idea of what I’m talking about. Say we fast-forward to the point where I was looking into patterns; at that point, I was not only looking into patterns, but I was also revisiting a bunch of things, such as classes, abstraction, inheritance, polymorphism, and principles. I had also already gone through the process of learning about things around databases, and so many other things, so by the time I’m learning something, I’m coming from a cumulative process, where everything I’ve learned thus far will probably affect my understanding of the thing I’m learning (or revisiting), at the moment.
This cumulative process also encompasses the experience gathered from one level to the next. I mean, by the time I got to learn about some OO principles, not only I had learn some of the core OOP principles, and database, and other things, but I had also experienced a lot of that. From the experience comes the notion of challenging my assumptions of when I’ve first learned about something, so that when I revisit it I’ll realize details I’ve missed back then.
On the little figure I’ve put on this post, I’ve added some question marks at the top of the spiral, which tells me I don’t know what the next thing is going to be, but somehow I know it’ll force me to review my currently knowledge of something. For instance, as I get more and more into TDD, I keep revisiting and polishing what I know about OOP. I’ll actually have another post soon regarding my experiences into the test world (unit tests, integration tests, TDD, etc.).
I really dig this learning in spiral thing…
Child learns simple words, and use them: "dadda", "mommy"…
Programmer learns simple keywords, and use them: "while", "for", "class"…
Child becomes a Teenager, and by this time should know words more formally: "father", "mother"…
Programmer becomes a developer, learns a few more words, and use them: "virtual", "override",…
Teenager becomes more comfortable with the language, and starts to drop a few vowels here and there: "r u there?", "c u l8r"…
Developer has been writing basic words for so long that has now become "Senior Developer" (no new words have been learned, though).
Teenager becomes an adult, learns a lot more words, and learns that in order to succeed in life, it’s mandatory to use the language properly in order to communicate intentions. Improper use of the language may indicate the person is either uneducated, immature, lousy, or all of the above.
Question: should the Senior Developer be labeled as uneducated, immature, lousy, or all of the above?
I’d say all of the above, unfortunately. I don’t believe it’s correct to call a developer a "senior developer" just because he or she has been programming for whatever number of years. I believe what makes a developer a "senior" is the level of expertise and knowledge acquired over the years.
Say developer A has read a book such as "Programing with whatever language in 21 days" or "Programming for dummies" 10 years ago, and has been writing code solely based on what’s been learned from that book. Then there’s a developer B, who has read countless books on architecture, OOD, patterns, etc., and has really mastered the craft, but has only been doing this for, say, 5 years. Who should be labeled "senior" in this case?
What I am trying to say here is that it seems like a lot of developers have been living under a rock for ages. These old dogs don’t seem interested in learning new tricks. There’s code out there that really seems like they’ve been written by children. Just like it is hard for a magazine editor to edit an article written by somebody with terrible command of the language, it’s equally painful to read code that seems to be written for nobody to understand.
Obviously, there are exceptions out there, and that’s where I try to set my bar at. I mean, it’s refreshing to see some ingenious code some brilliant people write out there, and that’s what keeps me interested in software development.