Argh, this whole "neptune looks like C#" thing is self-perpetuating. After we first noticed the similarities between the languages I looked into C# a bit more, and having that at the back of my head as we're discussing the language only paves the way for new C#-like constructs and so the hideous circle continues.

Example. And this is where smalltalk programmers should look away or at least read the disclaimer before continuing. The example is about synchronization and locking. In java, all objects can be used as monitors and you usually guard a critical section by synchronizing on some object: 

final Object lock = ...;
synchronized (lock) {
  // critical section
}

That's pretty readable even though it's somewhat warped that all objects can be used as monitors. But that's beside the point. In smalltalk it's even neater since you can use blocks and so don't need a special synchronized statement, you can just call a method on a Monitor or Mutex: 

mutex acquireDuring: [
  // critical section
].

In neptune, being derived from smalltalk, we also have blocks (they're called functions) and until recently we used the exact same technique as smalltalk for synchronization: 

Mutex mutex = ...;
mutex.acquire_during(fun {
  // critical section
});

Yeah I know, it doesn't look very good. It's exactly the same as in smalltalk except that method calls are written as mutex.acquire_during(...) and that the block syntax has changed into fun { ... }.

It turns out that you use acquire_during all over the place so we really want a more concise syntax. The idea is to add a special purpose syntax for acquiring a resource, for instance a mutex or a file, in a particular scope that makes sure the resource is released properly. It's an old idea we've had floating around but it never really got anywhere because we couldn't find the right syntax.

This afternoon we ended up discussing this problem again and it seems like we finally have a strawman: the using statement: 

Mutex mutex = ...;
using (mutex) {
  // critical section
}

C# programmers will find this very familiar -- C# has a construct with a very similar purpose and a very similar syntax. It is important, though, to point out that we haven't taken the whole construct from C#, only the name of the keyword. But that's a pretty important part of the construct.

As with all out shorthands, the using statement is just syntactic sugar for a simpler construct, in this case a method call: 

mutex.using(fun {
  // critical section
});

Any object is free to implement the using operator so it's a much more general construct than synchronized in Java. A using statement can also define variables, for instance when acquiring a resource produces a result: 

File my_file = ...;
using (InputStream stream : my_file) {
  // read file
}

Will this be a popular statement? I think that probably depends on how we use it in the libraries. But that goes for most of the language constructs, if we don't use them in the libraries they probably won't be used by others either. We'll see.

Disclaimer: I cannot be held responsible for any discomfort felt by smalltalkers while reading this post. To a smalltalk programmer the following probably seems like utter insanity since smalltalk already has a great solution to the problem in this example, and the people who are designing this language are all smalltalk programmers. I'm trying to find the courage to write a post about why we're moving away from smalltalk and I'm not quite there yet.