I originally created hackification.com as an addon domain and WordPress installation to an existing cpanel account, which was hosting a different site. The original domain was coming up for renewal, and I decided to let it expire, since it wasn’t really doing anything much.

Unfortunately I’ve since found out that cpanel really doesn’t like having its primary domain changed – Fantastico basically stopped working correctly and would leave me with files with permissions set to ’0000′ – unmodifiable by me.

In the end I decided just to start again: I asked my hosting company to completely trash and recreate my hosting. I’ve now restored from backups, which is a bit of a hassle:

1. Recreate the WordPress installation as closely as possible;
2. Import a previously exported WordPress XML file (which restores all the posts and comments);
3. Restore my “uploads” directory (which contains all the images referenced in my posts);
4. Restore various downloads directories (which contain various assets and demos);
5. Restore the custom theme I designed (the blue/orange one you can hopefully see);
6. Finally, try to remember my various WordPress and WordPress plug-in settings (particularly Akismet, since as soon as the blog went live the spam started appearing).

If I had to provide advice, it would be:

• Backup everything, in various ways (eg WordPress export, plus entire directory dumps, plus even screenshots of settings);
• If you’re planning to use a single cpanel to host multiple domains, make sure the primary domain is one you want to keep forever – it could even be a cheap-as-possible domain that no-one but you ever sees.

I was also very lucky with my hosting company, webhosting.uk.com: I’m not paying very much (£60 per year), but they were very quick getting me back up and running, and provide good service in the evenings (which is the only time I get to work on my blog), so thanks guys.

As coincidence would have it, I noticed a SitePoint article regarding WordPress backups: Keep Your Blog Safe: Back Up Your WordPress Installation. Hopefully that might be of use to anyone else with a cpanel blog to manage.

Thanks to the very helpful people at webhosting.uk.com I now have a fresh cpanel installation.

I’m currently restoring from backups… hopefully the site will be back up soon.

Looking through some of the submissions on the site, I was struck by how… well… random most of them are. Without meaning to be rude, they just look like someone went through the list, randomly assigning colors. Many many programmers believe coding and graphic design are polar opposites – that if you’re a coder, you must necessarily suffer from “programmer art”, and hence that it’s pointless to ever try to learn better design skills. I completely disagree with this diagnosis.

I’m going to use only one design rule for this color scheme – consistency: keep similar things similar, and make different things different.

Basics

I’ve already decided to create a “dark” theme, so the background will be black. I also want to highlight important or dangerous elements of the source, and downplay incidental aspects. This idea will modify each of the colors chosen, and help suggest colors where there is no clear choice. Each choice will be reflected as far as is possible across many file types – for example, a C# comment should probably be the same color as an XML one, a JavaScript one, etc.

I’m also going to make use of color shades. I know Visual Studio has to cater for people using low-color displays, remote desktop, and those with reduced vision, but its use of primary colors leaves it looking a little dated. Color shades can be used to bring the look a little more up-to-date, and to group related elements, while still being able to distinguish between them.

Comments – Green

Comments have always been green in Visual Studio, and I’m going to keep them that way – a vibrant green, made bold, to catch the eye. (If comments aren’t important, then why are you writing them?) Comment hyperlinks and the text in #region blocks also match.

Literals – Blue

String literals are red in the standard Visual Studio color scheme, but I wanted to reserve that color for errors and the like. In my mind strings are blue (don’t ask me why) so I’ve chosen a light blue for strings.

With consistency in mind, what else should match this?

• String literals are blue, so why not other literals, such as integers? The common color will highlight “magic values” in code.
• We’ll need to colorize XML and HTML, so we can make attribute values blue too.
• JavaScript and SQL obviously have literals.
• I’ve also chosen to see CSS values as literals – they go blue too. (You could easily argue the toss about that though).

Keywords – Gray

Since the background is black, ‘unadorned’ text will be white – a nice easy choice. How about keywords?

I want to make them a different color – so I can tell when I’ve typed ‘retrun’ for the billionth time – but I don’t consider them to be “core” code. I think of them as scaffolding around my identifiers. (Perhaps I’m a LISPer at heart). I’ve chosen to keep them a neutral color, but a dimmer shade, so they fade out – hence gray.

Types – Yellow/Orange

Colorizing types is handy as it again allows me to see when I’ve mis-typed something. I want them to stand out (so a dim color is out), and I don’t want them confused with anything else – so reds, greens, and blues are gone. Yellows and light oranges seem a good choice – close enough to the normal white text, but sufficiently different to catch the eye. I’ve chosen a light orange for types, and highlighted interface types as yellow. (I figure that looking at how interfaces are defined and used is often a good way to understand the structure of a body of code – hence the slightly more eye-catching color).

(Oddly enough, this doesn’t seem to work for types in C++ – they always seem to come out white. Not sure why.)

Errors, Warnings, and Oddities – Red

This was an easy color to choose – red (for me) means stop and think. There are a few code constructs that I wanted to highlight as either dangerous or needing attention:

• Compiler errors and warnings;
• Preprocessor directives;
• Breakpoints.

Editor Overlays – Purple/Dark Blue

Visual Studio now highlights parts of the source depending on where youyr cursor is – it highlights matching braces, and will also display all usages of the symbol at the caret. These display can change rapidly, so shouldn’t be too distracting. I’ve chosen a dark purple, which is subtly visible, but which blends in with the black background.

We need a related color for the selection too, so I’ve chosen dark blue.

Omissions

There’s still quite a few entries in the colors list I haven’t filled out – the main areas being:

• VB.NET;
• XSLT
• IntelliTrace
• Test Coverage

If you fancy addressing these omissions and sending me back an updated settings file, I’ll be happy to credit you.

Conclusion & Download

So there you go. Obviously color schemes are very personal (and contentious). I think I’ve done a pretty good job; you might well think otherwise. Even if you don’t like this particular scheme, I hope you’ll agree that setting a few design principles in place before assigning colors can help you choose (and use) the colors effectively.

Sadly there’s no way to upload my settings to StudioStyles, and I’m too lazy to re-do all the work by hand. Until they allow that option, I’ll host the settings from here:

Download hackification.vssettings

Save this file somewhere, then use Tools -> Import and Export Settings… to merge them in.

Top 25 Most Dangerous Programming Mistakes

http://www.codinghorror.com/blog/2009/01/top-25-most-dangerous-programming-mistakes.html

Summary article listing the 25 most dangerous (in terms of security impact) programming mistakes. Even if you’re aware of all of these, it’s worth re-familiarizing yourself (and your co-workers) with them.

Microsoft runs fuzzing botnet, finds 1,800 Office bugs

http://www.computerworld.com/s/article/9174539/Microsoft_runs_fuzzing_botnet_finds_1_800_Office_bugs

No, not that sort of botnet. Microsoft are using a distributed computer system to generate random changes to Office files, in an attempt to discover buffer overruns and other vulnerabilities in the file format parser.

Much ado about NULL: An introduction to virtual memory

http://blog.ksplice.com/2010/03/null-pointers-part-i/

Down-to-the-metal article explaining pointers, memory mapping, and virtual memory. Worth reading as it covers the basics that we rarely think about.

Amazing feats of Clang Error Recovery

http://blog.llvm.org/2010/04/amazing-feats-of-clang-error-recovery.html

Clang is the new up-and-coming C/C++ open-source compiler. If you’ve ever worked with C++, you’ll know how cryptic and downright useless the error messages emitted by most compilers are. Clang is attempting to address that weakness.

Good Math, Bad Pointer Math / C Is Not Assembly

http://james-iry.blogspot.com/2010/04/good-math-bad-pointer-math.html
http://james-iry.blogspot.com/2010/04/c-is-not-assembly.html

A deep-dive into the intricacies of C pointers, and how they relate to the C standard. If you’re interested in writing portable and correct C code, this is worth a read.

Underscore.js

http://documentcloud.github.com/underscore/

Not so much an article as a useful download – Underscore.js (named after the identifier used to access the functions) provides a suite of functional programming constructs for JavaScript.

What’s wrong with extending the DOM

http://perfectionkills.com/whats-wrong-with-extending-the-dom/

JavaScript allows any objects to be extended, either on a per-object or per-type basis. The popular Prototype library used this mechanism – and subsequently found it to be a bad idea. Prototype 2.0 is moving away from  this technique – read this article for a clear explanation why.

The ASP.NET Web Development Horror

http://www.codingthewheel.com/archives/asp-net-web-development-horror

I’ve recently started (belatedly) playing with ASP.NET MVC 2, and it’s a breath of fresh air compared to “classic” ASP.NET. (Presumably “classic” ASP is now “classic classic ASP”). If you’ve not been able to articulate why ASP.NET wasn’t up to scratch, this well-written and funny article will help. How can you not read an article containing the phrase “tricksy little hobbits doing obscene things in the cupboards”?

Use C# dynamic typing to conveniently access internals of an object

http://igoro.com/archive/use-c-dynamic-typing-to-conveniently-access-internals-of-an-object/

I’ve linked to Igor’s blog before – the articles are clear, well-written, and well-laid-out. This article suggests a new use for one of .NET 4.0′s new features, dynamic types.

A Brief, Incomplete, and Mostly Wrong History of Programming Languages

http://www.cvaieee.org/html/humor/programming_history.html

I like to end on a light note, so here’s a couple of funnies. If you’ve ever wondered about this history of various programming languages, this article is completely incorrect.

First among SQLs

http://www.theregister.co.uk/2010/04/20/verity_stob_sql/

If you’re ever bored at work, you can do far worse that read Verity Stob’s collection of articles. They’re tongue-in-cheek, deadpan, and scarily accurate.

Microsoft turns 35: Best, worst and most notable moments

http://www.computerworld.com/s/article/print/9173238/Microsoft_turns_35_Best_worst_and_most_notable_moments

An interesting look back at Microsoft’s history. Love ‘em or hate ‘em, you have to acknowledge the mark they’ve made on the IT industry. You’ll almost certainly know everything in this article, but it’s a nice summary all the same.

Windows Phone 7 Series: the complete guide

http://www.engadget.com/2010/03/18/windows-phone-7-series-the-complete-guide/

The details of Microsoft’s upcoming mobile OS were released recently, and this is a nice summary article. The graphical appearance of the OS looks very fresh and modern – could Microsoft have turned a corner, design-wise?

Building a Windows Phone 7 Twitter Application using Silverlight

http://weblogs.asp.net/scottgu/archive/2010/03/18/building-a-windows-phone-7-twitter-application-using-silverlight.aspx

Given the familiarity of the coding environment for Windows Phone 7, I could be tempted to wish for one, instead of wishing for an iPhone.

Programming Windows Phone 7 Series

http://www.charlespetzold.com/phone/

If like me you like to read an old-fashioned book in the bath instead of reading articles on-line, Charles Petzold is preparing one. Here’s a sneaky preview in PDF format.

New, But Not So Obvious, Features in .NET 4.0

http://galilyou.blogspot.com/2010/03/new-but-not-so-obvious-features-in-net.html

.NET 4 is with us, and there are plenty of new, headline features. Here’s a few that barely get a footnote – but which are interesting nonetheless.

Hello from a libc-free world! (Part 1)

http://blog.ksplice.com/2010/03/libc-free-world/

Why would a single-line program produce a larger-than-expected executable? Where does that excess baggage come from? And if you wanted to ditch the standard core libraries, how would you go about it?

Visualizing Usage of the Firefox Menu Bar

http://blog.mozilla.com/faaborg/2010/03/23/visualizing-usage-of-the-firefox-menu-bar/

Interviews with Average Programmers

http://blogs.citytechinc.com/sanderson/?p=290

I’ve been reading “Coders at Work” recently, a collection of interviews with great programmers. What would an interview with a coder like you or me be like?

5 Stages of Programmer Incompetence

http://coderoom.wordpress.com/2010/03/19/5-stages-of-programmer-incompetence/

Tongue-in-cheek article (mostly) about how we progress in the craft of coding. I can recognise aspects of myself in all of these.

A Few Billion Lines of Code Later: Using Static Analysis to Find Bugs in the Real World

http://cacm.acm.org/magazines/2010/2/69354-a-few-billion-lines-of-code-later/fulltext

This article is kind of an advert for Coverity, but it’s interesting all the same. It’s partly about their static code-analysis tool, but mainly about the social aspects of selling the software.

A Big Case of …OOPS…

http://www.communities.hp.com/securitysoftware/blogs/rafal/archive/2010/02/25/a-big-case-of-oops.aspx

Is defense against SQL injection attacks important? Absolutely, but for a middle manager it’s probably an academic issue… until you see your site has been hacked, right in front of your eyes.

Hg Init: a Mercurial tutorial

http://hginit.com/

Joel Spolsky might have stopped blogging, but he’s still writing other kinds of articles. This is an excellent introduction to Mercurial, a distributed version-tracking system. OK, so you might be stuck using Visual SourceSafe at work, but a coder can dream.

Processing.js

http://processingjs.org/

I’ve always fancied playing with Processing, the Java-based graphical environment, but the Java aspect always put me off. This is a JavaScript version, so anyone can view your creations.

Home-baked graphics

http://bit-player.org/2010/home-baked-graphics

In these days of pre-packaged charting libraries, it’s refreshing to see someone getting down to the metal (LISP and PostScript, in this case) to generate custom graphs. Why does the author bother? And where to go from there? Read for a discussion.

Prefer Futures to Baked-In “Async APIs”

http://www.drdobbs.com/go-parallel/article/showArticle.jhtml?articleID=222301165

Very useful, very specific, and practical article about a better technique for writing APIs that expose concurrency. Recommended reading despite Dr Dobb’s in-your-face adverts and pagination.

Comet with node.js and V8

http://amix.dk/blog/post/19484

A presentation (slideshow, no audio or video) on node.js, a JavaScript web-server running on Google’s V8 engine. Very interesting concept – using an event-based system vastly simplifies the code needed to serve data. There’s plenty of discussion about node.js on the interwebs at the moment – hopefully it will grow and become more than just a curiosity.

Gallery of Processor Cache Effects

http://igoro.com/archive/gallery-of-processor-cache-effects/

Interesting blog post about the effects that processor caches may have on performance. Examples are in C#, but really apply to any language.

Microsoft’s Creative Destruction

http://www.nytimes.com/2010/02/04/opinion/04brass.html?pagewanted=1&ref=opinion

Opinion piece from the NYTimes regarding Microsoft’s recent lack of innovation (at least, in the area of shiny gadgets). Written by an ex-vice-president of Microsoft.

How Many Passes?

http://blogs.msdn.com/ericlippert/archive/2010/02/04/how-many-passes.aspx

Summary article from Eric Lippert describing the differences between the C# compiler and a “traditional” compiler, and listing the various passes made over the symbol tree.

A Deadlock Holiday

http://www.theregister.co.uk/2009/12/10/verity_stob/

Very funny tongue-in-cheek article about the current state of parallel / multicore coding techniques, from Verity Stob of The Register.

A Maturity Model for Source Control

http://lucas-ward.blogspot.com/2010/02/maturity-model-for-source-control-scmm.html

Semi-opinion piece assigning levels to types of source-control systems – from “No SCM” through “Clunky” to “Speedy, Invisible, and Highly Capable”.

Luckily, that is now changing with the recent release of .less (Dot Less). This is a port of the Ruby LESS library to .NET. It’s still in beta, so be warned that the API is still in a certain amount of flux. (That’s a good thing however – I’d rather have a bit of pain in the beta stage, in return for a well-thought-out API later on). The authors are very responsive – there’s a friendly discussion group – and the couple of bugs I’ve reported have been fixed within a very short time frame. This project seems to be in very active development, and I’m extremely impressed with it. It’s so simple to use, and gives CSS development a much-needed shot in the arm, that using this library seems a no-brainer decision to me.

So what benefits does this library give you? (Examples are taken from the .less homepage).

1. Minification

The final output from .less is a compacted (or minified) version. This means you can write your CSS with as many comments and whitespace as you like, without worrying that the client-side download will be huge. This might seem like a “meh” feature, but it’s free and will have immediate beneficial effects on your bandwidth.

2. Variables

CSS doesn’t support any form of variables or macros, so constants (the worst culprit being colours) get copied around the CSS file. That’s fine until you decide that the pink-on-orange colour scheme isn’t working, and you need to make a change. .less allows you to define variables using the syntax “@name: value”, and then reference them anywhere a value would otherwise be used.

Example:

@brand_color: #4D926F;

#header {
  color: @brand_color;
}

h2 {
  color: @brand_color;
}

3. Mixins

We’re now in a second round of “browser wars”, with modern browsers providing useful features such as border-radius via non-standard extensions. We also have to cope with Internet Explorer still making use of odd syntax for features such as opacity (via filter). The upshot of this is that to define certain CSS effects, we have to provide three or four CSS style properties, to cover various browsers. Mixins allow this bloat to be ameliorated by defining a class with the desired properties, and then “mixing” them into another class.

Example:

.rounded_corners {
  -moz-border-radius: 8px;
  -webkit-border-radius: 8px;
  border-radius: 8px;
}

#header {
  .rounded_corners;
}

#footer {
  .rounded_corners;
}

4. Nested Rules

This feature is probably of least interest to me, since I favour single-line rule formatting, however if you write multi-line rules, then this could be a very useful feature. Nested rules allow “inheritance” of CSS rules, such that more specific rules may be nested within a less-specific parent rule.

Example:

#header {
  color: red;
  a {
       font-weight: bold;
       text-decoration: none;
    }
}

I could possibly see myself using it for :hover rules and the like.

5. Operations

Since I’m merging .less into an existing codebase, I haven’t yet refactored my CSS to make use of this feature. Operations allow arithmetic to be performed on expressions involving variables. For example, instead of defining variables for a colour and its lighter equivalent, you can instead just define a variable for the colour, and then computer the lighter colour.

Example:

@the-border: 1px;
@base-color: #111;

#header {
  color: @base-color * 3;
  border-left: @the-border;
  border-right: @the-border * 2;
}

#footer {
  color: (@base-color + #111) * 1.5;
}

Alternative Usage

The homepage gives instructions for a quick-up-and-running scenario, however I already had code to handle caching and combining of stylesheets, so I wanted to hook into that. It’s easily possible to process CSS as strings if desired:

// .less format CSS as string in 'input'.
var dotLessEngine = new dotless.Core.engine.ExtensibleEngineImpl( input );

// Transformed CSS now in 'css'.
var css = dotLessEngine.Css;

// Now minify...
var dotlessMinifier = new dotless.Core.minifier.Processor( css );

// Output CSS suitable for sending to client in 'output'.
var output = new string( dotlessMinifier.Output );

Smart, and Gets Things Done

Joel Spolsky’s 2006 article “The Guerrilla Guide to Interviewing” is a real classic that’s since been made into a book. He argues that there are two things to look for when interviewing, and that a candidate needs to have both attributes – having just one is as bad as having neither.

“Everybody gives lip service to the idea that people are the most important part of a software project, but nobody is quite sure what you can do about it. The very first thing you have to do right if you want to have good programmers is to hire the right programmers, and that means you have to be able to figure out who the right programmers are, and this is usually done in the interview process.”

Read Joel’s Article: The Guerrilla Guide to Interviewing (version 3.0)

Done, and Gets Things Smart

Steve Yegge’s 2008 response article reminds us that recognising smarts (in ourselves and others) isn’t even necessarily possible. He suggests that the best approach to hiring is finding “seed” employees (although obviously being able to identify them is a Catch-22 situation). To find them you either need to be lucky, or perhaps home in on them via word of mouth.

“How do you hire someone who’s smarter than you? How do you tell if someone’s smarter than you? This is a problem I’ve thought about, over nearly twenty years of interviewing, and it appears that the answer is: you can’t. You just have to get lucky.”

Read Steve’s Article: Done, and Gets Things Smart

Let’s suppose we want to represent an arithmetic operation on two numbers – such as plus, minus, multiply, etc. We could represent that operation as an enum (although to be clear – I don’t think you should):

enum ArithmeticOperation
{
  Add,
  Subtract,
  Multiply,
  Divide
}

We could then define a function to apply this operation to two numbers (highlighting will be explained later):

int ApplyOperation(ArithmeticOperation op, int x, int y)
{
  switch(op)
  {
    case ArithmeticOperation.Add: return x + y;
    case ArithmeticOperation.Subtract: return x - y;
    case ArithmeticOperation.Multiply: return x * y;
    case ArithmeticOperation.Divide: return x / y;
    default: throw new InvalidOperationException();
  }
}

That’s… sort of fine – but what happens when we want to extend it?

Adding Operators: No Compile-Time Checking

Let’s consider what happens if we want to add another operator – say exponentiation. If we add the enum value but forget to implement the switch case value, everything compiles fine. It’s only once we come to run the code, and actually hit that code path, that we discover the mistake, giving a run-time exception.

Adding Methods: Bad Code Organisation

Next, imagine what happens if we need to add more methods that switch on this enum. We might need a method returning the operator symbol, and another returning the operator precedence.

string GetOperatorSymbol(ArithmeticOperation op)
{
  switch(op)
  {
    case ArithmeticOperation.Add: return "+";
    case ArithmeticOperation.Subtract: return "-";
    case ArithmeticOperation.Multiply: return "*";
    case ArithmeticOperation.Divide: return "/";
    default: throw new InvalidOperationException();
  }
}

int GetOperatorPrecedence(ArithmeticOperation op)
{
  switch(op)
  {
    case ArithmeticOperation.Add: return 10;
    case ArithmeticOperation.Subtract: return 10;
    case ArithmeticOperation.Multiply: return 20;
    case ArithmeticOperation.Divide: return 20;
    default: throw new InvalidOperationException();
  }
}

I’ve highighted the relevant code for the “add” operator. Notice how it’s spread all over the place. Switch statements might group by operation, but they split by concept – and that’s the exact opposite of what’s usually intended with OO coding.

A Better Way

I’d suggest a better way of approaching this problem is to use an abstract class.

abstract class ArithmeticOperation
{
  abstract int ApplyOperation(int x, int y);
  abstract string GetSymbol();
  abstract int GetPrecendence();
}

class AddArithmeticOperation : ArithmeticOperation
{
  override int ApplyOperation(int x, int y)
  {
    return x + y;
  }

  override string GetSymbol()
  {
    return "+";
  }

  override int GetPrecedence()
  {
    return 10;
  }
}

// ...and so forth for the other operators.

That way, all the code for each operator sits in the same place, and adding any new methods for an operator requires all operators to be implemented before the code will even compile.

When to Use Enums

So if enums should be avoided, why do most languages include them? Personally I’d be happy without them,  but I can think of one possible reason you might want to use an enum. If you’re defining a public interface designed for consumption by other coders, you could argue that simplifying the interface at the expense of the code inside is a valid trade-off.