What makes a code base hard to modify?

Kent Beck makes the following observations, in Martin Fowler’s book, Refactoring:

  • Code that is hard to read, is hard to understand and consequently hard to modify.
  • Programs with duplicated logic are hard to modify.
  • Programs that require additional functionality that requires changes to existing code are hard to modify.
  • Code containing complex and convoluted conditional logic is hard to modify.

When should you refactor?

  1. When you add functionality.
  2. When you need to fix a bug.
  3. When you perform code reviews.

When shouldn’t you refactor?

  1. When you really need to rewrite from scratch!
  2. When you are close to a release deadline.

SQL Server More Secure Than Oracle

My favourite product is getting great press.

Between December 2000 and November 2006, external researchers discovered 233 vulnerabilities in Oracle’s products compared with 59 in Microsoft’s SQL Server technology, according to NGSS, which has worked for Microsoft in the past to make its software products more secure.

The NGSS report comes at a time when security researchers, irked by what
they consider to be Oracle’s glacial pace of fixing bugs, are increasingly turning their attention to its products.

New Features in C# 3.0 (part 2)

Implicitly Typed Local Variables

Implicit typing of local variables is a language feature that allows the type of a variable to be inferred at compile time from the type of the variable’s initialization expression. LINQ query expressions can return types, created dynamically by the compiler, containing data resulting from queries.

var n = 3;

var s = “Twas brillig”;

var d = 3.141592653;

var digits = new int[] { 1, 2, 3, 4, 5 };

Declaring Implicitly Typed Collections

Implicitly typed variables are useful when instantiating complex generic types:

var supplierProducts = new Dictionary<string, List<string>>();

var products = new List<string>();

products.Add(“pears”);

products.Add(“apples”);

products.Add(“oranges”);

supplierProducts.Add(“grocer”, products);

products = new List<string>();

products.Add(“beef”);

products.Add(“lamb”);

products.Add(“chicken”);

supplierProducts.Add(“butcher”, products);

int totalProducts = supplierProducts[“grocer”].Count +

supplierProducts[“butcher”].Count;

Console.WriteLine(“Total products: {0}”, totalProducts);

Implicitly typed variables should not be confused with untyped variables in scripting languages such as VBscript, or variants in VB6, where a variable can hold values of different types over the course of its lifetime. Once the compiler infers an implicit variable’s type from the expression used to initialize it, it’s type is then fixed just as if the variable had been explicitly declared with that type. Assigning a value of a different type will result in a compile time error.

var x; // Error: type is not known.

var x = { 1, 2, 3 }; // Error: type is not known.

var n = 8; // n implicitly typed as int

n = “This will not compile”;

Extending Types with Extension Methods

Extension methods enable developers to extend the functionality of existing types by defining new methods that are invoked using the usual instance method syntax. Extension methods (defined as static) are declared by specifying the modifier keyword this on the first parameter of the method. Extension methods can be added to any type, including the generic types such as List and Dictionary, as shown in this slightly contrived example:

public static class Extensions

{

public static Dictionary Combine(this Dictionary s Dictionary d)

{

var newDictionary = new Dictionary(s);

foreach (K key in d.Keys)

{

if (!newDictionary.ContainsKey(key))

{

newDictionary.Add(key, d[key]);

}

}

return newDictionary;

}

}

Initialise two dictionaries and then combine them using the extension method just defined:

var supplierProducts = new Dictionary<string, List<string>>();

products = new List<string>();

products.Add(“beef”);

products.Add(“lamb”);

products.Add(“chicken”);

supplierProducts.Add(“butcher”, products);

var supplierProducts2 = new Dictionary<string, List<string>>();

products = new List<string>();

products.Add(“pork”);

products.Add(“veal”);

products.Add(“venison”);

supplierProducts2.Add(“butcher”, products);

var x = supplierProducts.Combine<string, List<string>>(supplierProducts2);

Lambda Expressions

C# 2.0 introduced anonymous methods, which allow code blocks to be “inlined” where delegate values are expected. For example, the List FindAll method requires a delegate parameter:

List<int> oddNumbers = list.FindAll(delegate(int i) { return (i%2) != 0; }

Here, the delegate determines whether the input integer is an odd number. C# 3.0 takes this further and introduces lambda expressions, a functional programming syntax for writing anonymous methods.

A lambda expression is written as a parameter list, followed by =>, followed by an expression. The parameters of a lambda expression can be explicitly or implicitly typed. In an explicitly typed parameter list, the type of each parameter is explicitly stated:

(int x) => x + 1

In an implicitly typed parameter list, the types of the parameters are inferred from the context in which the lambda expression is used. In addition, if a lambda expression has a single, implicitly typed parameter, the parentheses may be omitted from the parameter list:

x => x + 1
(x,y) => return x * x + y * y

Here is an example of using a single variable lambda expression:

var list = new List<string>();

list.Add(“cat”);

list.Add(“dog”);

list.Add(“fish”);

list.Add(“mouse”);

list.Add(“catch”);

list.Add(“carrot”);

var matchStartsWithCA = list.FindAll( s => s.StartsWith(“ca”) );

foreach (string matchString in matchStartsWithCA)

{

Console.WriteLine(matchString);

}

References:
Hands-On Lab: Lab Manual: C# 3.0 Language Enhancements

Microsoft Best Practices Analyser

As usual, Scott Hanselman beat me to it (!) with his recent blog post Microsoft Best Practices Analyzer Tools where he gives a round-up of the offerings from Microsoft and muses whether we will be seeing a combined tool soon, which seems likely given this codeplex project called the Microsoft Best Practice Analyzer (BPA). It comes with a plugin for ASP.NET 2.0, and as Scott notes you might be surprised if you run it on one of your projects. Not only will it find potential problems but also suggest accurate solutions. His post also gives links to the various best practices tools currently available.

Lousy Random Number Generators

Over at Jeff Atwood’s blog, Coding Horror, I noticed a nice round-up of random number generation. I tried to post a quick comment but it kept being rejected so I’ve blogged it here instead.

Anyone interested in a small but ‘highly’ random generator that suffers from few points of failure should check out the mersenne twister pseudo-random number generator algorithm. This work is fairly recent (1998). I believe it has been implemented in the .NET framework?

The problem that plagues most generators occurs when you require a huge set of random numbers for large simulations (such as Monte Carlo simulations, for instance).

A word of advice: never, never attempt to roll your own generator or ‘improve’ an existing one. The results will be at best less than random, and at worst dangerous! It’s in the same sin category as using Bubble Sort. A most heinous crime!

http://www.bedaux.net/mtrand/ includes a reference to the original paper.
http://en.wikipedia.org/wiki/Mersenne_twister

Bruce Schneier’s book Applied Cryptography (John Wiley & Sons, 1994) is a great place to start if you are interested in random numbers from the point of view of cryptography.

Raku Ceramics and Zoomorphic forms

Until recently, when I moved house, I had a Raku kiln in my back yard (well, actually more of a neglected savannah). Raku originated in Japan in the late 16th Century, but has become adopted and popularised in the West. One of the exciting glaze techniques in Raku is reduction, where hot (as in 900+ C) fired oxide glazed ceramics are removed straight from the kiln and placed into a reducing environment (i.e. little or no oxygen) such as paper or sawdust, often in a sealed metal bin.

It can sometimes be a little disappointing, when after a couple of hours of cooling, you extract an all black pot, but sometimes the effects are marvelous, in all the hues you can imagine. The other source of excitement is being engulfed in flames from head to toe (we do wear appropriate safety equipment, such as casting gloves, splash screen masks and organo-metal filtered breathing masks. Also, always wear all cotton clothes, never anything made from synthetic materials).

I promised Joanna I would post a link to her (almost finished) site (that web site designer is so slack!), so here it is: Joanna Wakefield Ceramics.

New Features in C# 3.0

The C# 3.0 language enhancements are part of the LINQ project, whose aim is to make working with data as easy as working with objects. This will be a major evolutionary step forward in Microsoft’s development landscape (John Lam’s recent addition to the Microsoft stable could also be seen as a push in this direction). LINQ provides a single, general purpose declarative query functionality that can be applied to in-memory and persisted data. These new language features are:

  • Implicitly typed local variables whose type can to be inferred from the expressions used to initialize them.
  • Extension methods enable additional methods to be added to existing types.
  • Lambda expressions are a new form of anonymous methods that provide improved type inference and conversions to delegate types and expression trees.
  • Expression trees, which permit lambda expressions to be represented as data (expression trees) instead of code (delegates).
  • Object and collection initializers combine creation and initialization into a single step, allowing values to be specified for fields or properties for newly created objects.
  • Anonymous types, which are tuple types automatically inferred and created from object initializers.
  • Query expressions provide a language-integrated syntax for queries similar to relational and hierarchical query languages such as SQL and XQuery. This provides compile time checking of queried types, rather than at runtime. A definite productivity boost.

A great way to find out about the enhancements in C# 3.0, is to download the LINQ preview and to work through the short tutorials, which showcase all of the additions listed above. NOTE: I suggest you run up a VPC image, as LINQ does not yet have a Go Live license available. You can download BLINQ here.

I’ll explore some examples of these new language features in a couple of subsequent posts.

References:
Hands-On Lab: Lab Manual: C# 3.0 Language Enhancements

Development Zen

This gem comes from one of Scott Hanselman’s bosses:

Don’t let clients/users dictate the solution with their statement of the problem.

Or to put it a slightly different way:

When someone asks you to solve a problem, first discover the real problem they want solving.

Book Review: Professional Visual Studio 2005

Professional Visual Studio 2005, Andrew Parsons and Nick Randolph. WROX

This book is aimed at developers who are new to Visual Studio, and those with some exposure to it. It attempts to cover a large number of topics and features, and it does that admirably. It contains 56 chapters, spanning approximately 870 pages. This means that the coverage will not be quite as in-depth as other books on similar topics. For instance, compare with Apress’s PRO ASP.NET 2.0 which is longer by almost 400 pages and just 34 chapters. The source code for the examples in the book can be downloaded online.

It’s rather extensive breadth means that some of the chapters are a bit short; for instance Chapter 28 on Assembly Signing is just 3 pages long. In one or two places, I would have preferred slightly less breadth and a little more depth. Some of the chapters should have either been condensed into other sections or removed completely.

There is one omission in Chapter 4. This chapter provides a good introduction to the various kinds of projects available, but does not cover the ‘new’ Web Application Projects. This was due to the timing of the book’s completion and publication. Web Application projects are a freely downloadable add-in and will be included in Visual Studio 2005 Service Pack 1 in the very near future. They have been around for some time, and are in use around 50/50 compared with Web Site projects. They are essential for enterprise development of web sites. Another restriction of Web Site projects is that you can not use them with TSFS, as they do not have a permanent solution file.

There are a couple of places where screenshots might be confusing, such as Figure 51-3 on pg 728, because the correct line (aspnet_wp.exe) is not highlighted. There are also several sections with perhaps too many screenshots, such as pages 30-33.

The sort of coverage I would have liked to see expanded upon would have been best practices using the IDE and some worked examples. Since this book is aimed at newcomers, I think it could have contained more process based advice rather than just explaining what features are available. Even experienced developers moving from other environments would benefit greatly from advice showing ‘best practice’ ways of organising projects and solutions.

In conclusion: If you are new to Visual Studio 2005 and want to whet your appetite with a book that covers a great number of the available features, this book is worth reading. If you are already an experienced developer, you may pick up one or two gems, but the majority of the material will probably be familiar to you. I do not think this is a book you will read cover to cover, but rather dip into as and when you come across a certain feature and want to explore it a little further.

Disclaimer: I know one of the authors, Nick Randolph, personally (Nick has been the main organiser of the Perth .Net UG until his recent journey to New Zealand). I borrowed a copy of the book from the User Group library, as Nick had kindly donated a copy. Use of the library is free to User Group members, which is just one reason to join and participate.

One thing I noticed was the book states (pg xxxix) that the minimum requirement to use the book is VS 2005 PRO but I did find just one feature that requires VSTS. I’ll leave finding it as an exercise for the reader!

Annoying Download Behaviour

Sometimes the seemingly simplest problems set you seething. Today I wasted at least 30 minutes trying to discover the reason why, when I clicked on a web page file download link, it would automatically download the file and open it without giving me the option to save it.
If you’ve worked in any kind of support role, you will have heard this many times: I hadn’t changed anything! At least knowingly. At first I blamed IE (the universal scape goat!).

A few days ago downloads went off with a bang everytime, today the touch paper was fizzling and going out! I’m sure I didn’t change anything… It’s times like these, you realise how frustrating technology must be to someone who is not computer literate.

I could have fired up FileMon to find where it was temporarily storing the file, but this seemed the wrong answer. The answer in the end was very simple, but I still have no idea why it had changed…):

  1. Open Windows Explorer
  2. On the Tools menu, click Options
  3. On the File Types tab, select the appropriate file type in the Registered File Types list
  4. Click the Advanced button and ensure the “Confirm open after download” checkbox is ticked
  5. Click OK, and then OK again
  6. Repeat for any other offending file types