Duncan's Blog

Broken Records coming to New Zealand...

2009-03-18T20:33:00.004+13:00

Not exactly technology related, but I thought a little more promotion wouldn't go amiss. Since leaving the UK, my brother became a member of a band, Broken Records and I've never yet managed to see them live which is a real shame. They have recently been signed by 4AD and are currently recording their first album which is due for release on 1st June 2009. Good luck lads!
Oh, by the way, they aren't physically coming to New Zealand, just via my blog... Shame, I think it would be a good idea! :)

Partly for my own reference, but also as a shameless plug, here are some of their website links:
YouTube
Facebook Group
MySpace

Here are some videos that are worth watching too:

Broken Records Studio Video Diary - behind the scenes of their album recording:

Official promo for 'Lies' - the 3rd single from Scottish band, Broken Records

A Channel4 review:

Using language features for readability and understandability

2009-02-01T22:02:00.001+13:00

Whilst pairing recently, we came across a situation that I believed was best solved using LINQ. I've not used LINQ much other than reading about it in blogs so it was an opportunity to see what it was all about. In the end, we managed to solve the problem very nicely with very few lines of code. As we continued programming, yet another opportunity arose where LINQ could have solved the problem but instead we chose to write a foreach statement and this made me stop and think about language syntax in general. Why do we chose to use a certain syntax over another? Is it readability? Is it understandability? It is about knowledge? This post explores a few thoughts around this topic.

I can think of a few reasons that might affect why a developer would chose to use a certain syntax:

readability
understandability
fewest lines of code
existing knowledge of the syntax
they only know one way to solve the problem
technical constraint (platform, deployment, etc)

These are just a few choices of the top of my head and I'll examine the readability and understandability first. These two terms are very closely related but they do have distinct differences. I'm not going to discuss them here, but you can read further on Wikipedia on readability and understandability. Suffice to say that the choice of syntax can enhance both these concepts. Let's look at an example:

public string Name
{
    get
    {
        if (name == null)
            return "No name";
        return name;
    }
}
 

public string Name
{
    get { return name ?? "No name"; }
}

These two property statements are identical in functionality but obviously differ in syntax. However, if you do not understand the '??' operator, you will be at a loss for the second statement. However, if you did understand the operator, which of the statements has a higher readability index? I've come round to thinking that they are both readable but one could argue that the first one is more understandable because it uses an explanatory if statement. However, the '??' operator explains the same thing albeit that you need knowledge of the operator to understand its function. Further, you could also argue that the second implementation is more readable because it is only one line of code to read.

Let's look at another example this time using LINQ:

public IList<Customer> GetCustomers(string startsWith)

    IList<Customer> customersStaringWith = new List<Customer>();

    foreach (Customer customer in customers)

        if (customer.Name.StartsWith(startsWith))

            customersStaringWith.Add(customer);

    return customersStaringWith;

public IList<Customer> GetCustomersLinq(string startsWith)

    var selectedCustomers =

        from customer in customers

        where customer.Name.StartsWith(startsWith)

        select customer;

    return new List<Customer>(selectedCustomers);

Again, these two methods return the same result but which one is more readable?

Drawing a conclusion from this is quite difficult as readability and understandability are generally opinionated views. However, what I find interesting is that there are some language syntaxes that are adopted readily whilst others are left behind. Take generics, for example. I don't know any developer that doesn't use generics if they are using .NET Framework 2.0 or above. What is it about the syntax that attracts its adoption? Are developers becoming lazy about learning new syntaxes because they can still accomplish their goals using "standard" syntax? Does using a more recent syntax (Linq, Lambda) reflect on the developer's skill or is it just demonstrating knowledge?

So that I'm not left behind, I'm trying to use these new syntaxes where I get a chance as I believe that the more you use them, the more readable they become - to you. Sometimes, developers fear new syntaxes because they don't understand them well enough to use them effectively and therefore they write them off if they can accomplish the same result in another way. If a new syntax makes for more concise code and it doesn't impair its readability, then I believe it is the right choice. One way to expose yourself to various syntaxes (and code styles) is to take part in an open source project and explore the source code.

I've only scratched the surface in this post about readability and understandability but the concepts of each are extremely important to grasp in order to write good code, IMHO.

Creating a custom dictionary for code analysis in VS2008

2008-07-15T13:00:00.005+12:00

There seems to be a few posts out there asking where to put a custom dictionary to be used by FxCop (code analysis). In Visual Studio 2008, you can add a dictionary xml file to the solution and then tell the solution to use this as the dictionary for FxCop. Here's how.

Create your dictionary file
Add a new XML file to your project or solution and call it what you want. It doesn't need to be called CustomDictionary.xml.
The dictionary file must follow the correct schema, but unfortunately, there does not appear to be an .xsd schema file available (that I can find). As a starting point, copy the XML from the CustomDictionary.xml that comes with FxCop which is in the default FxCop install directory which on my machine is C:\Program Files\Microsoft Visual Studio 9.0\Team Tools\Static Analysis Tools\FxCop\CustomDictionary.xml. You can then edit this file to include your own words. However, the schema is pretty simple:

Making FxCop use your dictionary
In the properties for the XML file you've created (right-click, properties), change the Build Action to 'CodeAnalysisDictionary'.
Recompile your project and FxCop should no longer complain about those words. If you examine the build output window, Visual Studio makes a call to FxCop.exe with a whole load of parameters. Setting the build action property of the xml file to CodeAnalysisDictionary, makes VS include the switch /dictionary:"" to the FxCop command.
You can also just amened the CustomDictionaryl.xml file in the FxCop default installation directory but this obviously only takes effect on that machine. I like being able to check this dictionary file into source control so that other team members can benefit from it and this also includes the build server.

Reusing the dictionary across assemblies
Another common situation is that you have more than one assembly and you want to share the same dictionary across them. One way of doing this is to add your dictionary file to the solution rather than a specific project. Then, add an existing item to your project, browse to the dictionary file in your solution, and select add as link. This add the dictionary file to your project and makes the link act like a shortcut to the dictionary file in your solution. This means you only physically create one dictionary file which is then easily shared across all your assemblies. Remember, you must still set the build action property on the link file in order for it to be recognised as a code analysis dictionary.
Note: You don't actually need to add the dictionary.xml file to the solution, but it obviously must be checked into your source control system and it should be referenced relatively, not absolutely.

The reason
In most projects I've seen, the code analysis rule CA1704 - Identifiers should be spelled correctly is all too easily ignored by adding a rule to the global suppression file. Personally, I don't like this because I think the global suppression file should not be used as a custom dictionary, especially when there is an alternative. The custom dictionary method is much more portable across projects and it preserves the separation of spelling against genuine code analysis errors.

Standup meetings: Keeping them useful

2008-04-23T13:06:00.005+12:00

Every morning, we religiously hold a stand-up meeting to share information around the team - or at least, that is what's meant to happen. Over time, I've noticed that the whole idea of the meeting has been lost and people now attend the meeting because that's what they did yesterday and so it will go on until someone tells them to stop. The stand-up meeting is a technique taken from the Extreme Programming model and I believe it works effectively if you use it correctly.

A stand-up meeting every morning is used to communicate problems, solutions, and promote team focus.

So what does this mean? It means, you have to come to the meeting having prepared a synopsis of what you achieved yesterday focusing on the problems and solutions only. Don't talk about anything else. We only want to hear successes or failures and not all about your daily churn. Remember the audience that you are talking to - developers, testers, PMs, BAs, etc. They all have different interests but as a whole, they all must come together to ensure communication is effective across the team. This is the whole point of the meeting and everyone who speaks should bear this in mind and focus their content to suit the audience.

As a reference, here are some things I believe are not worth mentioning:

Daily churn - by this I mean we don't want to hear that you fixed a few bugs, added a comment to the order class and corrected a few spelling errors. This is not helpful information and doesn't affect anyone else apart from you. If you do fix a few bugs, say what they were and why they will help other people.
How you are tracking against your estimates is not productive on a daily basis because it's too granular. Project teams should also hold a weekly meeting that is more appropriate for this type of information. By all means highlight glaring errors in estimates, but don't talk about why you ran over by an hour on your last story card.
Anything that is implementation specific - remember your audience, save geek-speak for developers.
Any problems you are having that are not related directly to the project you are working on.

Typical things that I'd be interested to hear at the meeting are:

Solutions and successes. For example, we've worked out a more efficient way of loading information from the database. Or we have changed the structure of the build file making it easier to maintain and it has reduced the build time. People want to hear about what you've been doing and if anything you have done can help them in the future.
Problems - this means areas of the system that are causing longer development times or are very difficult to maintain. If you don't understand what or how you are meant to do something, raise this and identify someone who can help. If you sit on your own and never mention your problems, no one will know to offer help.
Milestones or notable achievements - everyone likes to celebrate.

If you have nothing worth saying, don't say anything. You are not required to say anything but you should always attend the meeting to hear what other people have to say. I bet that if you were to ask a team to repeat what someone said in the stand up meeting yesterday, they would not remember unless it was notable. No one wants to remember useless or boring information but we are "programmed" to remember anomalies so focus your information on notable items.

Finally, remember the rationale behind the meeting and why stand-up meetings are part of the XP methodology. As a team, we want to be continuously improving and each member of the team should be making suggestions to ensure this happens. The stand-up meeting is a forum for everyone to discuss their daily findings and making sure that, as a team, we solve those problems. Also remember that a stand-up meeting is not an excuse to stop talking during the rest of the day. It's more likely that you will talk to people in a similar role during the day and this should always continue, but use the stand-up meetings to bring the roles together and to form a team that communicates information effectively.

Team Foundation Sidekicks V2 Released

2008-01-15T14:48:00.000+13:00

Attrice Corporation released Sidekicks V2 on 7th January.

The version 2.0 of Team Foundation Sidekicks application provides all features available in previously released version 1.3.3, as well as new Code Review Sidekick. Significant number of bug fixes was also incorporated in that release; in addition, Team Foundation Sidekicks application now supports Team Foundation Server 2008.

This release also deprecates Team Foundation Sidekick Visual Studio add-in; all features previously available in add-in are now part of Visual Studio Integration Package (both for VS 2005 and 2008) which is in turn part of Team Foundation Sidekicks 2.0; new Code Review Sidekick is available as part of Visual Studio package as well.

Team Foundation Sidekicks application provides convenient GUI for a wide range of administrative and advanced TFS version control tasks. The version 2.0 stand-alone application includes Workspace Sidekick, Status Sidekick, History Sidekick, Label Sidekick, Shelveset Sidekick and new Code Review Sidekick. Team Foundation Sidekicks integration package for Visual Studio 2005/2008 includes Code Review Sidekick, source control items search, dynamic history and build types editing features.

Download from here

Too much Resharper...

2007-11-26T08:03:00.000+13:00

You know you've been using Resharper too much when you press F12 in a Word document expecting to be taken to the next spelling error! :)

However, now I think of it, it would be a good thing.

Mingle 1.1 Released

2007-11-02T08:20:00.000+13:00

ThoughtWorks Studios have now released Mingle 1.1.

The new changes are documented here. There is post installation documentation here which might be useful when learning about the new card types and how to start using them.

A word of warning - Once you installed the new version and launched the website, the installation says "...this could take a very long time". They weren't joking! It took several hours on my machine. I've no idea how long it actually took because I had to leave it running all night. However, it did successfully upgrade in the end. The strange thing was that during the upgrade process, the CPU is hardly used. What was it doing?!

Not had a chance to use the new features yet but from the documentation they look encouraging. Nice work ThoughtWorks.

Download Mingle R1.1

ScreenGrab! for Firefox

2007-10-26T13:28:00.000+13:00

Browsing around recently, I came across ScreenGrab for Firefox.

Screengrab! is an extension for Firefox that makes it easy to save a web-page as an image. With it, you can save anything that you can see in a browser window - from a small selection, to a complete page.

If you are a web developer and need an easy way to convert sections of a page or an entire page to a .png file, this the tool for you. It would be very useful when supplying clients with page screen shots.

IMAP Released for GMail

2007-10-26T13:19:00.000+13:00

Finally, IMAP is available for free on GMail.

It was only released within the last few days and is still being rolled out to everyone.

Here is the official word.

Great Mistakes in Technical Leadership

2007-10-03T08:32:00.000+13:00

Came across this article on Hacknot.

It's worth a read.

From the article:

A Technical Lead lacking in self-confidence can be a major frustration to their team. They may find themselves waiting on the Lead to make decisions that significantly effect their work, but find that there is some reticence or unwillingness to make a firm decision. Particularly when new in the role, some Technical Leads find it difficult to make decisions in a timely manner, for they are paralyzed by the fear of making that decision incorrectly. Troubled that a bad decision will make them look foolish, they vacillate endlessly between the alternatives, while their team mates are standing by wondering when they are going to be able to move forward.

I'm online with Plugoo

2007-10-02T07:48:00.000+13:00

I've just added Plugoo to my blog and gave it a test run last night. What a cool idea!

Thanks to Plugoo, visitors on your webpage, friends or family, can easily chat with you while visiting your website!

Plugoo enables you to chat directly from your Instant Messenger with any visitor of your blog, personal webpage or e-sales site.

When you’re logged into your Instant Messenger (Windows Live Messenger, Yahoo! Messenger, AIM, GoogleTalk, Jabber or ICQ), you can receive in real time all the comments of your visitors or any question they might ask, and answer instantly!

It's very easy to sign up and get it working on your website or blog. If you are reading this from my blog directly rather than a feed reader, make sure you say hello!

Google Apps includes presentations

2007-10-02T07:30:00.000+13:00

Google have just released another application to add to their Doc & Spreadsheet Google App suite called presentations.

As far as I can see, Google have recreated Microsoft Office online. Well done Google!

Word = Documents
Excel = Spreadeheets
Outlook = Calendar + Gmail + todo
PowerPoint = Presentations

The rest of the Office suite doesn't matter. No one uses it anyway!

I wonder how long it will be before businesses will starting using Google Apps in earnest?

Mingle Roadmap

2007-10-01T08:45:00.000+13:00

There are a few nice things coming our way in Mingle before Christmas. This pdf shows a roadmap at a glance. I'm particularly interesting in parent-child card relationships and CruiseControl integration both of which I'll need to wait until v1.2 scheduled to be release in December.

However, there are plenty goodies in version 1.1 that will keep me interested in the meantime such as card printing, enhanced transitions and date properties to allow card scheduling.

It's not surprising that the Mingle development team use Mingle themselves and here is a picture of their current card wall for release planning.

Of all these goodies, I'm still concerned about the memory use of MingleServer.exe. It seems to take up a huge amount of memory which I understood was to be fixed in the RTM release. If anyone out these knows how to make this memory use any better, I'm all ears.

Shared Posts

2007-09-12T12:32:00.000+12:00

I've starting using Google Reader in earnest now and one of its features is the ability to share items on my blog from feeds that I read. Basically, I act like an aggregator for the items that I think are worth sharing.

This is separate from my blog feed so if you are interested, you can subscribe to my shared items list list using this feed ,or you can see it on the homepage of my blog.

Setting up .NET Development Trees in Visual Studio

2007-09-10T08:01:00.000+12:00

I had the intention of talking about best practice ways of setting up a Visual Studio solution including which are the best tools followed by a step by step guide of how to do it. Well, it looks like someone beat me to it! This pdf from Mike Roberts does exactly that. What was interesting is that we set up our VS solutions very similarly and use most, if not all of the same tools. But then again, Mike Robert's is from ThoughtWorks and our Development Manager is ex ThoughtWorks - Amazing how the information flows between companies! ;)

Talking of development tree structures, there is a tool on CodePlex that generates your solution tree for you in line with how Mike Robert's document suggests. It's called Tree Surgeon. It's very simple but it provides a good start.

TechEd New Zealand is underway

2007-08-13T21:58:00.001+12:00

TechEd 2007 started today starting witht the keynote speech given this year by Lou Carbone. It was brilliant! It is soon to be posted on the TechEd NZ site soon and I recommend that you watch it. It is very inspirational. Some more info on this on Darryl Burling's blog and Nigel Parker's blog

Intergen were dressed in their ususal "outstanding" outfits making our mark on the NZ community.

I went to the following events:

DEV346 Next Generation Team Foundation Server
Having already played with TFS quite a bit, I didn't learn a great deal from this session. However, what i did learn is that there is a way to gain access to TFS source control using a SVN client! So that means we could use TortoiseSVN from Windows Explorer to manage TFS source control - how cool!
ARC304 Architecting Next Generation Business Applications
This was heavily focussed on MOSS which wasn't for me so didn't take a lot away from this session
ARC306 UX - Interface Design patterns
This was an interesting session showing the possibilities of user interface design. It included a few video clips showing Photosynth, some multi-touch tabled demos from Jeff Han all giving us plenty of ideas for our next user interface.
DAT304 The Next Release of Microsoft SQL Server: Overview
There are a few cool additions to the next vesion of SQL Server codenamed "Katmai". I particularly liked the automatic page recovery feature of a mirrored database! Check out the rest of the features on the Microsoft site.
The July CTP of SQL Server 2008 is now available for download

A great start to TechEd 2007. Hopefully tomorrow will continue to be as good...

Intergen setting up at TechEd 2007

2007-08-12T19:34:00.000+12:00

Well, Tim and the rest of Tech Services did a great job of setting up the hand on labs room at TechEd this year. Well done guys!! The lab room looks cool and aparently everything is working just fine... fingers crossed!

Nothing of note has happened so far, but that's because Ben wasn't there to entertain us with a brooks-worthy cockup!! Still, 3 days left for that, eh Ben!

Shaun made a stellar effort of setting up the Intergen stand complete with an shot-em-up arcade machine. Tim and I had a game and got hooked in pretty quickly! If I'm not on lab duty or attending a session, you'll find me playing games at the Intergen stand.

As ever, the TechEd bag is quite funky and comes with a bundle of advertising inside, the most controversial of which was a brochure from Absolute IT doing a salary review. :) It's worth a read.
No free copies of Vista yet but I'm on the lookout.

To keep everything central, I've setup a Facebook group called Intergen TechEd 2007 for all the photos, videos, thoughts and new from this years event. It's an invite only group so if you're from Intergen, ping me an email and I'll add you in. There is a link to my Facebook public profile at the top of my blog and from there you can look at my groups to find the TechEd 2007 one.

Adding statistics to your blog

2007-08-10T08:00:00.000+12:00

Add stats to your blog with Statcounter.

I've added some statistics to my blog so I can see who is looking at what. Nice to see the demographics of who visits your blog! It's very easy to sign up and there are loads of config options. Some of the stats are very interesting, especially the demographic map one!

A free yet reliable invisible web tracker, highly configurable hit counter and real-time detailed web stats. Insert a simple piece of our code on your web page or blog and you will be able to analyse and monitor all the visitors to your website in real-time!

Formatting your code for blogging

2007-08-02T13:11:00.000+12:00

In my previous post, I was trying to insert XML into my blog entry. Blogger isn't very helpful and makes a mess of XML and any C# or VB code entrys.

However, there is a formatting tool which outputs 4.01 compliant HTML which you can paste directly into your blog! It parses c# vb, xml, t-sql and others and does it very nicely.

Here is a sample of c# output:


using System.Windows.Forms;

namespace Vulcan.Borat.WinApp.UserControls
{
    public partial class ProductPanel : UserControl
    {
        public ProductPanel()
        {
            InitializeComponent();
        }
    }
}

Using NUnitForms with NUnit Framework 2.2.9

2007-08-02T11:48:00.000+12:00

NUnitForms has been compiled to work with NUnit framework library 2.2.7. However, NUnit have released a new framework which can be made to work with NUnit 2.2.9 quite easily.

By default, if you put NUnitForms and NUnit Framework 2.2.9 into the same project, you will get the error message

Could not load file or assembly 'nunit.framework, Version=2.2.7.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77' or one of its dependencies. The located assembly's manifest definition does not match the assembly reference. (Exception from HRESULT: 0x80131040)

along with a further error

WRN: Assembly binding logging is turned OFF. To enable assembly bind failure logging, set the registry value [HKLM\Software\Microsoft\Fusion!EnableLog] (DWORD) to 1. Note: There is some performance penalty associated with assembly bind failure logging.
To turn this feature off, remove the registry value [HKLM\Software\Microsoft\Fusion!EnableLog].

However, you can use NUnitForms with NUnit 2.2.9 if you get the test project to perform some assemble redirecting. In your test project, create an app.config file and add the following XML to redirect NUnitForms assemble to use the NUnit Framework 2.2.9 assembly:

<?xml version="1.0"?>
<configuration>
  <runtime>
      <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
          <dependentAssembly>
              <assemblyIdentity name="nunit.framework" publicKeyToken="96D09A1EB7F44A77" culture="neutral"/>
              <bindingRedirect oldVersion="0.0.0.0-2.4.0.2" newVersion="2.4.0.2"/>
          </dependentAssembly>
      </assemblyBinding>
  </runtime>
</configuration>

Recompile and run your NUnitForms tests and your working :)

Mingle v1.0 Released

2007-08-01T15:50:00.000+12:00

ThoughtWorks Studios have released Mingle v1.0 to the public.

You can download a 30 day trial version

Mingle

2007-07-19T08:28:00.000+12:00

Mingle is a software application that helps you and your team manage Agile IT projects.
It supports software delivery by providing the whole team with a single place to share all project output using a framework based on over 7 years of ThoughtWorks' Agile experience.

Mingle provides project intelligence for teams that need to make real-time decisions based on Agile metrics collected from everyday activities.

I've had a play with Mingle recently and so far it looks like a great piece of software, even though it is still an alpha release. It is developed and supported by ThoughtW orks Studios. You can register you interest in Mingle which I did and was given access to download the software the next day.

Mingle uses MySQL or PostgreSQL as a back end database and the installation was simple and problem free. It integrates with Subversion for tracking your code against the requirements

Well worth checking out Mingle if you are looking for a tool to help you with agile project management and centralising your project information

Get latest before checkout

2007-07-17T09:00:00.000+12:00

One difference between Visual Source Safe (VSS) and the version control in Team Foundation Server (TFS) is that VSS performed a get latest operation before checking out a file but TFS does not offer this functionality. This caused an issue for a few of my colleagues and until now, I didn't know of a way around this problem. For those that are interested, Greg found an article here that describes how to alter this behavior and you can download the file from CodePlex. However, the add in doesn't do it for me because IMHO, you should NOT perform a get latest before you checkout and file and here is why.

Microsoft have lulled us into a bad head space when it comes to source control. No source control system should manage state, but VSS and TFS both manage state on the server. This just causes no end of problems and doesn't represent what source control is all about. The topography of source control should be a hub & spoke situation - once a client performs a get latest on the server, the server does whatever it needs to to provide the information to the client and then severs the connection. The server should not maintain that Joe Bloggs just checked out file x because it makes absolutely no difference. What if that person kept file x checked out forever? Would it matter? No, not at all. What matters is what goes into the repository, not what comes out of it. In fact, the whole concept of check out is flawed. It's not that you are checking out the file, it more that you want to make changes to a file. In TFS land, check out means "update the server with a record saying that I'm maybe going to edit a file" and undo checkout removes the record. What's the point of maintaining that you might do something? Ultimately, once you have the latest source on your machine, you shouldn't need to contact the repository again until you want to commit the files.

Take this scenario:

there are two developers, Bill and Ben
Bill makes changes to the customer code file
Ben makes changes to the customer code file
Bill checks in his changes
Ben checks in his changes

What happens here? Whose changes are accepted? What actually happens is the server performs a merge on every check in and if the code can be merged without conflicts, the changes are merged and accepted into the repository. So in this case, as long as Bill and Ben's changes merge successfully, there will be no issues and their changes will be merged together.

However, there is a fundamental step missing from this scenario which causes the most headaches. Before you check in, you should always perform a get latest. If you don't, the version control system will attempt to merge your changes together but it's a horrible position to be in to be caught short when your trying to update the repository. A much better approach is to perform a get latest on the entire solution before you check in. This way, any files that have changed are brought to your machine locally and you can merge/diff/rebuild the project and run your tests before checking in.

Lastly, and my main point about why get latest is bad before checkout, imagine this scenario:

There are two developers Bill and Ben
Ben makes changes to the customer file and these changes require changes to several other files file to complete the change successfully
Bill wants to edit the customer file and he does a get latest before he starts. When he tries to compile, it will fail because he did not get the related files that Ben changed, only the customer file. Therefore, Bill also has to get all the other necessary files to make the solution compile. He doesn't know which files these are and so ends up having to get latest on the entire project

This scenario is bad because you haven't completed doing what coding changes you were working on and yet you've had to mix changes from other people. Basically, you should not perform a get latest on a individual file otherwise you are only getting a partial get latest when it comes to building the entire solution. Also, before performing a get latest, you should finish your own changes first and ensure it compiles and passes all the tests before introducing changes from other member of the team through a get latest. Remember, get latest cannot be undone, so if you have your IDE perform a get latest before you check out a file and you end up in the above situation, you could spend a lot of time putting things back together before you are ready to.

In general, when you are working with source control, you should follow this procedure:

Make changes to the source
Build the solution and run your tests
Perform a get latest on the entire solution
Build the solution and run your tests
If it builds and all the tests pass, check in

Get latest on an individual file is fine if you understand the repercussions of what you are doing, but having your IDE automatically get the latest copy of a file before you check out defeats the purpose of having a source control system there at all. Assuming it were possible, why not just have all team members working from a central file resource so they alway have the latest files? Can you imagine what this would be like? This is exactly what is recreated if you get the latest version of a file before you make changes to it.

Leadership and Management

2007-06-13T08:43:00.001+12:00

I came across these two definitions which I thought distinguished the difference between leadership and management effectively.

Leadership without management

...sets a direction or vision that others follow, without considering too much how the new direction is going to be achieved. Other people then have to work hard in the trail that is left behind, picking up the pieces and making it work. Eg: in Lord of the Rings, at the council of Elrond, Frodo Baggins rescues the council from conflict by taking responsibility for the quest of destroying the ring - but most of the management of the group comes from others.

Management without leadership

...controls resources to maintain the status quo or ensure things happen according to already-established plans. Eg: a referee manages a sports game, but does not usually provide "leadership" because there is no new change, no new direction - the referee is controlling resources to ensure that the laws of the game are followed and status quo is maintained.

Leadership combined with management

...does both - it both sets a new direction and manages the resources to achieve it. Eg: a newly elected president or prime minister.

Read the source article