Blog

Walking While Working

Thu, 23 May 2013 00:21:13 GMT

Staying in shape as a programmer can be difficult, but recent studies have shown that even if you’re among those in our profession who do work out regularly, sitting for long periods of time at work is detrimental to your health. To be a bit more dramatic about it, sitting is killing you (see Phil Haack’s blog post on this from last year). So, how can we combat this risk while continuing to get our work done (and, if you’re like me, keep on doing the thing you love)? One option is to take frequent breaks, get up from your desk, go for a walk. This is good advice, and by all means, follow it. But it’s not always easy to do, and of course you still have work to get done at your computer. What if we could get our work done, without having our bottoms stuck in an office chair? More and more of us are doing just that, using standing or walking desk setups. Pictured at right is my current home office setup, which consists of the following components:

LifeSpan TR1200-DT Treadmill Desk (found cheaply on Craig’s List)
Tyke Dual Monitor Stand Desk Clamp
2 HP ZR24w 24” LCD monitors (which don’t have HDMI, which is my only complaint)
Rode Podcaster with Boom and shock mount (for recording my Pluralsight training courses)
… and a fast computer (currently a rig found inexpensively from iBuyPower)

Since walking while working is somewhat novel still, many people have questions and concerns. Since the treadmill desks are rather pricy, that adds to the uncertainty, since it’s difficult to just pick one up to try out and see if it’s right for you. However, more and more people are going this route, both at home and at work, so if you ask around it’s likely somebody you know already has a treadmill desk you can try. Barring that, trying out a standing desk can be as easy as stacking some (stable) things on you current desk and setting your laptop or keyboard up on this higher surface, and working from there for a while to see how you like it. In any case, I’ll try to answer some of the more common questions about this setup here.

First, though, it would be good to be able to actually measure the effect of walking while working (or not), so to that end let me recommend one more gadget to add to this mix: the Fitbit. There are a variety of styles of Fitbit available now, including a wristband model (the Flex), if you prefer that to a clip-on or in-your-pocket version. There are a bunch of nice things about the Fitbit (like food, calorie, and weight tracking as well as gamification and competition with your friends), but for this article I just want to focus on how the Fitbit can help you visualize how active you are during the day. Here’s a typical workday for me:

Occasionally, I’m able to work from home, in which case you can see the difference pretty obviously:

Note that in Fitbit’s graphs above, each bar represents a five minute period, so showing 300 or 500 steps in 5 minutes is still just a walking pace. None of these graphs show, for instance, an actual aerobic running workout. This is just walking at a slow-to-medium pace, which generally doesn’t distract or make typing (or thinking) difficult). The model of treadmill desk I have allows setting the speed in .1 MPH increments between 0 and 4 MPH, and typically for work that involves typing or using the mouse (as opposed to, say, watching a video) I will keep my speed between 1 and 2 MPH. It’s also worth noting that the total steps in the top graph was 12,095, in the bottom it was 18,977, and in a typical workday without using the treadmill desk at all, it would often be under 5,000.

Now, let’s address some questions I’ve had myself, or have been asked by others, about this crazy idea of actually getting work done while walking.

How do you like the Lifespan TR1200 DT?

I’m very pleased with it. As I mentioned above, I picked mine up locally by finding someone who had an almost-new one they wanted to sell, so I paid much less than retail. That made trying it out much easier to stomach (and increased the Wife Acceptance Factor). It has a fairly large desktop, with a built-in wrist rest that I find to be very comfortable to use. The wrist rest spans the whole front of the desktop surface, so it helps with the mouse as well as the keyboard. Also, the front of the desk is slightly curved, which I like because it lets me be a little bit closer to the desk, while still letting me set things off to the side (phone, mouse, coffee, etc.). The settings work fine for me. I don’t use any of the custom settings, or track things like steps, calories, distance, weight, etc., mainly because I use Fitbit for that. The controls beep every time you make a change, which I’ve read others have found annoying enough that they’ve filled the speaker hole with hot glue to muffle the sound, but it hasn’t bothered me enough to worry about that. The treadmill itself is super-quiet, at least compared to another treadmill I’ve had for home use (bought over 10 years ago, so maybe they’re all much quieter now). You can be on a phone or skype call while walking and nobody can tell (though I don’t walk while recording Pluralsight courses, since I don’t want to have the risk of errant sounds to have to clean up during editing). The desktop is height-adjustable, but not automatic. If you want an automatic (motorized) desktop, it’s going to cost a lot more. You can sit a barstool height chair on the treadmill (or roll the treadmill out of the way – it’s not attached to the desk except via a couple of cables that can easily be unplugged), so if you want to take a break and sit down at the desk, it’s not terribly difficult to achieve. Personally, if I need a break from walking, just standing for a bit works for me, and if I need more of a break than that, I’ll typically leave my desk and go do something else for a bit (or switch to checking email, etc., from my iPad, maybe in a comfortable chair or at a table).

Note that when using the Tyke Dual Monitor Stand Desk Clamp with this particular desk, you’ll need to mount the clamp slightly off-center, since the desktop includes a cable run in it. There’s also a metal cable-tray that attaches at the rear of the desktop that I had to remove in order to use the monitor clamp, but that wasn’t a big deal in my case (the power strip I had had in the cable tray is now simply hanging from the back of the desktop, which isn’t necessarily ideal, but it’s working. And of course I could always mount the power strip to the underside of the desktop with screws).

Multi-Tasking is Bad; Why isn’t Walking While Working a Bad Idea?

There’s plenty of research available to suggest that multi-tasking can detract from our ability to work effectively. Doing multiple tasks at once means none of them have our full attention, and some studies have shown that heavy multitaskers tend to be less able to focus on the task at hand in the presence of distractions. There are also plenty of practices in use in software development that are specifically designed to reduce multitasking and distractions. One of the fundamentals of kanban is to reduce work-in-progress, to maximize the rate at which tasks are completed. The pomodoro technique prescribes eliminating all distractions for a 25-minute period during which all of our attention can be directed at the task-at-hand. Pair programming works best when both parties are fully engaged in the task-at-hand, and it can be much more difficult to allow ourselves to be distracted by email, twitter, etc. when we’re working with a partner on a task. As someone who feels there is value in all of these techniques, I can tell you that walking while working does not, typically, qualify as a separate task we’re focusing on that distracts from our ability to work effectively.

You can think of any number of things you’re doing while you’re working, or while you’re reading this. Maybe you’re sitting. Maybe you’re breathing. Maybe you’re walking. None of these is requiring a huge amount of concentration from you, typically (unless you’re sitting on a bucking horse, or walking through a crowd and having to navigate your path). Walking in place, at a pace that doesn’t require you to breathe hard or perspire, is not terribly distracting for most tasks, most of the time. Are there times when I want to take a break from walking, so I can really concentrate on something? Certainly. But for most of my work, and most of the time when I haven’t already been walking for hours without a break, it doesn’t even enter my mind that I’m walking. And frequently, rather than distracting, walking can help me think. If you’ve ever gone for a walk, alone or while having a conversation with someone, and found when you were done that you were less stressed and had solved, at least in your mind, some problems that had been causing you stress, you’ve worked effectively while walking.

How do you avoid getting all sweaty?

If you’re just walking at a light pace, this shouldn’t be an issue. At least, it hasn’t been for me. Of course, you can always adjust your air conditioning, or point a fan at your workspace, if those help. My treadmill desk is currently in my basement, the coolest part of the house, so it’s generally comfortable. Loose-fitting non-chafing clothes are probably a good idea, but I’ve been fine in anything from running shorts to the same khakis I wear to the office.

How can one afford one of these setups?

There are plenty of options for do-it-yourself alternatives to the LifeSpan $1500-retail treadmill desk. I know Julie Lerman has had some success sitting her bicycle trainer in front of her desk to work. Plenty of others have used off-the-shelf Ikea or similar furniture to create standing desks, or to build a desk around a standard, less-expensive treadmill. And you may be able to get lucky, like I did, and find one locally via Craig’s List or your newspaper classified section for much less than retail.

When you consider the cost of a decent desk, along with the cost of a small, quiet treadmill, the overall cost of the LifeSpan unit is still a bit more, but not unreasonably high. If you factor out a couple of hundred dollars for a decent chair (that you won’t need, if you’re always walking or standing), then the price becomes even more reasonable. And if you’re doing professional work using this equipment, you can very likely write it off as a business expense (consult your financial advisor, I am not a lawyer or accountant, YMMV, etc.).

How do you pair program on a treadmill desk?

I haven’t tried it, and I don’t know if it’s practical. So far, I’ve only used my setup at home, to work on my own. If I were to get one of these at the Telerik office where I work, it would probably be a shared workstation, where different employees could go to check email, take a customer call, etc. for an hour or two at a time. Alternately, I might try to get one for my own primary use, where currently I don’t ever pair program with anybody (on the rare occasions when I get to pair program, I do it in one of our team rooms at one of our pair programming workstations).

Alternately, if you’re really good, you might be able to have the shorter person walk in front, the taller one walk in back, and as long as they’re able to keep in step, both could work together on the same treadmill (and computer) at the same time. It would be hard for them to swap positions, so hopefully the taller one would have long enough arms to reach the keyboard and mouse from behind the shorter one. :)

Don’t your feet/back/legs/whatever get sore?

Not so much. Occasionally my lower back will feel it if I’ve been working while standing or walking for a long time. I find that making sure the desk is at the right height so that my arms can be in the correct position (forearms parallel to floor) helps this. A little bit of stretching takes care of it for me. Also sometimes my Achilles are tight, but no more so than if I’d done a lot of walking-sans-working, and again stretching resolves the issue. If you do find that walking or standing causes you pain or discomfort, slow down and limit how much you do per day until your body gets used to the additional activity. If your body has been conditioned to not do anything for up to 8 hours a day while you sleep, and another 8 hours a day (or more) while you’re at a desk, plus whatever time you spend sitting in a car or on a couch watching TV,etc., it’s going to notice when you start converting those at-work hours into (light) activity hours. Stick with it, and in a little while your body will be used to the new normal activity you expect of it.

How can you work with papers, etc. from a treadmill desk?

This can be a bit of a challenge, and especially before I got the monitor mounting arms, my desktop space was limited. But with the monitor up off of the desktop, there’s really quite a bit of space available using my setup to spread out papers. Personally, I try to limit the amount of paper I need to work with, but sometimes it’s inevitable, so it’s nice to have the available space. If you’re trying to process bills, or do data entry of some kind, etc. and you need some desk space for the papers, you’ll probably have enough space with my setup. You might need to just stand, rather than walk, if you’re having to reach for papers, etc., but it’s still better than being stuck in a chair for hours.

What kind of shoes should you wear?

Whatever are comfortable for you. I have a pair of running shoes that I often wear while on the treadmill that are “indoor-only” so they’re clean. But I also will frequently use the treadmill desk in bare feet, or in socks. In the winter months, when it was a bit cooler in the house, I would even walk in slippers. I haven’t had any problems with any of these options, but again, choose whatever footwear works for you. If you’re just getting started, choose shoes that have good support, no different than if you were going to go for fairly long walk.

Does the Fitbit Flex work while you’re typing (and walking)?

I haven’t tried one myself, but I asked this question of Fitbit and was assured they’d tested it in such scenarios and it would record steps accurately under these circumstances.

How easy is it to adjust the height of the Lifespan TR1200 DT?

You can do it with one person, but it’s a bit easier with two. There are to dials that you loosen, then pull out, releasing pins in the legs of the desk. While the pins are out, you slide the desk up or down to the desired height, then replace the pins. It’s best to do this with nothing on the desk. Once at the desired height, tighten the dials back down – this will eliminate any tendency for the desktop to wiggle (e.g. if all of the weight is on the back of it, like it is in my case with the mounted monitor stand).

How easy is it to use a chair with this setup?

Easy. I have a bar-height chair a few steps away that I’ve used a few times. I just set it on the treadmill itself, which has worked fine, but probably isn’t recommended for extended use (I suspect it could cause wear on the treadmill belt, but so far it’s been fine). Alternately, pulling the treadmill itself out from under the desk is quite easily done. There are two cables, a power cable and a small serial cable that connects it to the desk (and the controller on the front of the desk), that need undone, but that’s it. There are wheels on the front of the treadmill, so if you just pick up the back of it, it will roll out of the way, as long as you have some room to maneuver. Then you can stand (off of the treadmill) or put a (high) chair there if you’re taking an extended break from walking. I haven’t done this, but the whole operation should take about 2 minutes (unless you’re very tight on space, in which case it might take longer).

Regional Differences

Tue, 21 May 2013 15:16:28 GMT

Last week I ran a poll (that maxed out at 400 responses on twtpoll) asking how developers recommend using regions in C# (or not). You can see the results here:

About 15% of the respondents chose Other and/or chose to leave a comment. The comments are useful because they often highlight answer categories that I overlooked when I set up the poll. In this case, there were a lot of comments, I think because there are a lot of different opinions about regions in general, some of them rather heated.

Clearly the largest number of respondents simply never use Regions. A number of comments went on to say things like “Regions aren’t evil I just don’t know a situation where they’re useful.” The most popular use of regions from the ones I provided was for wrapping interface implementations, which isn’t too surprising since these regions are often automatically added when an interface is implemented automatically. Similarly, a large number of comments referenced “generated code” as a use case for regions, which I probably should have included in the original listing.

I added a couple of the options above, F and G, as items that I would consider obvious wrong answers on a standardized test. Surprisingly, both got a reasonable number of votes, with 13% of respondents recommending the use of regions with long functions. Now, some of these votes probably belong to commenters like this one: “Hiding long methods as I refactor it”. If you’re temporarily collapsing sections of a long function during your refactoring exercise, that seems quite reasonable to me. But if you’re putting regions into your function as a recommended, long-term approach, then I probably don’t want to work on that codebase with you. I would much rather functions be small enough that (without regions) they fit on one screen, and if they get too big for that, fix the problem by extracting out well-named and well-composed methods, as opposed to hiding the problem behind regions. And regions with regions. Wow.

My personal opinion is that regions had some great and common use cases in the early versions of .NET and C#. For instance, the first version of ASP.NET used regions appropriately to hide auto-generated wire-up code in the codebehind. A large number of comments continue to suggest that regions be used for generated code. Today, two things make this less of an issue. The first is partial classes. Generated code today is almost always in its own class, or could be, and as such rather than wrapping it with a region, I find it is better to simply use a partial class to keep the generated code in a separate file from the custom code. The second feature is more of an IDE feature. A lot of users find regions helpful as a code navigation tool, or as a way to limit what they are looking at on the screen. VS2010 provides great support for expanding and collapsing methods and other areas of code that you don’t wish to see, and tools like ReSharper make it trivial to navigate to a type or member anywhere in your solution (ctrl-T, then type a substring of the type, then enter and you’re there. For a member, the default keymap is the not-quite-as-easy-to-type ctrl-F12). A number of comments also suggested using regions for using statements. These don’t tend to bother me because I can quickly scroll down and not have to see them on my screen, and my using statements are usually quite small since ReSharper will clean up the ones I don’t need and will auto-add any that I do need, and my classes are small so they aren’t generally using more than a handful of other namespaces. And of course, VS2010 supports collapsing using statements as well, like so:

Why Consider Them Harmful, Smelly, or even “Evil”?

Evil is obviously a strong word, and of course since regions have no effect on compiled code, they can’t directly have any impact on the software you’re creating. However, I do think it is at least fair to say that regions often represent “code smells.” That is, areas of your code that may be worth investigating to see if there is rotten code that needs to be cleaned up. Why do some, including me, tend to feel this way? Because regions are often a symptom of underlying problems with the code itself. Regions do two things:

Provide a single-line comment
Wrap some number of lines of code and allow it to be hidden on demand

When might you need these features?

The intent of the code is unclear
The code is too long to quickly understand at a glance
Both of the above
You prefer an “outline view” of classes so you can drill into each category of member when you dig into a class

In the case of items 1 through 3, regions are covering up problems.

If the intent of a block of code is unclear, fix the code. Extract a method. Rename the variables. Refactor. Simplify. Don’t add a comment or a region (glorified comment) to try and cover up the problem. If you spill something in the kitchen, should you clean up the floor, or just throw a rug over it or put out an orange cone to warn people about the spill? Which option is going to keep the kitchen optimally usable? The same goes for your code. Keep it clean. Regions are rugs under which to sweep smelly code.

If the code is simply too long, fix it. Eliminate duplication. Refactor. Abstract details into larger-grained operations. If you’re spending 10 lines of plumbing code talking to a database or service, move that into its own method or class that is only responsible for that work. If you’re spending lots of lines of code copying values from one object to another, use a tool like Automapper to map the values with one line of code. Keep your code concise and at the appropriate level of abstraction for the method you’re in, and don’t mix plumbing code with application code if you can help it.

In the case of 4, regions are being used to do something that your IDE should be able to easily do for you. I won’t say regions are being mis-used in this context, but I do think that if a large number of people use them for this purpose, then Visual Studio or one of the add-in providers should provide this kind of view such that you don’t have to implement yourself in the source code with region statements. I definitely think it’s valid that some developers prefer this view of their classes, I just don’t think they should have to clutter up everybody’s codebase in order to do so. Let the IDE do that work. And of course, if the classes and methods are small, the need for a high-level view is significantly lessened. If you prefer to have all of your public properties in one section, public methods in another, private members in another, etc. then wouldn’t you prefer to have an IDE that would simply let you specify the organization you prefer, and automatically have it in every file you open?

Summary

Almost half of the developers polled would never recommend using regions. Yet nearly 15% of those polled would recommend using them to organize long methods. A great many use them to organize code into categories (public, private, methods, properties), though this could probably be better done automatically by a tool. When .NET was young, regions provided a useful way to hide generated code within classes or to provide expand/collapse capabilities within the IDE. Today, partial classes and improvements to the IDE and various plug-ins make these uses unnecessary for many developers. Clearly, there are still some opportunities for IDE/plug-in vendors to build in code organization support that will further erode the legitimate use cases for regions. If you’re not using them for such organizational purposes today, think about the underlying reason you’re using a region the next time you add one, and consider if you wouldn’t be better off correcting the underlying code deficiency rather than hiding it under the region rug.

Moving a Site to Windows Azure in 5 Easy Steps

Tue, 21 May 2013 02:42:53 GMT

One of my sites is currently having issues where it’s currently hosted. They’re resolved by restarting the application, but that’s gotten tedious and I simply don’t have time to invest in troubleshooting this particular site. And, oh hey, those MSDN Windows Azure benefits keep looking shiny like I should play with them. So, I figure I’ll try moving the site to Azure and see if miraculously that fixes the problem.

Step One: Activate Azure Benefit

Sign into your account with your MSDN Subscription, and click the Activate Windows Azure link:

Fill out the form, which will require a credit card and a mobile device (that can receive text messages) to complete.

Step Two: Connect to Azure Portal

Follow one of the many links to https://manage.windowsazure.com (or just click on mine). There’s a ton of stuff you can configure and create from here. In my case, since I may want to host more than one small website, and I want to be able to use A records (I’m not a fan of www in front of domains for web sites, which is pretty much required for CNAME DNS approaches), I’m choosing to create a small VM (more on Azure DNS). You can do this from the NEW command in the bottom left, and if you use the gallery option you can select the OS you want – in my case I went with Windows Server 2008 R2 SP1.

Once you complete this wizard, it takes a few (really surprisingly few – I remember how long it took to deploy apps to the original version of Azure, and this is way faster) minutes to deploy and start the VM. In a short while, you should see:

So now what? Click on your VM to see what you can do with it:

The next thing I want to do is remote into the machine and start setting things up.

Step Three: Connect to Virtual Machine

My first thought was to just try to connect to the public foo.cloudapp.net name my VM was given, but of course that didn’t work. Looking at your VM, navigate to the ENDPOINTS tab to see the public port configured for RemoteDesktop access. You’ll need to specify that in your Remote Desktop Connection in order to connect (you do this by adding it to the end of your computer’s name following a : (colon)):

With that, you should be able to remote into the machine. In my case, since I want this VM to act as a web server, the first thing I need to do is Add Roles and select the Web Server (IIS) role. After that, the web platform installer is your friend. Once IIS is configured and I’ve gotten my web site’s files to the server, the next step is to configure the database.

Step Four: Configure Database

Your MSDN benefits include some database benefits in addition to the VM and web site benefits. Note that the database benefits are fairly limited, so if you have a lot of small databases you may use up this benefit quickly. With the Visual Studio Ultimate with MSDN benefit, you can use five 1GB web databases per month for free. To create a new database, go back to the Azure Management Portal, click on NEW, and choose SQL Database.

Choose a name, and a server (or a new one will be created if this is your first SQL Database). Then, if this is a new server, specify the username and password that will be used to connect to it. Once set up, which takes a few seconds, you should see the database:

So now, how do you connect to this database and move your existing data to it, is the next question…

Step Five: Connect to a SQL Database in Windows Azure

Click on the database name just like with the VM to see initial options:

Now that you see the server info at the bottom, naturally the next step is to try and hit it with SQL Management Studio, but you’ll get this:

Security bites us again! Click on the DASHBOARD link to change which IP addresses are allowed to connect to the server:

It will help you out by suggesting your current client IP:

Be sure to click the SAVE link at the bottom after you add it.

Voila! Now you can connect from Management Studio, which will let you run whatever queries you need in order to get your data into the database.

One last note – to actually connect to your web site on your VM, you’ll need to set up an endpoint for port 80 via the VM’s ENDPOINTS menu.

Once that’s in place, you should be able to hit your site in a browser:

When To Comment Your Code

Thu, 09 May 2013 02:01:22 GMT

My opinions on comments in software code have evolved with my experience. When I was a teenager first learning to program for real, I rarely used comments unless the code was for an assignment, in which case it was a forced exercise every bit as much as teachers’ requests to “show your work” added verbosity to my math and science problems’ solutions. Of course, the programs themselves were quite simple, and the languages used (BASIC, Pascal) didn’t really support OOP (not that I knew what that was). And it was important, then, to be able to express the intent of the code in English, if only so the instructor knew what was being attempted. It wasn’t uncommon to receive partial credit for comments describing the approach one would take, not having had enough time to actually write the code itself.

Later on in college, my first course used Scheme and the classic Structure and Interpretation of Computer Programs textbook. My first labs included comments not for the instructor, but for my own sake. Scheme is a very different kind of language from those I’d used before, and my lack of familiarity with it necessitated that I describe what esoteric blocks of parentheses were meant to be doing with comments. I still have that textbook, the first edition, which I noted as I wrote this doesn’t even mention comments in its index. The second edition, which is available online, has only this to say:

“Semicolons in Scheme code are used to introduce comments. Everything from the semicolon to the end of the line is ignored by the interpreter. In this book we don’t use many comments; we try to make our programs self-documenting by using descriptive names.”

Self-documenting is an interesting term and relates to the discussion of comments. It even has a (small) wikipedia entry devoted to the concept. The chief objective of self-documenting systems, according to this source, is that they make source code easier to read and understand. In my opinion, source code should be written in such a way that its simplicity eliminates the need for most comments. I’ve collected here a number of quotes and excerpts on the subject of comments, and have added my own thoughts to these as well.

"The most reliable document of software is the code itself. In many cases, the code is the only documentation. Therefore, strive to make your code self-documenting, and where you can't, add comments."
- Daniel Read - The Principle of Self-Documenting Code.

“The way to make programs easy to read is not to stuff them with comments... A good programming language ought to be better for explaining software than English. You should only need comments when there is some kind of kludge you need to warn readers about, just as on a road there are only arrows on parts with unexpectedly sharp curves.”

- P. Graham (in "Hackers and Painters" footnote 9, pg. 224)

It’s hard sometimes to know what should or should not be commented, especially if you’re inexperienced. What seems worthy of commenting to you might be obvious to someone with a better grasp of the system or programming language you’re working with. Steve McConnell offers some advice on this.

Code Complete, by Steve McConnell, is on my list of books I consider to be required reading for software developers today. He notes:

Comments should explain the why instead of the how or what.

Here are two examples of code from Code Complete that illustrate the poor usage of comments:

 1: //set product to base

 2: product = base;

3:

 4: //loop from 2 to "num"

 5: for ( int i = 2; i <= num; i++ ) {

 6:     //multiply "base" by "product"

 7:     product = product * base;

 8: }

 9: System.out.println( "Product = " + product );

and

 1: //compute the square root of Num using the Newton-Raphson approximation

 2: r = num / 2;

 3: while ( abs( r - (num/r) ) > TOLERANCE ) {

 4:     r = 0.5 * ( r + (num/r) );

 5: }

6:

 7: System.out.println( "r = " + r );

McConnell concludes:

If the code is so complicated that it needs to be explained, it’s nearly always better to improve the code than it is to add comments.

One of the simplest ways to achieve this is to name variables and classes consistently and descriptively, in plain English. Another is to keep methods small, well-named, and single-purposed. When you see a method growing out of control, that’s a sign that another method is growing inside of it – use extract method to set it free and give it a descriptive name.

When structuring a process, it’s a common practice to start out by writing comments for the steps involved, e.g.:

// Extract the data from the old system

// Transform the data

// Load the data into the new system

This is fine in my opinion as a way to organize one’s thoughts, but the next step isn’t to put 100 lines of code after each comment, it’s to replace each comment with a method name, e.g.:

Extract();

Transform();

Load();

A couple more quotes from Steve McConnell:

Good code is its own best documentation. As you're about to add a comment, ask yourself, "How can I improve the code so that this comment isn't needed?" Improve the code and then document it to make it even clearer.

- S. McConnell

It's OK to figure out murder mysteries, but you shouldn't need to figure out code. You should be able to read it.

- S. McConnell

Comment Only What the Code Cannot Say

In 97 Things Every Programmer Should Know, Kevlin Henney writes a small essay on comments, including:

What of comments that are not technically wrong, but add no value to the code? Such comments are noise.

A prevalence of noisy comments and incorrect comments in a code base encourage programmers to ignore all comments, either by skipping past them or by taking active measures to hide them.

Try to express as much as possible through code. Any shortfall between what you can express in code and what you would like to express in total becomes a plausible candidate for a useful comment. Comment what the code cannot say, not simply what it does not say.

[Read the full essay here]

Again, the point is made that comments should not say what code simply does – the code should do that already. If the code isn’t clear, make it clear.

If your clothes are smelly, wash them, don’t spray Axe body spray all over them to try and communicate that they shouldn’t smell.

My own contribution to the 97TEPSK book is the Don’t Repeat Yourself principle (I didn’t invent it, I just wrote about it for the book). Comments that say only what the code already makes clear merely add noise and violate the Don’t Repeat Yourself principle. They invite bugs for all the usual reasons that repetition in software attracts bugs, and have the added effect of drowning out any truly insightful and important comments by training developers to ignore comments.

Comments Can Be (and frequently are) Wrong

…and the only way to know it is to read and understand the code.

“A comment is of zero (or negative) value if it is wrong.”

- Kernighan and Plauger, The Elements of Programming Style

“If the code and the comments disagree, then both are probably wrong.”

- N. Schryer

Don't get suckered in by the comments -they can be terribly misleading: Debug only the code.

- D. Storer

Since you can’t trust comments to be correct, and you can’t verify their correctness in any automated fashion (at the time of this writing, I’m unaware of any comment unit testing frameworks), the only way to verify the correctness of comments is to read and understand the code they relate to. If the comment attempts to express what the code does, then if ever the code or the comment changes such that the two are no longer in sync, bugs are bound to occur if the comment rather than the code is used as the basis of understanding what the application does.

In Software Design

There are two ways of constructing a software design. One way is to make it so simple that there are obviously no deficiencies. And the other way is to make it so complicated that there are no obvious deficiencies.

- C.A.R. Hoare

Which of the above two software designs do you think would require more comments? Interestingly, one quote sees the act of being forced to write comments as being potentially helpful to design:

Being forced to write comments actually improves code, because it is easier to fix a crock than to explain it.

- G. Steele

The assumption seems to be that one need only comment the ugly bits in the code, and so by cleaning them up one avoids the necessity of explaining the ugliness.

In Communication

Omit needless words. Vigorous writing is concise. A sentence should contain no unnecessary words, a paragraph no unnecessary sentences, for the same reason that a drawing should have no unnecessary lines and a machine no unnecessary parts.

- W Strunk Jr (in The Elements of Style)

Software source code is written for two audiences: computers and programmers. Computers don’t care what the code looks like, how it’s organized, what things are named, and certainly what the comments say. Programmers, of course, will care about many of these things. By keeping the source code simple and without unneeded noise, we maximize its clarity as an instrument of communication. Note that I’m not suggesting we minimize the number of characters used or anything silly like that. But we should avoid redundancy and repetition and vestigial blocks of text that serve no functional purpose as much as possible, as these cloud the clarity of the code.

"The most common kind of coding bug, and often considered the least harmful, are documentation bugs (i.e., erroneous comments). Although many documentation bugs are simple spelling errors or the result of poor writing, many are actual errors - that is, misleading or erroneous comments. We can no longer afford to discount such bugs, because their consequences are as great as 'true' coding errors. Today programming labor is dominated by maintenance. This will increase as software becomes even longer-lived. Documentation bugs lead to incorrect maintenance actions and therefore cause the insertion of other bugs. "
- Boris Beizer - Chapter 2: The Taxonomy of Bugs, Section 3.5. , Software testing techniques by Boris Beizer , ISBN: 0442206720

Here Be Dragons

In addition to expressing why, comments should also be used to explain why not.

"Write comments that emphasize potential hazards. "
- Steve Maguire - Chapter 5: Candy-Machine Interfaces. , Writing Solid Code: Microsoft's Techniques for Developing Bug-Free C Programs by Steve Maguire , ISBN: 1556155514

Sometimes you’ll find that code needs to be written in a way that might not be intuitive to another programmer (or yourself) at a later date. Maybe it is inconsistent with the usual way things are done, or it appears to be inefficient and in need of optimization, but you know, at this moment, that the consistent or optimized way does not work, while the current implementation does. Here is a great opportunity to say what the code cannot with a comment: why not optimize it?

Like caution signs on roadways, comments can warn of dangers in the codebase. But just like ubiquitous “Are you sure?” windows, too many comments can condition developers to ignore the important warnings along with the noise.

[more on Here Be Dragons origins]

Comment Therapy

If you’ve had comment-writing beaten into you to the point where it’s not natural for you to simply write code that expresses what it does clearly, consider these techniques:

"When you feel the need to write a comment, first try to refactor the code so that any comment becomes superflouus."
- Martin Fowler, Refactoring: Improving the Design of Existing Code by Martin Fowler, Kent Beck (Contributor), John Brant (Contributor), William Opdyke, don Roberts , ISBN: 0201485672

And of course, if you really want to know what code does, read (and execute) the tests for the code. If the tests are written in a self-documenting fashion, they should have expressive names that tell you how the code should behave under certain circumstances. Does it throw an exception when you pass in a null parameter? Hmm, well there’s a test called FooShouldThrowExceptionWhenParameterIsNull, and it’s Green, so I’m going to say that yes, at this moment, that’s the behavior. What, there’s no test for that? You know how to fix that, don’t you?

Comments for Documentation

Many programming languages support some kind of documentation-extracted-from comments feature. In .NET there are /// <summary>…</summary> XML comments that can be used with NDoc / Sandcastle. In Java there is JavaDoc. If you’re generating such comments, my first question is, is anybody actually reading the generated documentation? My second question is, how useful is it? I’ve probably searched for some documentation on a class hundreds of times only to end up on a website with the auto-generated documentation where it says only the most obvious of information about the class – and provides no examples. http://msdn.microsoft.com used to be awful in this regard, but has lately gotten much better.

If you’re shipping a framework or a product with a public API, then obviously documentation of what the code does is important. However, in both of these cases only the public interface needs to be described in great detail, and in .NET you can actually apply your XML comments to an interface, rather than to a class, which I think makes more sense since ideally you want the interface to be the primary way other components interact with your framework and classes, to avoid tight coupling. XML comments on interfaces are also picked up by Intellisense in Visual Studio for classes implementing the interface.

Clean Code

In Clean Code, Robert “Uncle Bob” Martin devotes a chapter to Good Comments (chapter 4). Here’s a brief excerpt from the start of the chapter, with which I agree completely:

The proper use of comments is to compensate for our failure to express ourself[sic] in code. Note that I used the word failure. I meant it. Comments are always failures. We must have them because we cannot always figure out how to express ourselves without them, but their use is not a cause for celebration.

So when you find yourself in a position where you need to write a comment, think it through and see whether there isn’t some way to turn the tables and express yourself in code. Every time you express yourself in code, you should pat yourself on the back. Every time you write a comment, you should grimace and feel the failure of your ability of expression.

Why am I so down on comments? Because they lie. Not always, and not intentionally, but too often.

Truth can only be found in one place: the code. Only the code can truly tell you what it does. It is the only source of truly accurate information.

So, since you can’t trust comments, you have to read the code to know what it does. And since you’re going to have to read (and understand) the code anyway, it’s certainly better to spend the energy and thought making the code simple and clear and readable, rather than trying to explain what a mess of code is attempting to do (or was at some point in the past when the comment was added).

Clean Code also goes on to recommend that boilerplate comments such as licensing/copyright information, change history, and old blocks of code that might someday be useful can all be replaced with proper version control systems and post-build processes that leave the actual source files small and clean. Use the right tool for the job – source control is a much better way to store change history and vestigial code than within the code itself, and no programmer working day-in and day-out should need to trip over legalese that can easily be appended to the top of every file out-of-band or as part of packaging the files for a release.

Clean Code is another book I highly recommend, and is one of my favorite developer books.

Summary

While not strictly evil, comments should generally be avoided where the code can tell what it does as well or better. Good comments tell only what the code cannot express itself, such as why a particular technique was favored or the dangers of optimizing a block of code. Most other kinds of comments are simply noise, and their presence clutters of code, making it more difficult to understand and creating errors when, inevitably, the comments get out of sync with the code they reference. Overuse of comments also tends to make real warnings less noticeable, just as the boy who cried wolf trained the townspeople to ignore is warnings. Consider carefully how and when comments should be used within your codebase.

Speaking at FalafelCon

Mon, 06 May 2013 18:13:48 GMT

Hey, California people, I’m coming your way. I’ll be speaking at FalafelCon 2013 next month about Refactoring with SOLID Principles. The event is taking place 10-11 June 2013 at Microsoft’s Silicon Valley campus. The speaker lineup looks pretty awesome, with keynotes from Scott Hanselman, Stephen Forte, Michele Bustamante, and Tim Huckaby, and tracks covering Web, Mobile, Sitefinity, and TestComplete.

My session will briefly cover the SOLID principles of object-oriented design, which you can of course learn more about in my Pluralsight course on SOLID Principles of Object Oriented Design. In addition to discussing each principle, this presentation also demonstrates how, through simple refactoring techniques, programming structures that are causing you as the developer pain can be improved, resulting in a better design. As it happens, I’m currently working on a course on Refactoring for Pluralsight, which I hope to add to my list of published courses there soon.

If you’re in the area, I hope you’ll attend. If you do, please let me know how you enjoyed the presentation.

March 2013 Pluralsight Experiment

Thu, 04 Apr 2013 03:06:52 GMT

Update: Winner and Results

The winner of the experiment's prize is Martin Frey (@tinfrey). You can watch a video of the random drawing here (I'll keep the file up until at least 1 May 2013).

In terms of the results of the experiment, I would say they were somewhat inconclusive. I noted in the initial post below that my SOLID course averaged just 78 minutes per unique subscriber in February. Reviewing the figure, it's actually 77.31 minutes. In March, during the experiment, this jumped all the way up to 77.42 minutes (almost 7 seconds more!). Looking at another course, Kanban Fundamentals, the course's per-user viewing time average ranged from 41.9 minutes in Dec 2012 to 36.3 minutes in January, up to 39.8 minutes in February, and maxed out at 43.2 minutes in March. It's difficult to say if this was natural variation, a result of this experiment, or due to other factors, though.

For the experiment, the courses' popularity for entries was as follows:

Creating N-Tier Apps Part 1, 13 entries
Creating N-Tier Apps Part 2, 8 entries (and the winner)
Design Patterns Library, 3 entries
Kanban Fundamentals, 12 entries
SOLID Principles of OO Design, 12 entries
Web Application Performance and Scalability Testing, 0 entries (c'mon, really? it's not a bad course, honest!)

Thanks to everybody for participating. Martin - please DM me with your email address and I'll send you the Amazon gift certificate.

The Experiment

See how many people will spend more time learning via Pluralsight (and actually completing courses, not just watching a little bit) with a chance at $100 as motivation.

The Prize

$100 Amazon Gift Certificate (out of my own pocket). Just one. To be sent to the winner via email.

The Rules

You must be a Pluralsight subscriber with a public profile (like this one)
You must tweet that you’ve completed one of my courses (by name), with a link to your public profile and with @ardalis mentioned in the tweet (so I can track them; not at the start of the tweet like a reply).

If your profile doesn’t list the course as complete, you won’t be entered to win
You don’t have to have passed the assessment
Example (the link must go to your profile):
Just completed Kanban Fundamentals by @ardalis http://ow.ly/ixQbb

You may enter multiple times, but only one time per course during the contest period

That is, if you complete 3 of my courses, and tweet each one, you will have 3 chances to win

The contest ends at 11:59pm EST on 31 March 2013.
Winner will be chosen at random and selected by 5 April 2013, and notified via Twitter

In the event the profile listed in the tweet and the person tweeting do not match, the person matching the Pluralsight profile will be deemed the winner

Eligible courses include any listed on my Pluralsight Author Page; I’ve also created an SVG/PNG graphical learning path of my training courses

Questions?

But I completed your course a long time ago – can I still enter?

Sure, as long as you follow all of the rules above and the course shows on your public profile

Which course(s) would you recommend?

I think the SOLID Principles course should be required for all software developers, but if you’re looking for the quickest way to complete a course, Kanban Fundamentals is only 92 minutes long. Any and all of them are fair game, though. Kudos to anybody who gets through all of the Design Patterns Library.

What should I spend my $100 on?

I have some recommended developer books you might consider. I’m also a big fan of my LifeSpan TR1200-DT treadmill desk, which you could apply the gift card toward.

What course are you working on now?

I’m currently recording a Refactoring Fundamentals course.

Will you share the data?

Yes, I’ll be sure to share the results of the experiment.

Are you just doing this as a cheap(?) way to increase traffic to your courses?

You saw through me so easily? That’s the experiment part of things – I have no idea if this will cost me money, break even, or if the increase in royalties will cover the prize and trouble of running the experiment. I do know that in February 2013 my SOLID course was watched about 78 minutes per unique subscriber who watched it. The course is 248 minutes long, so that’s just 31% of the course. I’m wondering if I can make a noticeable impact on March’s course completion rate.

How do I set up a public profile on Pluralsight?

Log in.
Click on your username in the top-right.
Click on Your profile
Customize your user name if you wish to do so
Click the Share my profile button if it’s not already enabled.
If it’s currently shared, you should see something like this:
When you share your profile, others can access it here: http://pluralsight.com/users/steve-smith

Speed Up YouTube Videos

Fri, 22 Mar 2013 17:27:06 GMT

If you’ve ever wanted to speed up a YouTube video, like you can do with Pluralsight training videos, here’s a quick tip to show you how to do so.

Today, I was watching the KendoUI 2013Q1 Release Keynote on YouTube, because I wasn’t able to catch it live. It’s a little over an hour long, and I’ve become rather spoiled lately by Pluralsight’s video player, which lets you adjust the speed to whatever level you’re comfortable with between 1x and 2x in .1 increments, like so:

The iOS app for Pluralsight also supports this, and I usually set it around 1.5 or 1.6, personally.

Back on YouTube, the default Flash player has no such controls:

However, if you switch to the HTML5 player for YouTube, you can control playback speed. You’re limited to choosing between 1.5x and 2x speeds, but this is probably good enough for most people, and certainly an improvement over having no choice at all. To switch to the HTML5 player, you need to opt into HTML5 for your YouTube account. To do that, go to youtube.com/html5 and click the “Join the HTML5 Trial” link at the bottom. Once you do, it should immediately opt you in and look like this:

Once you’re opted into the HTML5 trial (which I believe has been going on since 2011…), you’ll be using the HTML5 player by default for all of your YouTube viewing, and thus will have access to the new Settings functionality:

Summary

That’s it! All you need to do to be able to speed up your YouTube video viewing by 1.5 or 2x is join the YouTube HTML5 trial, and then select the speed you prefer from the settings dialog on the videos you watch. Note that you can also slow down videos to half- or quarter-speed as well, which can be interesting. You’ll thank me later for all the time you’ll save if you frequently watch screencast or lecture-style content on YouTube.

When Should You Arrive for an Interview

Wed, 20 Mar 2013 15:00:17 GMT

We’ve been doing a lot of interviewing as we grow our team in Hudson, Ohio for Telerik Services. We have a fairly small office in a suburban environment, where you can basically park right outside the building and walk right in – no elevators, reception area, parking decks, or other hassles you might find in a more urban location. As a result, we’ve learned that if we schedule an interview, we should be prepared for the candidate to arrive at least ten to fifteen minutes earlier than the allotted time. This is somewhat in contrast with what I learned was the “right” thing to do, which is to arrive 5 minutes early, so that you’re not interrupting whomever you’re meeting with by arriving any earlier. Now, it’s important to leave plenty of time in your travel plans to ensure that you can arrive 5 minutes early, but if I were to arrive 20 minutes ahead of the scheduled time, I would find somewhere to spend a few minutes before knocking on the door.

Since so many of the recent candidates for positions were arriving 15 or more minutes ahead of schedule, I thought I’d run a twitter survey to see if my own position was in line with current industry expectations. It turns out that most folks do, in fact, think that arriving earlier is the appropriate thing to do, with most of the respondents suggesting candidates arrive 10 minutes early, and the 2nd most suggesting 15. A couple even suggested arriving earlier than that.

Note that I specifically stated “arrive at the reception area” – not the parking lot – for this question. I understand that if you’re going to an urban environment or a large corporate campus you’ll want to leave plenty of time to get from your car to wherever your meetings are scheduled.

Of course, this isn’t a terribly scientific poll, but it does at least serve to demonstrate that our recent experience isn’t outside of current industry expected behavior. I’m not sure this information will change my own behavior when I’m the one visiting another office – I still think “on time is late, 5 minutes early is on time.” But it seems like, more and more, that wisdom is shifting earlier:

I wonder if the answers would be terribly different if I asked the same question, but about when to show up for a dinner invitation at an acquaintance’s home? In that case, is it better to be “fashionably late,” or at least, not to arrive 20 minutes early when the hosts are no doubt still preparing for the visit? Maybe that’s a poll for another day.

How To Contribute to ASPNET Yourself

Tue, 19 Feb 2013 00:21:39 GMT

Recently I upgraded the Stir Trek conference site’s web code from ASP.NET MVC 2 to 4. When I did, I ran into an issue where the [OutputCache] attribute’s behavior changed for RenderAction code. Specifically, if you had code like this:

[OutputCache(CacheProfile="Default")]

public ActionResult SponsorList()

    var context = new DataContext();

    var sponsors = context.Sponsors.GetAll().Where(s => s.Type.Amount > 0).OrderByDescending(x => x.Type.Amount).ToList();

    return this.View(sponsors);

it would stop working. You would get an error message like this:

Now, this error will make no sense to you if, like me, it used to work just fine in MVC 2, and you check your configuration file to ensure that you have, in fact, set the duration to a non-zero value:

Doing a bit of searching will turn up others who have encountered the issue, such as this Stackoverflow post:
http://stackoverflow.com/questions/4728958/caching-childactions-using-cache-profiles-wont-work

The bug in question here is that the error message is wrong. It should be this one:

The reason this doesn’t fire is that the code that checks for this performs the checks in the wrong order:

So now, we’ve discovered the issue. We’ve fixed our code (replace CacheProfile usage with this: [OutputCache(VaryByParam = "*", Duration = 10)]). Now how can we make this fix available for others? Well, it turns out that the ASP.NET team accepts pull requests. What that means, if you’re not familiar, is that you can contribute back to the project. The instructions for doing so are quite good – I just performed these steps today for the first time myself.

First, visit the ASPNETWebStack project on Codeplex. This is where all of the latest ASP.NET goodness is hosted. The source control is available in using git, and it’s pretty simple to grab the latest once you have Git installed (I recommend Git for Windows).

Next, if you’re looking for information on a particular feature request, issue, or bug, search for it in the Issue Tracker. In my case, the bug didn’t appear to exist previously, so I created a new issue describing the issue with the OutputCacheAttribute. ( Since I actually did the fix before I created the bug, I referenced the pull request in the bug, but you don’t need to do that).

Now, assuming you are interested in and able to fix the bug, the next step is to create your own fork. You can do this from the Source Code tab. Click on the Fork link:

Give the fork a name, and then clone it to your local machine. You can drag the folder with the resulting forked code into GitHub for Windows to start using GitHub for Windows to manage your commits, etc. Once you have the code, open it with Visual Studio. To run the tests, you will need to install SkipStrongNames and run it with –e (at an elevated/administrator prompt):

If you don’t do this, you won’t be able to run the unit tests. Speaking of which, you’ll probably also need to install the Moq and Xunit packages via Package Manager Console, at least for System.Web.Mvc.Test:

Once you have all of that, you should be able to successfully run tests (I’m using JustCode’s test runner, which supports xunit along with the other usual testing frameworks):

Once you have the bug fixed in your local build (with tests that prove it works – that’s how professional write code, you know), commit it (again, using git via command prompt or GitHub for windows) and then push/sync your changes back to your fork on CodePlex:

Click on Send Pull Request to submit your pull request to the team, and you’re done! Well, almost. Be sure to review everything on the Contributing section of the wiki, including this bit:

You’ll need to send in this license agreement, but once that’s done, you’ll be free to contribute your own pull requests to the aspnetwebstack on CodePlex. Thanks a bunch to Eilon Lipton for his assistance with this issue! This was actually my first pull request, believe it or not (though I’d submitted SVN patches to other projects in the past), and the process was overall pretty painless. Hopefully this will help others feel more confident about submitting fixes themselves, perhaps in addition to just answering questions about the bug on Stackoverflow…

Presenting at Telerik Software Pros Conference in New Delhi India

Sat, 12 Jan 2013 11:33:53 GMT

Today I gave two sessions at the Telerik Software Professionals Conference in New Delhi, India. The event is still ongoing (Chris Sells is wrapping up a great talk on building Windows 8 apps with HTML5 and JavaScript), but I wanted to get my talks posted here for attendees to download and review. I’ve loaded them on Slideshare, so you should be able to view them here, or navigate to Slideshare to get the slides themselves.

Presenting in New Delhi, India

Tue, 08 Jan 2013 16:51:51 GMT

This Saturday (12 January 2013), I’ll be presenting at the Telerik Developers’ Conference in New Delhi, India. The event kicks off at 9am – here’s the current plan for the agenda:

I’m giving two presentations in the afternoon. The abstracts are as follows:

Refactoring Applications using SOLID Principles

We’ve all heard about well-designed software projects, where things aren’t (yet) a big ball of mud that’s painful to work with, but many of us aren’t lucky enough to work on these. Nor is it an option for us to get to start a brand new “greenfield” project, where we can leave behind the legacy of spaghetti code and technical debt our current project might have.

But there is hope! By applying refactoring steps based on SOLID principles of object oriented design, we can reduce the technical debt of our existing application, improve our code quality, and hopefully make our application more enjoyable and productive to work with.

In this session, we’ll briefly introduce the SOLID principles and several design patterns, and then we’ll apply these principles and patterns by improving the design of an existing application through several refactoring steps.

Common ASP.NET Design Patterns

Design Patterns provide common templates for solving the same family of problems in a similar way. They also provide a higher-level language for software developers to use to describe approaches they might choose when designing a component of an application. In this session, you'll learn about several of the most common, and useful, design patterns used by ASP.NET developers today.

If you’re in the area, please register for the event, and I hope to see you there. This will be my first trip to India, and I’m excited and looking forward to it!

IntelliCommand and JustCode

Tue, 08 Jan 2013 14:43:33 GMT

I’ve been using JustCode regularly, lately, but I’m still learning some of the keyboard shortcuts and features (and probably always will be). JustCode features a nice view showing all of the common commands that you can access at any time (from the menu, or via ctrl+shift+alt+/):

And of course, you can also change these, or even jump to another common set of shortcuts, in the JustCode options:

Now, these are all nice features, but something new I learned about recently is a separate Visual Studio extension you can download from the Visual Studio extensions gallery:

The extension is called IntelliCommand, which you’ll find if you search Online within Visual Studio:

The extension is available for both VS2010 and 2012. I first learned about it from Denis Gladkikh’s blog post. When you combine IntelliCommand with JustCode, it can help you to discover and remember commands you’ve not used before (or for some time). For instance, since many of the shortcuts start with Ctrl, you can see the available commands as you press and hold Ctrl, Ctrl+Shift, and Ctrl+Shift+Alt, below:

Ctrl

Ctrl+Shift

Ctrl+Shift+Alt

Obviously, you can use Intelli Command to learn about all of the keyboard shortcuts you currently have set up within Visual Studio, not just JustCode. If you’re trying to determine an available combination to map to a new command, this is probably a much easier way to visualize what you currently have mapped than using the standard Visual Studio keyboard shortcut editor (which really, really needs a UI refresh). If you’re interested in playing with JustCode some more, you can download a free trial here.

Working with Ivy Bridge Ultrabook Sensors

Wed, 05 Dec 2012 04:18:47 GMT

I’ve had Intel’s preview Ivy Bridge Ultrabook for a little over two months now. It’s a preview device with a few pre-production quirks, but it’s also a powerful developer machine in a small, lightweight package, complete with a very responsive touch screen that works great with Windows 8. You can read my first impressions of the device, as well as my first follow-up review.

In this last write-up, I wanted to go a little bit deeper into the sensors that come with the device. As programmers, we can easily incorporate these sensors into our applications, especially Windows 8 apps. I’ve already described the variety of sensors the device supports. To get started with coding against these sensors, first, make sure you have the latest drivers for your machine. Especially right now, a lot of these devices are brand new and updates are happening frequently. Next, I recommend you grab the Windows 8 App Samples kit, which includes 145 different samples (not all relating to sensors, but still, that should keep you busy for a while).

Let’s take a look at a couple of these samples, and the code they provide. First, let’s take a look at the Accelerometer sensor sample code, which is pretty typical for all of the other sensors. First, we need to get an instance of the sensor, which we do by calling the GetDefault() method:

Next ,we can pull individual readings from the sensor, like so:

When run, the live sample looks like this (here I’ve tipped the laptop up on its left side):

You can see the X axis reading is showing almost –1, because of how I’ve tilted the laptop. When it’s at rest on a horizontal surface, the readings for X and Y are nearly zero, while the Z axis is –1. Essentially, when no external force apart from gravity is pulling on the device, gravity is what you’re detecting. When it’s resting flat, you can think of the X axis as starting at your caps lock key and proceeding toward your enter key, while Y is starting at the touchpad and proceeding toward your screen. Z is passing vertically through your keyboard. So, if you hold the laptop upside down, Z flips to positive 1. It would be interesting to see the readings this thing would have in a fighter jet…

As a bit of trivia for you physics buffs, what would the readings be if I tossed the laptop into the air, while it’s rising, while it’s at its peak, and while it’s falling, assuming it stays perfectly flat so we’re only concerned with the Z axis?

Related to the accelerometer is the inclinometer sensor, which you can read similarly (so similarly I’m not going to waste time showing you screenshots of the code). The main difference is that the resulting readings are Pitch, Roll, and Yaw. For these, you can pretend your laptop keyboard is an airplane, with its tail at the touchpad and nose by the screen. Lifting the tail results in negative pitch. Lifting either side results in a Roll change. Yaw is where things differ from the accelerometer, as this refers to rotation along the Z axis. That is, if you leave your laptop flat on the table, but turn it, that’s changing Yaw (read more on flight dynamics terms).

Here’s the app running with me picking up the right side of the laptop.

You can see how you could build games to take advantage of these sensors, especially in a tablet form factor.

There’s also a compass, which you access like the other sensors shown. Its event handler looks like this:

On this laptop, the “needle” of the compass seems to point out the right side of the keyboard, as that’s what I had to point north in order to get a 0 degree reading. When used in a tablet form factor, that probably makes the most sense (for it to come out of the top of the tablet).

The gyrometer provides similar readings of X, Y, and Z axis values based on angular velocity. At rest, these all read zero, but if you move the device, they’ll show you the instantaneous effects. The API is identical to the accelerometer and inclinometer APIs.

Working with the GeoLocator (GPS reader) is slightly different. You can simply instantiate one of these classes to start working with it. The code to pull the location data from the GeoLocator instance looks like this:

Finally, the LightSensor lets you detect ambient light. You access the sensor just as with most of the other sensors (like the accelerometer), and its event handler yields a single LUX value:

You can use this sample to locate the light sensor on your device, if you don’t know where it is (on this laptop, it’s by the integrated webcam at the top of the screen). If you cover the sensor, the reading drops to 0. The brightest I could get it to read from some indoor lighting (at night) was just over 20,000, but that was held right up to a light bulb. A “normal” reading as I use the laptop seems to be around 15-20, depending on whether there is direct light on the sensor.

Summary

As you can see, there’s a lot you can do with the sensors that ship in this device, and I’m sure other devices designed for use with Windows 8 will have many of these sensors as well. The code for detecting whether a sensor is present and available is of course included in these samples as well, since obviously not every device will support every sensor. You can read more on this topic from other bloggers like John Papa and Scott Hanselman. I hope you found this interesting, and if you have an ultrabook you recommend, please share it in the comments (I’m looking at the Lenovo Yoga, for instance, but I haven’t bought one yet). And feel free to debate the physics question I proposed, too.

Don’t Forget Block Selection Using Alt in Visual Studio

Sun, 18 Nov 2012 18:04:57 GMT

So do you ever find yourself wanting to try out some code you found on the Internet (via Copy Past Programming, but in a spike or test project, naturally!), and unfortunately when you copy the code it includes a bunch of line numbers? Like the code from this sample on testing Entity Framework stuff?

  1: [TestClass]
  2: public class TestRunDatabaseCreator {
  3:  4:   public const string DATABASE_NAME_TEMPLATE = "CPT_CDS_{0}";
  5:

Of course, some code highlighting tools make this a little easier for you, and Scott Hanselman shows off some options. But in this case, the post was made some time ago, so I don’t think we can rely on the author to change how they’ve chosen to post the code itself. There’s always the manual option, which I know I’ve done plenty of times. That is, type del del del del del downarrow, del del del del del downarrow, … repeat. That gets old fast – there should be a better way.

Fortunately, there is, and it’s been around for a long time. I was just reminded of it today, and thought I’d share for those of you who don’t know about it. Just use the block selection option in Visual Studio, which you get by holding down Alt while selecting with the mouse. Take some code like this:

Highlight with the mouse while holding alt:

And hit delete. Problem solved.

Share this if it helped you, and happy coding!

2013 Software Craftsmanship Calendar

Fri, 16 Nov 2012 18:45:12 GMT

It’s that time of year again when Software Craftsmanship wall calendars are shipping out of our Hudson office. A few things are different this year. The small NimblePros logo on the calendars has been replaced with a small Telerik logo. The boxes of calendars from the printer now come with 60 calendars per box, instead of 55. And the calendars themselves have an extra page in them (you’ll have to get one to see how we put it to use). We’ve also continued to be blown away by the popularity of the calendar, and we love that the community has supported this idea (which we’ve spent a great many hours obsessing over each year). Two years ago, for the first calendar (the 2011 calendar), we ordered 1500 calendars. Last year, in response to demand, we increased the order to 3000. This year, we’ve gone even further, and have printed 5000 calendars. That’s just over 83 boxes, at 38 pounds per box, which is over 1.5 tons of software craftsmanship awesomeness.

If this is all new to you, you can check out some of our past calendar images. If you have ideas for motivational images and themes we can use in future calendars, please leave a comment – we’re always looking for (and happy to credit) new ideas!

I think my favorite topic in the 2013 Software Craftsmanship calendar is Separation of Concerns. Separation of concerns is, of course, an extremely important principle in quality software development. It’s also one that is violated with alarming regularity. Whether there’s data access code inside of a click event handler, or any other low level plumbing logic embedded in code that is otherwise concerned with higher level concepts, this is something we should try to minimize in our software. We spent a lot of time thinking about how to best visualize this (we’ve tried to avoid just showing some random code snippet as the image wherever possible – who wants to look at that all month?). What we came up with is shown here (we’d just gotten a new, larger refrigerator at the office).

Everybody knows that you keep your cleaning supplies and your food separated in your kitchen, so this seems like an image that really works. It’s also visually interesting enough that even a non-developer walking by might do a double-take when they see what’s on the shelves in this refrigerator. What do you think, does this do a reasonable job of demonstrating a violation of separation of concerns, using a non-code metaphor? And yes, all of the cleaning tools were new, not used, when they were used as props for this shot.

You can order your 2013 Software Craftsmanship calendar now at http://gear.telerik.com. Thanks to all of you who have supported this idea the last two years! We really appreciate your support and hope you’ll continue to share this with your friends and let us know how we can continue to improve the calendar.

JavaScript The Good Parts Reviewed

Mon, 12 Nov 2012 16:13:01 GMT

Finished up Douglas Crockford’s JavaScript: The Good Parts this week. It definitely helped me improve my understanding of JavaScript, which I’ve been using since it was new, but always like a C programmer, and only recently like a JavaScript programmer. I really appreciated Crockford’s honest, no-holds-barred analysis of JavaScript’s design and language choices. It had me chuckling more than once. I also appreciated that the book, at only 150 pages including the index, is devoid of fluff. There’s just enough repetition between chapters to ensure certain points are made and made well.

The book makes frequent use of railroad diagrams, which I’ve seen before but not nearly so widely used as in this book. I found these sometimes helpful, but I’ll admit that I skipped the full 10 page appendix full of them when I’d reached the end of the book. I’m not sure they did a great deal to improve my grasp of JavaScript, but I appreciated the attention to detail, and I know I can refer to them if I’m stuck wondering why a particular bit of JavaScript isn’t behaving the way I would expect (which is probably the way it would in, say, C#).

The book isn’t that old (published in May, 2008), but it does predate some of the newer JavaScript testing tools available online. For instance, Chapter 1 suggests that the reader can easily run JavaScript programs by creating a simple HTML file, and a program.js file, and then opening the HTML file in a browser. This of course still works, and it’s important to let people know this option is available, but I think if the book were re-released today, it would be improved if it pointed the user at a tool like JSFiddle, where one can work interactively without the need to deal with files. For example, here’s Hello World implemented on JSFiddle (probably for the millionth time). It’s worth noting that JSFiddle also supports JSLint, which I believe Crockford wrote, and which is covered in the book as well.

I made a few notes as I read the book. I particularly liked on page 3, where Crockford writes, “If you want to learn more about the bad parts and how to use them badly, consult any other JavaScript book.” I think I may have discovered a bug in the p. 6 railroad diagram, which appears to include an unnecessary ‘/’ following the opening ‘/*’ of a comment. I don’t see it listed in the book’s errata, but since the only place go from the ‘/’ is into an ‘any character except * and /’ block it seems the diagram would work equally well without the ‘/’. I may be missing a nuance of the syntax, though.

Chapter 4 covers Functions, and includes some interesting bits on function currying (which was new to me) and memoization, with examples of how to use this in your JavaScript code. Chapter 9 discusses Style, and notes, “Surprisingly, perhaps, we should also avoid features that are often useful but occasionally hazardous. Such features are attractive nuisances, and by avoiding them, a large class of potential errors is avoided.” Page 95 goes on to say, “And even if style doesn’t matter, isn’t one style as good as any other?” which I believe is another typo not listed in the errata (doesn’t should be does). The points are well made, however, especially “It turns out that style matters in programming for the same reason that it matters in writing. It makes for better reading.”

One of JavaScript’s bad parts requires that one use the K&R style of curly bracing in order to avoid bugs with return statements. This is noted in the Style chapter, and covered in detail in my favorite part of the book: Appendix A: Awful Parts. Semicolon insertion is one such awful part, and is responsible for the aforementioned return statement bug. If you write

return
{
status: true
};

instead of
return {
status: true
};

The first version will return undefined, while the latter returns a new object with a status of true. I also thought it was interesting that you can actually redefine the global variables for undefined and NaN, as they are not, in fact, constants or reserved words. Crockford writes “That should not be possible, and yet it is. Don’t do it.” :)

There are many reasons why == is a Bad Part, explained in Appendix B: Bad Parts (along with a number of other Bad Parts). Despite the book’s name, I appreciate these appendices showing me which parts aren’t so good, and why. Finally, Appendix E is devoted to JSON, and includes a fully functional parse utility that avoids the need to use the (not so secure) eval() method.

Overall, very good book. I appear to have a later printing [2011-04-08] that includes some of the errata from the book’s web site. My JavaScript-fu still isn’t as good as my C#, but I have a much better appreciation for JavaScript now, and a much better understanding of how to use it properly. I’d definitely recommend this book if you’re a JavaScript programmer, or a C# programmer looking to get better at JavaScript.

Limit SQL Server Memory Use on Dev Machine

Wed, 07 Nov 2012 14:46:21 GMT

If you’re a developer running SQL Server locally, you may sometimes need to limit how much memory the database is consuming. Under normal conditions, SQL Server likes to use as much memory as it can get, since keeping results in memory improves the database’s performance. In typical production scenarios, this is the ideal behavior, but on a dev machine you probably want your RAM for other things. In my case, I noticed my RAM was creeping up to over 9.5 GB and saw this:

First of all, it’s somewhat telling that on my dev machine here, I’m not even running my dev environment, and my browser windows are collectively using more RAM than anything else (and what’s up with SnagitEditor.exe? It’s not even active at the moment). Clearly I need to spend more time working in Visual Studio and less time working in Outlook. But leaving that aside, and ignoring the fact that I still have loads of RAM free since this machine has 12GB, I’d still like to reduce the memory SQL Server is using since I’m not using that at all and if I don’t do something about it, it will just keep getting bigger until I restart.

Fortunately, it’s rather simple to fix. Just open SQL Server Management Studio, connect to your server (localhost in this case), and right click on the server in the server explorer. Choose Properties. Then choose the Memory section, shown here:

Change that big number (2,147,483,647 MB ~= 2 Petabytes) to something more reasonable. In my case, I’m already using about 577MB, but 100 MB is probably more than enough for my dev needs.

If this doesn’t work for you, there are some additional tips and things to try on this StackOverflow question.

JustCode JustRocks

Mon, 29 Oct 2012 16:53:43 GMT

I have been a ReSharper fanboy for a long, long time. I have recommended it in user group and conference talks and on my blog. It was one of my favorite tools for a long time, and it remains a great product. However, I’m happy to say with all honesty that I now prefer JustCode. This is fortunate, as I now work for the company that makes JustCode, but I’ve held off on endorsing it (or completely replacing ReSharper in my actual work) until I felt it really met my needs. That day has come. Let me share with you why I’m now a convert.

Must-Have Refactorings

There are a few refactorings that I use all the time because of the way I write testable, maintainable code (see my online programming course on SOLID Principles of Object Oriented Design). For instance, I try to follow the Explicit Dependencies Principle, which means that my classes take in the things they need via their constructors (or method parameters). When you’re writing code like this, it’s common to create a constructor, add several parameters (usually interface types), and then assign each parameter to a private readonly field of the same type. You end up with something like this:

Strategy Pattern

We’re essentially talking about the Strategy Pattern, or Dependency Injection here, and doing a lot of this is very tedious. The name of the operation in JustCode is Create and Initialize Field. Fortunately, with JustCode, you can now just type “ctor TAB TAB” (using Visual Studio’s code snippet), add a parameter (e.g. ISendEmail mailSender), then bring up the Visual Aid Menu (I map this to Alt+Enter, which is R#’s default – JustCode uses ctrl+` by default which is nowhere near the keys I normally have my fingers on – fortunately you only need to change this once since your settings persist between computers as I’ll detail shortly), and select the first item, Create and Initialize Field ‘_mailSender’ by pressing Enter:

The whole thing takes very few keystrokes and doesn’t require the mouse, which of course is key to frictionless coding. Essentially for me it’s:

ctor TAB TAB typename variablename alt+Enter Enter

Of course if the type already exists you can tab complete it rather than typing the whole thing.

Dealing with Files

Frequently when you’re working test-first or in a way that minimizes dependencies, you’ll end up with a solution that involves a lot of small classes with well-defined responsibilities and interfaces. Using the typical Visual Studio approach to creating these files and classes is tedious – it’s much nicer to simply create the interface and class definitions in whatever file happens to be open, and then move them using JustCode shortcuts. For example, in this screenshot you can see that I’ve defined the interface in the same file as the class, so it’s underlined (because by default it’s recommended to have types in separate files). Mousing over, you’ll see warning:

Clicking there and then hitting alt+Enter Enter will move the interface into its own file.

Result:

Of course, you can also make sure filenames match your typenames. Any time a typename doesn’t match the current filename, you’ll get a warning and a suggestion to either Move Type To Another File or Rename File To Match Type Name.

Clean Up

Of course I’m a fan of Clean Code, so being able to quickly and easily clean up code is very helpful. I especially like to remove clutter, so unused using directives and other redundant bits of code I like to eliminate wherever possible, so they don’t obscure the intent of the actual code doing the work. JustCode supports a bunch of options for cleaning up and formatting code, and you can save your personal preferences in a profile. Here are some of the options available:

One nice feature of JustCode is that you don’t have to do this in each file. You can do it at the project or solution level:

Navigation

When you write code such that it’s loosely coupled and testable (e.g. follows SOLID principles), you tend to have a lot more types than in a tightly coupled big-ball-of-mud solution. You also tend to have a lot more instances where your code is executing functionality through an interface, rather than through an explicit implementation. This makes the default navigation features of Visual Studio insufficient, or at least annoying. Very commonly as a developer you will want to find a particular type, or a particular file, or jump to the actual implementation of a method being called. Justcode makes all of these very easy.

Find Type / File

To find a type, just use the default keyboard shortcut. Since I’m a former R# user, I have ctrl+N and ctrl+shift+N embedded in my brain as Find Type and Find File. If you type in capital letters, it will quickly find camel-cased types that match (e.g. “ISE” will find “ISendEmail” as shown).

You can do the same with files, searching for camel-case or for substrings:

This is much, much faster than hunting through Solution Explorer looking for a particular class that you think might be implementing the interface you’re using. Speaking of which, let’s look at how we navigate through a call stack. Using only Visual Studio, if you want to find out what the implementation of Send() does in this code, you can do so by ctrl+Clicking on it.

Of course, ctrl+Click will lead you here:

This isn’t all that helpful in most cases. Fortunately, JustCode will easily let you Go To Implementation of the interface method (and again these are using the default R# key bindings):

This leads you here:

which is probably where you wanted to go to see what the code is actually doing.

Speed

One issue I had with some of the early versions of JustCode was with its speed. The latest version is very fast, and I no longer have any complaints. I’m certainly not finding that I’m waiting on it, which occasionally was the case in the past.

Cloud Sync

Most of the features I’ve described above already exist in ReSharper – in fact that’s where I fell in love with most of them. Now let’s look at some of the new and awesome features that JustCode has added that make it stand apart from its competitors. Chief among these, to me, is the ability to synchronize settings in the cloud. Those of you who know me through Microsoft MVP or ASPInsiders program may know that I have been lobbying Microsoft to provide a way to store and sync Visual Studio’s settings in the cloud since around 2003. And here it is 2012 and there’s still no support for it. About the best you can do is export/import your settings and sync them via DropBox or similar, which isn’t awful, but it’s enough extra friction that I’ve never fallen in love with this solution. What I want is for VS to “just work” the way I want it to when I sign into a new machine on my domain, or when I do a new install. JustCode now solves this problem.

In a previous release, JustCode provided a means to sync its own settings in the cloud, including all of the code templates and whatever preferences you had set up for formatting, cleaning, etc. However, in the most recent release, JustCode now will sync all Visual Studio settings, which is far more useful as it includes key bindings and other environment changes (e.g. turning on line numbers in the editors). I’m composing this article on a newly-installed Win8 machine, and I’m pleased to say I didn’t have to adjust any of my Visual Studio settings in order to get things set up how I like it. I simply installed JustCode, provided my Telerik credentials, and it does the rest. You can upload or download changes on-demand, as well as enabling automatic sync, as shown here:

Of course, if you don’t want to sync everything, you can choose a subset. And if you don’t trust automatic sync, you can choose to only upload/download on demand. You can also back up a given configuration, and then restore it later, allowing you to try something out and then easily revert. This can also be useful for presenters, who maybe use a black background and small fonts on their desktop, but want to use a white background and large fonts when presenting. JustCode accommodates this via its Cloud Backups.

This has literally been something I’ve wanted for almost ten years as a Visual Studio user, and it’s already making my life much easier, as I use quite a few different machines in my work. I was very excited to learn about, and now to use, this feature, and it works great. For more on this, read about how to Save Your Visual Studio Settings in the Cloud.

Keymaps

Another thing I’ve struggled with when I would try and evaluate competing tools (when I used R#) is relearning the keymaps of the various tools on the market. It was always tedious to reset key binding in Visual Studio’s settings, and of course you would have to do this on every machine you used, or every time you reinstalled your tools. It was a big barrier to switching, and of course this is a good thing for ReSharper (and other tools) if it provides some vendor lock-in. But for an individual developer who wants to be able to use, or at least evaluate, other tools, it was a problem. Fortunately, JustCode has a solution to this as well. You can simply choose one of the default keymaps that already has all of the mappings you’re familiar with. In my case, I went with the R#/IDEA keymap, as shown:

This dialog appears as part of the Getting Started wizard when you first install JustCode, making it very easy to evaluate JustCode using the key bindings you already have committed to memory. The JustCode team also has an article describing how they came up with the JustCode Keyboard Shortcuts Profiles feature that you may want to check out.

Summary

I’ve waited a long time to be able to write this article. When I joined Telerik earlier this year, I still wasn’t completely convinced that JustCode was really a tool I could recommend over my old friend ReSharper. I’m very pleased, as a Telerik employee, to be able to confidently endorse it now. If you’ve tried it before and found it lacking, I would encourage you to give it another shot. If you’re not using any Visual Studio add-in, and you’re trying to write loosely coupled, testable code, JustCode will eliminate a ton of the friction involved in doing so. You can download a JustCode Trial here, if you’d like.

And since it’s almost election time here in the United States, let me end with “I’m Steve Smith, and I approve this message.”

The Ivy Bridge Ultrabook Continued

Fri, 19 Oct 2012 19:16:50 GMT

I’ve now had the new Intel Ivy Bridge Ultrabook machine for about six weeks, and have been carrying it as my primary machine for much of that time. You can read about my initial impressions of the Ultrabook here. The short version, for those who don’t like to click on links, is that this is a pre-release hardware clamshell Ultrabook with a touch screen and a slew of sensors that you can code against, with Windows 8 installed on it. It was provided to me for free in order to solicit my honest opinions on the device, which I disclose to you here in accordance with the Federal Trade Commission’s 16 CFR, Part 255: “Guides Concerning the Use of Endorsements and Testimonials in Advertising.

General Use

I’m an Ultrabook fan, having used “desktop replacement” laptops in the past, with their 17” screens and dual-stacked hard drives and massive power supplies and fans. Really, though, since I’m not playing games on the machine, I don’t need a huge video card, and since most of the performance of Visual Studio and Office is dictated by RAM and HDD, having an SSD makes the performance of thin, light laptops more than adequate for my needs. Sure, I have a big tower computer with two big monitors on my desk, but when I’m not at my desk, I’m quite content to use an Ultrabook.

This particular Ultrabook is quite nice. I actually find the keyboard to be much nicer than my Asus Zen, which tends to miss characters when I’m typing quickly, and the touchpad is rather sensitive so sometimes that results in the mouse pointer jumping. In contrast, the Intel Ultrabook is quick to type on and doesn’t frequently require me to retype due to its failings (though I still have my own mistakes to deal with, all too often). I would prefer if it had actual home/end buttons, instead of overloads on the arrow keys, but that’s a minor quibble.

In terms of presenting, the lack of a VGA outlet can be a concern, especially if you’re presenting at customer or conference locations. Even HDMI is a slight challenge because the port on the machine is a mini-HDMI, so you need an adapter or your own cable. I picked up an A to C Type HDMI to Mini-HDMI Cable for this purpose. If you want VGA, you can pick up a Mini HDMI to VGA M/F Active Adapter.

I continue to find it very natural to use the touch screen, rather than the touchpad or mouse. When reading long articles/emails, it’s often easier to simply scroll the screen with a thumb or finger, especially when no mouse is available (to use the scroll wheel).

Development

Visual Studio 2012 runs great on the device. As has been mentioned, it only has 4 GB of RAM, but honestly I haven’t found that to be a problem. I think VS2012 is, in general, faster and more lightweight than its predecessor, and so even if I’m running more than one instance of Visual Studio, I haven’t noticed any slowdown. Now, to be fair I’m mostly running smaller solutions, not massive solutions with 100 projects in them, but if your solution has that many projects I think you have bigger problems than your machine’s memory resources can address.

Scott wrote up some nice stuff on the Windows 8 SDK and the sensors in the machine. The SDK actually does make working with the sensors pretty straightforward. The Geolocation Sample Scott references is very easy to just download and run on a Win8 machine, and lets you easily play with the GPS. Other sensors are also easily accessed via the SDK:

Apps

Of course, the Ultrabook’s running Windows 8, so in addition to all the usual desktop/dev stuff, there’s the Windows Store and all that it holds. I’m not using a ton of apps yet, but I’ve played with a few. MetroTwit is OK, though I think I prefer HootSuite still. The Weather app continues to be a favorite of mine. Mail is OK, but Outlook is still way better (or Google Apps), IMHO. The Win8 eBay app is actually very nice, so I would encourage you to check it out. And the new Microsoft Solitaire Collection is pretty cool; my 10yo daughter really enjoyed playing a bunch of those games (as did I).

Summary

So far I don’t have much negative to report on the machine. I use it for email and some software development, though it’s not my main dev machine. I’ve used it for presenting. It’s light, fast, and fun to use and hasn’t let me down yet for any of these activities. The touch screen combined with Windows 8 is nice, especially when you’re lying down or in a cramped space (flying economy, for instance). And I suspect the small things that would improve it (more RAM, more compact power supply) will be there when production models ship.

Do you have questions I can answer about the machine? Post them here and I'll try to answer them.

A Review of The Clean Coder

Thu, 11 Oct 2012 18:04:19 GMT

I’m generally a fan of Robert C. “Uncle Bob” Martin’s books, so realize I’m going into this book with something of a positive bias. While is previous books, Agile Principles, Patterns and Practices in C# and Clean Code, have been specifically about programming techniques, this latest title, The Clean Coder, is more philosophical in nature. It seeks to present Martin’s philosophy of how software developers should behave: responsibly, professionally, and with the will to say no when required. The book consists of a number of stories, relating experiences from Martin’s programming career that spans four decades, and is obviously autobiographical in nature. The stories are always interesting, to me at least, though not always completely relevant to the point being made. Nonetheless, I found the book to be enjoyable and worthwhile. While his other books frequently illuminated areas of programming or design that I hadn’t known or hadn’t put a name to, this one largely described a philosophy to which I already subscribe, and thus held few surprises. However, it also made me think about my own career, and moments and experiences I’ve had, and I think most readers will share this kind of healthy reflection on the choices they’ve made.

I definitely would recommend it, especially to developers who are just starting out in their careers.