Deadlock detection – finally released

I’d hoped to be able to make this post a week ago, but adding extra unit tests, performance tests and documentation took longer than expected. (Doesn’t it always?)


I’ve now refactored the previous incarnation of SyncLock in my Miscellaneous Utility Library (snappy title, huh?) and added a new type of lock which can detect deadlocks (throwing an exception instead of entering the deadlock-prone state). There’s also a usage page explaining how to use the locks, and what the performance impact is. (Well, what it is on my box, anyway.) Any further suggestions now it’s concrete are welcome, of course.


Pedantry – how much is too much?

I’m a pedant, there’s no doubt about it. I’m particularly pedantic when it comes to terminology in computing discussions – at least where I see value in being precise about what is meant. So, when discussing static constructors in a mailing list thread recently, I’ve been very carefully distinguishing between a static constructor (which is a C# term) and a type initializer (which is a CLI term). This hasn’t been met terribly favourably by those who wish to use the term “static constructor” to mean both the .cctor member in a (compiled) type and the C# static constructor, despite them being slightly different in semantics and belonging to different domains. Now, I don’t wish to spill that discussion over onto my blog, but it has made me think about the general issue of pedantry when it comes to terminology.


Pedantry is rarely popular, but I believe it does bring value to a discussion, especially when some subtleties are involved. I generally assume a specification to be the authoritative source of information on terms related to the topic covered by the specification, as it’s a piece of common ground on which to base discussions. (The exception to this is if the spec is generally agreed to be incorrect in a particular regard.) If I talk about something being a variable and you understand “variable” in a completely different way to me, it’s a potential source of great confusion. I’m not pedantic to gain a feeling of superiority – I’m pedantic to try to make sure everyone’s effectively speaking the same language.


Of course, you don’t need to be absolutely precise all the time. If I were discussing an ASP.NET problem, for instance, I probably wouldn’t feel too bad about a sentence such as “x is now a string of length 5″. However, if I were discussing variables, reference types etc, I’d probably try to be more precise: “The value of x is now a reference to a string of length 5.” Writing (or reading) the second style for prolonged periods gets quite tedious, but I believe it’s important to be able to move into that mode when the need arises.


So, the question is: am I the only one who feels this way? I would expect most of the readers of this blog to be people who’ve read either my newsgroup posts, mailing list posts, or C# articles, so you probably have a fair idea of what I’m like. Do I go over the top, or do you find it useful? Is there a way of bringing precision to a discussion without irritating people (as I tend to, unfortunately)? Just to possibly remind you of things I’m often pedantic about, here’s a brief list of “pet peeves” which tend to involve people cutting fast and loose with terminology:


  • Value types “always being on the stack”
  • “Objects are passed by reference by default”
  • “C# supports two floating-point types: float and double.” (That one’s in the C# spec, unfortunately – decimal is also a floating point type.)
  • “I’m having trouble with ASCII characters above 127…” (along with its side-kick “I’m using extended ASCII”)
  • Volatility and atomicity being mixed up

What kind of deadlock prevention do you want?

Okay, so I’m having another look at the alternative threading ideas which are part of my threading article. (They’re not that big an alternative really – not compared with CSP etc – they’d just make things more pleasant.) I want to add deadlock prevention to my locks, making it impossible to lock things incorrectly (so long as you’re locking the simple way – if you lock the associated monitor independently, that’s your own lookout). Obviously this requires you to set up what’s correct and what’s incorrect to start with. My question to you all is: how do you want to be able to set up those rules? What kind of rules do you need? Do they need to be extensible somehow? Some desirable things may be impossible, but I’d like to know what the ideal would look like before working out the realistic. I have a couple of pretty simple ideas, but I won’t taint your own views by mentioning them yet…


Visual Studio vs Eclipse


I often see people in newsgroups saying how wonderful Visual Studio is, and they often
claim it’s the “best IDE in the world”. Strangely enough, most go silent when I ask how
many other IDEs they’ve used for a significant amount of time. I’m not going to make any
claims as to which IDE is “the best” – I haven’t used all the IDEs available, and I know
full well that one (IDEA) is often regarded as superior to Eclipse. However, here are a
few reasons I prefer Eclipse to Visual Studio (even bearing in mind VS 2005, which is a
great improvement). Visual Studio has much more of a focus on designers (which I don’t
tend to use, for reasons given elsewhere) and much less of a focus on making actual coding
as easy as possible.



Note that this isn’t a comparison of Java and C# (although those
are the languages I use in Eclipse and VS respectively). For the most part, I believe C#
is an improvement on Java, and the .NET framework is an improvement on the Java standard
library. It’s just a shame the tools aren’t as good. For reference, I’m comparing VS2005
and Eclipse 3.1.1. There are new features being introduced to Eclipse all the time (as I write,
3.2M4 is out, with some nice looking things) and obviously MS is working on improving VS
as well. So, without further ado (and in no particular order):


Open Type/Resource



When I hit Ctrl-Shift-T in Eclipse, an “Open Type” dialog comes up. I can then type in
the name of any type (whether it’s my code, 3rd party library code, or the Java standard
library code) and the type is opened. If the source is available (which it generally is -
I’ve used very few closed source 3rd party Java components, and the source for the Java
standard library is available) the source opens up; otherwise a list of members is displayed.
In large solutions, this is an enormous productivity gain. I regularly work with solutions
with thousands of classes – remembering where each one is in VS is a bit of a nightmare.
Non-Java resources can also be opened in the same way in Eclipse, using Ctrl-Shift-R instead.
One neat feature is that Eclipse knows the Java naming conventions, and lets you type just
the initial letters instead of the type name itself. (You only ever need to type as much as you
want in order to find the type you’re after anyway, of course.) So for example, if I type
“NPE”, I’m offered NullPointerException and NoPermissionException.



Note that this isn’t the same as the “Find Symbol” search offered by VS 2005. Instead,
it’s a live updating search – as you type, the list is updated. This is very handy if you can’t
remember whether it’s ArgumentNullException or NullArgumentException and the like – it’s very fast
to experiment with.



There’s good news here: Visual Studio users have a saviour in the form of a free add-in
called DPack, by USysWare. This offers dialogs
for opening types, members (like the Outline dialog, Ctrl-O, in Eclipse), and files. I’ve only
just heard about it, and haven’t tried it on a large solution yet, but I have high hopes for it.


Sensible overload intellisense



(I’m using the word intellisense for what Eclipse calls Code Assist – I’m sure you know what I mean.)
For some reason, although Visual Studio is perfectly capable of displaying the choice of multiple
methods within a drop-down list, when it comes to overloads it prefers a spinner. Here’s what you get
if you type sb.Append( into Visual Studio, where sb is a StringBuilder
variable:




Here’s what happens if you do the equivalent in Eclipse:




Look ma, I can see more than one option at once!


Organise imports



For those of you who aren’t Java programmers, import statements are the equivalent to using directives
in C# – they basically import a type or namespace so that it can be used without the namespace being
specified. In Visual Studio, you either have to manually type the using directives in (which can be
a distraction, as you have to go to the top of the file and then back to where you were) or (with 2005)
you can hit Shift-Alt-F10 after typing the name ofthe type, and it will give you the option of adding
a using statement, or filling in the namespace for you. Now, as far as I’m aware, you have to do that
manually for each type. With Eclipse, I can write a load of code which won’t currently compile, then
hit Ctrl-Shift-O and the imports are added. I’m only prompted if there are multiple types available
from different namespaces with the same name. Not only that, but I can get intellisense for the type
name while I’m typing it even before I’ve added the import – and picking the type adds the import
automatically. In addition, organise imports removes import statements which aren’t needed – so if you’ve
added something but then gone back and removed it, you don’t have misleading/distracting lines at the
top of your file. A feature which isn’t relevant to C# anyway but which is quite neat is that Eclipse allows
you to specify how many individual type imports you want before it imports the whole package
(e.g. import java.util.*). This allows people to code in whatever style they want, and still get
plenty of assistance from Eclipse.


Great JUnit integration



I confess I’ve barely tried the unit testing available in Team System, but it seems to be a bit of a pain
in the neck to use. In Eclipse, having written a test class, I can launch it with a simple (okay, a slightly
complicated – you learn to be a bit of a spider) key combination. Similarly I can select a package or a whole
source directory and run all the unit tests within it. Oh, and it’s got a red/green bar, unlike Team System
(from what I’ve seen). It may sound like a trivial thing, but having a big red/green bar in your face is a
great motivator in test driven development. Numbers take more time to process – and really, the most important
thing you need to know is whether all the tests have passed or not. Now, Jamie Cansdale has done a great
job with TestDriven.NET, and I’m hoping that he’ll integrate it with
VS2005 even better, but Eclipse is still in the lead at this point for me. Of course, it helps that it just
comes with all this stuff, without extra downloads (although there are plenty of plugins available). Oh, and
just in case anyone at Microsoft thinks I’ve forgotten: no, unit testing still doesn’t belong in just
Team System. It should be in the Express editions, in my view…


Better refactoring



MS has made no secret of the fact that it doesn’t have many refactorings available out of the box. Apparently
they’re hoping 3rd parties will add their own – and I’m sure they will, at a cost. It’s a shame that you have
to buy two products in 2005 before you can get the same level of refactoring that has been available in Eclipse
(and other IDEs) for years. (I know I was using Eclipse in 2001, and possibly earlier.)



Not only does Eclipse have rather more refactorings available, but they’re smarter, too. Here’s some sample code
in C#:


public void DoSomething()
{
string x = "Hello";
byte[] b = Encoding.UTF8.GetBytes(x);
byte[] firstHalf = new byte[b.Length / 2];
Array.Copy(b, firstHalf, firstHalf.Length);
Console.WriteLine(firstHalf[0]);
}

public void DoSomethingElse()
{
string x = "Hello there";
byte[] b = Encoding.UTF8.GetBytes(x);
byte[] firstHalf = new byte[b.Length / 2];
Array.Copy(b, firstHalf, firstHalf.Length);
Console.WriteLine(firstHalf[0]);
}


If I select the last middle lines of the first method, and use the ExtractMethod refactoring, here’s
what I get:


public void DoSomething()
{
string x = "Hello";
byte[] firstHalf = GetFirstHalf(x);
Console.WriteLine(firstHalf[0]);
}

private static byte[] GetFirstHalf(string x)
{
byte[] b = Encoding.UTF8.GetBytes(x);
byte[] firstHalf = new byte[b.Length / 2];
Array.Copy(b, firstHalf, firstHalf.Length);
return firstHalf;
}

public void DoSomethingElse()
{
string x = "Hello there";
byte[] b = Encoding.UTF8.GetBytes(x);
byte[] firstHalf = new byte[b.Length / 2];
Array.Copy(b, firstHalf, firstHalf.Length);
Console.WriteLine(firstHalf[0]);
}


Note that second method is left entirely alone. In Eclipse, if I have some similar Java code:


public void doSomething() throws UnsupportedEncodingException
{
String x = "hello";
byte[] b = x.getBytes("UTF-8");
byte[] firstHalf = new byte[b.length/2];
System.arraycopy(b, 0, firstHalf, 0, firstHalf.length);
System.out.println (firstHalf[0]);
}

public void doSomethingElse() throws UnsupportedEncodingException
{
String y = "hello there";
byte[] bytes = y.getBytes("UTF-8");
byte[] firstHalfOfArray = new byte[bytes.length/2];
System.arraycopy(bytes, 0, firstHalfOfArray, 0, firstHalfOfArray.length);
System.out.println (firstHalfOfArray[0]);
}


and again select Extract Method, then the dialog not only gives me rather more options, but one of them is
whether to replace the duplicate code snippet elsewhere (along with a preview). Here’s the result:


public void doSomething() throws UnsupportedEncodingException
{
String x = "hello";
byte[] firstHalf = getFirstHalf(x);
System.out.println (firstHalf[0]);
}

private byte[] getFirstHalf(String x) throws UnsupportedEncodingException
{
byte[] b = x.getBytes("UTF-8");
byte[] firstHalf = new byte[b.length/2];
System.arraycopy(b, 0, firstHalf, 0, firstHalf.length);
return firstHalf;
}

public void doSomethingElse() throws UnsupportedEncodingException
{
String y = "hello there";
byte[] firstHalfOfArray = getFirstHalf(y);
System.out.println (firstHalfOfArray[0]);
}

Note the change to doSomethingElse. I’d even tried to be nasty to Eclipse, making the variable names different in the second method. It still does the business.


Navigational Hyperlinks


If I hold down Ctrl and hover over something in Eclipse (e.g. a variable, method or type name), it becomes a hyperlink. Click on the link, and it takes you to the declaration. Much simpler than right-clicking and hunting for “Go to definition”. Mind you, even that much isn’t necessary in Eclipse with the Declaration view. If you leave your cursor in a variable, method or type name for a second, the Declaration view shows the appropriate code – the line declaring the variable, the code for the method, or the code for the whole type. Very handy if you just want to check something quickly, without even changing which editor you’re using. (For those of you who haven’t used Eclipse, a view is a window like the Output window in VS.NET. Pretty much any window which isn’t an editor or a dialog is a view.)


Update! VS 2005 has these features too!
F12 is used to go to a definition (there may be a shortcut key in Eclipse as well to avoid having to use the mouse – I’m not sure). VS 2005 also has the Code Definition window which is pretty much identical to the Declaration view. (Thanks for the tips, guys :)


Better SourceSafe integration


The source control integration in Eclipse is generally pretty well thought through, but what often amuses me is that it’s easier to use Visual SourceSafe (if you really have to – if you have a choice, avoid it) through Eclipse (using the free plug-in) than through Visual Studio. The whole binding business is much more easily set up. It’s a bit more manual, but much harder to get wrong.



Structural differences


IDEs understand code – so why do most of them not allow you to see differences in code terms? Eclipse does. I can ask it to compare two files, or compare my workspace version with the previous (or any other) version in source control, and it shows me not just the textual differences but the differences in terms of code – which methods have been changed, which have been added, which have been removed. Also, when going through the differences, it shows blocks at a time and then what’s changed within the block – i.e. down to individual words, not just lines. This is very handy when comparing resources in foreign languages!



Compile on save


The incremental Java compiler in Eclipse is fast. Very, very fast. And it compiles in the background now, too – but even when it didn’t, it rarely caused any bother. That’s why it’s perfectly acceptable for it to compile (by default – you can change it of course) whenever you save. C# compiles a lot faster than C/C++, but I still have to wait a little while for a build to finish, which means that I don’t do it as often as I save in Eclipse. That in turn means I see some problems later than I would otherwise.



Combined file and class browser


The package explorer in Eclipse is aware that Java files contain classes. So it makes sense to allow you to expand a file to see the types within it:




That’s it – for now…


There are plenty of other features I’d like to mention, but I’ll leave it there just for now. Expect this blog entry to grow over time…


RSS for my articles

A friend suggested on Sunday that I create an RSS feed for my articles, so that interested parties would know when I’ve created a new one – so I’ve done it. It’s hand-crafted, so there may be a few wrinkles to iron out, but hopefully it will prove useful. It would be nice if there was a way of specifying the last time that an item had been updated (rather than the original publishing date). I can’t see anything like that in the spec but maybe I’ve missed something. The feed works in Thunderbird at least – let me know if you have problems with it.


New (to me) threading paradigms

In the last couple of days, I’ve been reading up on CSPs (Communicating Sequential Processes) and the Microsoft Research project CCR (Concurrency and Coordination Runtime). I suspect that the latter is really a new look at the former, but I don’t have enough experience with either of them to tell. Now, I know a number of my readers are smart folks who have probably lived and breathed these things for a while – so, is my hunch right, or are they fundamentally different models?


A few links for further reading:



System.Random (and java.util.Random)

This is as much a “before you forget about it” post as anything else.


Both Java and .NET have Random classes, which allow you to get random numbers within a certain range etc. Unless you specify otherwise, both are seeded with the current time. Neither class claims to be thread-safe. This presents a problem – typically you effectively just want one source of random numbers, but you want to be able to access it from multiple threads. You certainly don’t want to create a new instance of the Random class every time you want a random number – due to the granularity of the system clock, that commonly gives repeated sequences of random numbers (i.e. multiple instances are created with the same seed, so each instance gives the same sequence).


I suggest that very few people really need to specify seeds – which means they don’t really need instance methods in the first place. A class with static methods (matching the interface of Random) would be perfectly adequate. This could be implemented using a single Random instance and locking to get thread safety, but a slightly more elegant (or at least more interesting) way would be to use thread-local static variables. In other words, each thread gets its own instance of Random. Now, that introduces the problem of which seed to use for each of these instances. That’s pretty easily solved though – either you take some combination of the thread ID and the current time, or you create a new instance of Random the first time any thread accesses the class, and use that Random as the source of seeds for future Randoms. The only time locking is needed is to access that Random, which occurs once per thread.


This does, of course, break my “keep it as simple as possible” rule – the simplest solution would certainly be to lock each time. In this case though, as this will end up as a library class which may well be used by many threads simultaneously in situations where a lot of random numbers are being generated, I think it’s worth the extra effort. I’ll probably write this up as an article when I’ve written the tests and implementation…


Adverts on my C# article pages?

I had an email today which suggested I should start advertising on my C# article pages. I’ve considered this in the past without coming to any conclusions. I would certainly plump for Google AdSense on the grounds that it’s fairly non-invasive. I just can’t decide whether or not it’s a good idea.


Pros:


  • I get money for things which do actually take a fair amount of time to write.

Cons:


  • I’d need to work out what the tax implications are (particularly in terms of being in the UK when Google is in the US). I don’t currently fill in a tax return, although I’ll have to next year anyway…
  • People might get annoyed with the ads and not want to read the articles.
  • People might feel that when I link to an article either here or in newsgroups, that I’m just doing so to get more money.

That last point really worries me – but maybe I’m being paranoid. So, what do you think – should I give it a try, or would it “spoil” the articles?