I for one am very happy that the next version of Visual Studio will finally embrace what some of us have been requesting for a long time now – UML adoption. A few months ago I mentioned some stuff that would be in the next version of VS and now that more has been going on I am thoroughly pleased.
For my part I’ve not really looked too much into what’s going on with the class diagrams etc and whether or not we will be graced with the standard l&f for UML diagrams. I for one hope that this does happen.
This is way overdue and both Eclipse and Netbeans have UML incorporated into them to a certain degree. Netbeans has pretty good UML support right now in fact. Of course the great thing about the addition of these UML features is that we will be able to get a more abstract view of our code and the way various components work with one another by reverse engineering it. Maybe this might not seem so helpful now, but when you revisit old code or encounter code that isn’t yours it will be.
I know that the VS team have had a tonne of stuff to do but why have we had to wait so long for tools which are pretty much essential? We’ve been palmed off to use things like Visio or fork out the big bucks for more comprehensive software.
Well, at least the wheels are finally in motion. Hip hip 😉
Before I go be sure to check out Channel9 this week for more insight on what’s coming up in VS2010. I briefly watched a video today just to get the gist of what has been added since I last looked and it was pretty decent.
There is a pretty interesting architecture based on software pipelines that will at least allow your systems to utilize many-core processors in a far easier manner than other alternatives. This approach has a lot in common with fluid dynamics in that some principals are the same.
All service requests hit something called a pipeline distributor. The pipeline distributor routes the request to the appropriate pipeline. What is pretty nice about this approach is that the pipelines within a pool can delegate requests to other pipelines within the same pool or even delegate requests to another pipeline distributor that maps requests to a different set of pipelines within a different pipeline pool.
I can’t do this approach justice myself via a simple blog post but upon further searching I came across a rough cuts book named Software Pipelines: The Key to Capitalizing on the Multi-core Revolution. I’ve quickly skimmed the book just now and it looks as though it covers the subject quite well.
As I mentioned several days ago I’ve been seeing if a dark theme in VS would help my eyes a little. The short of it is – no, no it didn’t. The major sore point is that if you use a dark theme in VS then you find yourself constantly swapping between dark (VS) and light (web content, content in general). The latter of course doesn’t sound like its particularly good for you and I’d definitely concur with that.
I actually found that my background was slightly off-white in my VS settings and since changing it to pure white around 3 or so days ago I’ve found that my eye strain has just disappeared. Funny thing is I can never remember changing the background colour.
I’ve no doubt that the colour schemes used in VS are very subjective so I won’t announce that light themes are the best, but it seems to work well for me.
I’ve been highly critical of using dark themes in Visual Studio particularly because the UI of VS is light in its very nature. The combination of the two proving to be an interesting proposition when using VS for large durations of time.
I digress. Recently I have suffered a few eye issues and I’m pretty much willing to try and use a dark theme now for more than an hour and then dismissing it in the hope that it may help me out a little. I have tried a few other minor solutions prior to this experiment, the most of which revolve around making the background colour of VS a slightly off-white colour. If anything that approach made things worse.
I’ll be using the theme for all my coding which spans from C++ to C# and see how it goes. The theme I will use is Vibrant Ink by Rob Conery.
Hopefully this may help my eyes a little? …
Part 4 of the design patterns series I have been writing has just been published on DotNetSlackers. This part covers the singleton pattern.
View it – Design Patterns – Part 4
In case I am not the only one that appreciates virtual desktops then be sure to download this new tool from Mark Russinovich and Bryce Cogswell.
More on it here.
UPDATE: I’m only using this because I’ve recently sold my monitors as I’m moving country soon. Life without many monitors is pretty bad ;-(
We have just released 0.6 of the Data Structures and Algorithms library. Notable new features include (amongst many other little changes not listed):
- AVL Tree
- Radix sort
Download Data Structures and Algorithms 0.6!
Peli has just posted a good post on using Pex in a TDD fashion to create a binary heap.
In case you don’t know, Peli is actually one of the guys working on Pex at MSR so if you have a chance do give it a look 😉
“Pex (Program EXploration) is an intelligent assistant to the programmer. From a parameterized unit test, it automatically produces a traditional unit test suite with high code coverage. In addition, it suggests to the programmer how to fix the bugs.”
By the way Pex is not tied to MSTest. See the Pex Extensions project on CodePlex for other framework support like NUnit.
The third part of this series covers the factory pattern.
View it – Design Patterns – Part 3
You may also be interested in part 1 (strategy), and part 2 (observer).
An article I wrote for DotNetSlackers has just been published entitled Setting up a build environment. The article is based upon a pretty simple example that uses Subversion, TortoiseSVN, MSBuild, MSBuild Community Tasks, and TeamCity.
Give it a read – Setting up a build environment.
Note: I give a brief mention also to the SDC Tasks Library project which contains some very helpful tasks.
Visual Studio and TeamCity integration
One thing I didn’t really have space to mention in the article is the integration that TeamCity provides for Visual Studio. Its a little plugin that allows you to view the results of builds, as well as being able to run a local build. There are a few more features and I suggest you view this video on the JetBrains web site to get up to speed with all of them.