Michael Sevestre's Blog

Setting up a Ubuntu 10.10 machine

2011-08-04T10:00:00.000-04:00

My first thought was to start my rails journey on a Win7 machine. There are a few tutorial out there and even an msi package installing ruby and rails for you for windows.... It did not take me long however to realize, that even if you can get rails running on windows, most tools and tutorials are tailored for a Linux based machine. If learning something new, better learn it right, eh?

I am not a Linux expert whatsoever so I wasn't sure where to start. What distribution to install, which version etc... A little bit of research revealed that the Ubuntu installation is a favorite in the Rails community.... Does that mean that I have to install a Linux Ubuntu system from scratch?!? The short answer is no! You can actually download a VM Image of a fully configured Ubuntu 10.10 machine. How neat is that? The only thing left is to install a VMWare player and you're good to go. You have a Ubuntu machine working. Great!

So Friend, don't be afraid to leave the Microsoft world completely and embrace the power of Ubuntu. It's so easy to get started. If you screw up the installation, no big deal, just unzip the downloaded image and you have a clean start! (unless you have a VMWare Workstation which allows you to take snapshot of your machine at any time...in that case, you just need to revert to a snapshot).

Learning Ruby and Rails

2011-08-03T13:47:00.004-04:00

I have been doing Microsoft Development for most of my career, mostly using .NET and C#. I feel confident in my ability to tackle any project using this platform. It is a great feeling, no question about that, and I am always excited to start a new project.

Of course, even in C#, I am far from knowing everything! There is always something to learn especially with the new features such as the Asynchronous library that will be released in C# 5. But for now, I want to learn what I really don't know about the "other (non-Microsoft) side" of things. There is a lot of noise about Ruby and Rails and a growing demand for Ruby on Rails developers, so learning to build sites with Rails is certainly not a bad idea, is it?

I spent the last few weeks deep diving into ruby and rails, feeling happy by the incredible possibilities offered by Ruby and overwhelmed at the same time by the new syntax and inherent philosophy. There is definitely a steep learning curve when coming from a static language like C#.

Learning by doing is for me the best way to integrate and understand the core concepts of a new technology. So guess what! I will spend a lot of time trying stuff out. Be prepare to see a lot of posts relating my journey to the other side and away from the comfort zone!

Optimizing components registration in Castle

2011-07-28T10:43:00.002-04:00

Some of our users complained that the time needed to start one of our desktop application was too long (~50s). There is a lot of things happening under the hood when starting the application so I decided to use my favorite profiler tool (yeah I know, jetbrain again!) to profile the application.

The new version of the profiler comes with a bunch of new features. Since I wanted to exactly know what was happening and where time was being lost, I went with the high accuracy mode and of course, checked the start profiling immediately since the time spent to start the application is our concerned.

The results were really interesting and I could not really believe it at first: 70% of the time was spent registering components in our IoC Container of choice. Castle! Looking closer at the profiler output, I could see that we were registering close to 1000 components in the container (991 exactly). The registration is (of course) based on some predefined convention (yeah convention again) to register the type automatically in the container. 1000 components is a lot, but nothing too crazy and there is no way so much time should be spent just to register them anyways.

Now look at what happens here. The components validation is taking 96% of the overall registration time. I guess the kernel is always trying to check if a component being registered is valid or not. If you have a lot of invalid components (which happens obviously when registering components with convention), the time spent in validation degenerates to an O(N^2/2) operation! There had to be a way to disable the validation and optimize the registration....

And indeed, I found the OptimizeDependencyResolution! Apparently this is a way to optimize registration, but it breaks startable facility in castle 2.1, which happens to be the version we are using currently. I decided to take the plunge and upgrade to castle 2.5, where a fix was provided. It meant also updating to NHibernate 3.1 and FluentNhibernate 1.2...ARGHHS versioning hell all over again. An hour later, I was back on track and the app was running. At that point, I was so glad that we had integration tests to test our FluentNhibernate mapping etc... Upgrading all at once without that security net would have been a real nightmare otherwise.

Back to our OptimizeDependencyResolution. The only thing that was left to do was to encapsulate the registration with

using (kernel.OptimizeDependencyResolution())
{
//do registration logic here
}

The time to load the application with that one only code change dropped to 9s! Wow now we're talking!

So Dear Reader, don't spend time guessing where you can optimize your code. First only optimize when a performance problem occurs, NEVER BEFORE! Then use a profiler to discover the bottleneck of your application.

Test your conventions with reflection

2011-07-27T10:17:00.010-04:00

I am not a big fan of using reflection in .NET. Most of the time, people believe that reflection is well known, easy to understand and part of the standard tools available to all .NET developers. I strongly believe that reflection can do more harm than good. Used wisely however, it can be really helpful...let see an example!

In one of the application I am working on, we encapsulate all the user actions changing the underlying domain in command objects, using the well-known command pattern. Each command should be kept into a command history so that one can track at all-time what has changed and how. One requirement to the system is the ability to rollback to any previous state of the project (and thus reverse all changes made since that state) and AT ALL TIME. Yes dear readers, it means that on top of the domain, the history of all command needs to be persisted as well.

We have an in-house Xml Serialization Framework that we use to serialize the commands. In order to serialize a Command, let say a DeleteCommand, we need to define an object implementing the ISerializer<DeleteCommand> , for instance DeleteCommandSerializer. Now we have hundreds of commands in the system. How to make sure that we don't forget to write a serializer for a new command? In other words, how to ensure that our convention "Each command should have a serializer" is met? Write a test!

It's where reflection comes into play:

[Observation]
public void each_concrete_command_should_have_a_defined_serializer()
{
var commandAssembly = typeof(ICommand).Assembly;
var allCommandTypes = commandAssembly.GetConcreteTypesImplementing<ICommand>();

var serializerAssembly = typeof(ISerializer).Assembly;
var allSerializerTypes = serializerAssembly.GetConcreteTypesImplementing<ISerializer>();

var allImplementationType = new Collection<Type>();

foreach(var type in allSerializerTypes)
{
foreach(var typeForGenericType in type.GetDeclaredTypesForGeneric(typeof(ISerializer<>)))
{
  if (allImplementationType.Contains(typeForGenericType.DeclaredType)) continue;
    allImplementationType.Add(typeForGenericType.DeclaredType);
}
}

var errorList = new List<string>();
foreach(var type inallCommandTypes)
{
if (allImplementationType.Contains(type))
  errorList.Add(string.Format("No serializer found for {0}", type));
}

Assert.IsTrue(errorList.Count == 0, errorList.ToString("\n"));
}

Looking at the code above there are a few items I should point out

This will retrieve all the types implementing ICommand and all the types implementing ISerializer. We suppose that all commands are defined in one assembly as well as all serializers. (that might be however the same assembly). We use the useful extension method defined here.
Then we retrieve the actual type used in the open type ISerializer<>. For that I use another extension method, GetDeclaredTypesForGeneric that returns MyType (the so called DeclaredType) for a generic ISerializer<MyType>. If you are interested in the implementation, drop me a line and I will blog about that as well.
Last we want to log the error. Note the use of a list to save the error. The assertion only happens at the very end of the test so that we get the exhaustive list of all commands without a serializer.

Friends, my advice is to always test the convention in your system. That will bring joy and happiness in the long run and enhance your productivity.

Finding types in an assembly implementing another type

2011-07-27T09:22:00.005-04:00

The other day I had the need to retrieve the types defined in an assembly that were implementing another given type. How would you do that? Here is my solution:

public static IEnumerable<Type> GetConcreteTypesImplementing<T>(this Assembly assembly)
{
  return assembly.GetConcreteTypesImplementing(typeof(T));
}

public static IEnumerable<Type> GetConcreteTypesImplementing(this Assembly assembly, Type typeToImplement)
{
  return from type in assembly.GetConcreteTypes()
         where type.IsAnImplementationOf(typeToImplement)
         select type;
}

public static IEnumerable<Type> GetConcreteTypes(this Assembly assembly)
{
  return from type in assembly.GetExportedTypes()
         where !type.IsGenericType
         where !type.IsAbstractClass()
         select type;
}

The code here is fairly simple. The idee is to query all exported type in the assembly filtering out the generic and abstract types. Note that IsAbstractClass is another extension methods:

public static bool IsAbstractClass(this Type type)
{
  return (type.IsAbstract || type.IsInterface);
}

Prevent Resharper from adding regions!

2011-04-01T09:00:00.005-04:00

Resharper is an amazing tool that I use every day. I could certainly not do without anymore. There is one really annoying thing with it however: Its default behavior is to wrap interface implementation in a region!

Unless your code is being generated automatically, regions are just noise to me. If you need them to make your code easier to understand, I bet that your code is doing way to much and is certainly violating the Single Responsibility Principle.

The good thing with Resharper is that you can configure almost everything! Turning off regions for interface is a bit trickier than expected. I’m sure this has been blogged about thousands of times. I was just asked again how I managed to get rid of them but could not find it, so I wanted to capture it someplace useful.

Follow this steps, and you will be region free:

Go to Resharper -> Options
Go in the left pane to C# ->Formatting Style ->Type Members Layout
Unchecked "Use Default Patterns"
A scary XML appears on the right pane. It looks scarier than it is so stay calm
Find the section marked by
Find the tag <entry>

Remove

<group>
<implementsinterface immediate="true" region="${ImplementsInterface} Members">
</implementsinterface>
</group>

That's it!!

Nice Feature in Rhino.Mocks. The Do() handler

2011-03-31T20:00:00.007-04:00

I have been working with Rhino.Mocks for quite a while now and believed I knew most of the goodies available in this tool. Today I was proven wrong!

Using the extension methods Stub on a mock object, you can specify the return value for a method when being called. Keep in mind that you do not create an expectation for this method.

A sample code could be something like:

_orderFactory.Stub(x=>x.CreateOrder()).Return(new Order());

Notice that each and every time the method CreateOrder() is called on the mock object _orderFactory, the same static object created in the first method call will be returned.

Now this behaviour is more than enough for most of the tests I write. But there are times, like this morning, where I needed the CreateOrder() method to always return a new instance of Order when called. There is a really easy way to do it. Using the Do() handler:
The signature of the Do() is pretty scary at first. It takes a Delegate. That's right, an old .NET 1.0 Delegate which is not strongly typed. That's also the reason why its use can be really powerful:

_orderFactory.Stub(x=>x.CreateOrder()).Do((Func<Order>)(() =>new Order()))

And that's it! Every time the CreateOrder() method is called, the mock will return a new Order.

On a side note, I don't like to use the word stub or mock in the code, since it tends to decrease the code readability. I have created an extension method that helps make the code easier to understand

public static class RhinoMocksExtensions
{
/// 
/// Setup a result for the given function call
/// 

public static IMethodOptions<R> SetupResultFor<T>(this T mock, Function<T, R> func) where T : class
{
return mock.Stub(func);
}
...
}

//using this extension method, stub call would be
_orderFactory.SetupResultFor(x=>x.CreateOrder()).Do((Func<Order>)(() => new Order()));

Sweet!

BDD Style - How to organize your files / folders

2011-01-10T19:00:00.004-05:00

One thing that can become really tricky when using a BDD style approach to develop software is the organization of files and folders within a visual studio solution.

A common approach is to create one project containing all the unit and integration tests for the application. This means in general that you have to duplicate the folder / namespace structure from the application itself in the test project. It could look something like this.

Intuitive at first, this approach has one major drawback. The time spend moving file when refactoring a namespace or a folder increase drastically. You always have to keep in mind that you must duplicate the modifications made to the application folder structure in the test project, which of course might easily be forgotten.

We have adopted a slightly different yet powerful approach to structure our tests in a solution. Instead of creating a project for our tests, the specs/tests file lives beside the code it is testing.
For example, if we have a class CustomerRetriever, the specs/tests will be in the file CustomerRetrieverSpecs.cs that resides in the same project and namespace as the CustomerRetriever. Thanks to this organization, there is no need to duplicate any folder structure in a test project and we can see with a single glance if a portion of code has not been tested (means there is no xxxSpecs.cs file for that class). Such an organization could look something like this:

This approach is of course only usable if the .NET system is being build using NAnt, rake, albacore etc.. since only a subset of the files should be used to build the assemblies.

In NAnt for example you would have to use the <csc> Task with a fileset


<fileset id="app.sources">
  <include name="${src.dir}\**\*.cs"/>
  <exclude name="${src.dir}\**\*Specs.cs"/>
</fileset>

In Albacore, Derick Bailey created following syntax to achieve the same goal.


csc :build do |csc|
  csc.command = "csc.exe"
  csc.compile FileList["src/**/*.cs"].exclude("src/**/*Specs.cs")
  csc.output = "myproject.dll"
  csc.target = :library
end

Migration to Fluent NHibernate

2010-12-27T18:00:00.007-05:00

A few months ago, I decided to take the plunge and migrate our existing NHibernate xml mapping to the fluent version using the Fluent NHibernate API. At that time I was following the development of the Fluent NHibernate project and felt that the product was mature enough to use in production.

The really good surprise: the migration to Fluent NHibernate was really easy. For almost all our existing hbml files, the migration was straight forward. Only a few mappings required some more searching (and guessing) but nothing that could not be found...eventually.

Migration strategy:
When migrating a system, the key is to try to make as few changes as possible. Obviously, the more you change at once, the higher the chance is that something is broken.
The other good surprise: Fluent Nhibernate fully supports side-by-side hbml and fluent mapping which makes the migration strategy feasible. Sweet!
Here is what I did:

1-Let Fluent NHibernate load your existing configuration:
The first thing to do is download the last version of FluentNHibernate. Reference the FluentNHibernate.dll. Then I had to modify our configuration so that FluentNHibernate is now in charge of loading our hbml mapping. In our case, we used the configuration object:


private Configuration createConfigurationFor(string dataSource)
{
   var config= new Configuration();
   config.SetProperty("connection.provider", "NHibernate.Connection.DriverConnectionProvider");
   config.SetProperty("connection.driver_class", "NHibernate.Driver.SqlServerCeDriver");
   config.SetProperty("dialect", "NHibernate.Dialect.MsSqlCeDialect");
   config.SetProperty("connection.connection_string", string.Format("Data Source={0}", dataSource));
   config.SetProperty("connection.release_mode", "on_close");
   config.SetProperty("proxyfactory.factory_class", "NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle");
   config.SetProperty("show_sql", "false");
   config.AddAssembly(typeof(SessionFactoryProvider).Assembly);
   return config;
}

In this example, SessionFactoryProvider is a class that creates the NHibernate Configuration object which is later used to create a SessionFactory. The only thing I had to do here is replace the last line returning the configuration with


return Fluently.Configure(config)
 .Mappings(cfg => 
    {
       cfg.HbmMappings.AddFromAssemblyOf<sessionfactoryprovider>(); 
       cfg.FluentMappings.AddFromAssemblyOf<sessionfactoryprovider>();
    }).BuildConfiguration();

And that's it. FluentNHibernate is now in command and loads our hbml mappings. It's a good first step, yet not really exciting. Time to get rid of our old hbml mappings!!

2-Migrate the hbml mapping files.
As mentioned before, the key is to make as few changes as possible. So I decided to migrate one file at a time (and one only)

create a new ClassMap for the entity matching the file being replaced.

delete the original hbml file (so that it's not loaded in the configuration)

run the tests covering the basic CRUD operations, if you have any, and make sure they're still green.

Last but not least, perform a schema compare to ensure that nothing has changed

Repeat for all hbml files!

This time, that's really it! Congrats! If you have followed these few steps, you should have migrated all your existing hbml mappings to their fluent contra-parts. In the unlikely, yet possible event, that you are using some advanced NHibernate features which are still not supported by the fluent mapping, you can keep the hbml mapping. Remember, FluentNHibernate supports side-by-side hbml and fluent mapping. For the craziest among us, you can even split mapping for one entity between hbml and fluent mapping!...to use at your own risk :-)

Happy fluent mapping!

How to generate gaussian random numbers in .NET - Part2

2010-12-20T21:00:00.002-05:00

In one of my last post, we talked about how to generate gaussian random numbers and introduced the class RandomGenerator.

Let's now see how to use it and take a real life example of a variable that follows a normal distribution.

According to the ICRP Data 2002, the height of a 30 years old European man follows a normal distribution with a mean of 176cm and a standard deviation (std) of 8.8 cm. Our goal is to generate a set of random heights following this distribution.

Let's first create a fairly basic NormalDistribution class that will encapsulate the behavior of the normal distribution.


public class NormalDistribution
{
 private readonly double _mean;
 private readonly double _deviation;

 public NormalDistribution(double mean, double deviation)
 {
    _mean = mean;
    _deviation = deviation;
 }

 ...

 public double GenerateRandomDeviate(RandomGenerator randomGenerator)
 {
    return randomGenerator.NormalDeviate() * _deviation + _mean;
 }
}

The only thing we need to do now is generate a few normal deviates (here 100000) and plot them in a bar chart.


var normalDistibution = new NormalDistribution(176, 8.8);
var randomGenerator = new RandomGenerator();
var randomNumbers = new double[100000];
for (int i = 0; i < randomNumbers.Length; i++)
{
  randomNumbers[i] = normalDistibution.GenerateRandomDeviate(randomGenerator);
}

we recognize the bell-shaped curve we were all waiting for!

Hope this helps,

I tried dotCover and I love it!

2010-12-16T18:25:00.002-05:00

We've been using code coverage analysis as part of our continuous integration process for a while now. The tool of choice thus far was the free version of NCover. I decided to try the new coverage tool 'dotCover' from Jetbrain. You can download a 30 day trial version here. So far I am really pleased with the product:

The integration in Visual Studio (2008 and 2010) as well as in Resharper test runner is, as always with Jetbrain, flawless.

An new interesting feature that was not availale in NCover (at least in the free version): you can navigate from a certain piece of code to the tests covering that code.

Being a huge keyboard freak, I am happy to see that shortcuts are available: ALT + R + U + O starts a test in coverage mode, while ALT + R + U + R starts the Resharper runner for a given test.

Last but not least: It's also possible to use dotCover with Continuous Integration: A console runner is available that runs coverage reports from the command line so that you can start the tool from your rake, NAnt, MSBuild, you-name-it script. If you are using the newer version of TeamCity (Version 6 as of today) the integration is already there, as TeamCity includes a bundled version of dotCover out of the box.

All in all a really good product. I am a fan of Resharper and dotTrace and I believe dotCover is the natural extension to my toolbox.

How to generate gaussian random numbers in .NET - Part1

2010-12-14T20:48:00.000-05:00

A pompous blog title for a subject that comes up in my projects much more frequently than I would have ever expected.

Our goal is to generate a series of random numbers based on a given Gaussian (normal) distribution.

There are few good mathematical methods available to achieve this goal. There is one however, that has proven to be fast, stable and reliable called the Box-Muller transformation. It allows to transform some uniformly distributed random variables, into a new set of normally distributed random variables. I will not go into the algorithmic details of the transformation, since it has been described thoroughly here or here.

Good implementation of that method for .NET is however hard to find! Here is one in C# that is adapted from the C implementation in Numerical Recipes page 289.


public class RandomGenerator
{
   private readonly Random _random;

   //indicates that an extra deviates was already calculated
   private bool _hasAnotherDeviate;

   //The other deviate calculated using the Box-Muller transformation
   private double _otherGaussianDeviate;

   public RandomGenerator() : this(new Random())
   {
   }

   public RandomGenerator(int seed) : this(new Random(seed))
   {
   }

   public RandomGenerator(Random random)
   {
      _random = random;
   }

   // returns a normally distributed deviate with zero mean and unit variance.
   // Adapted from Numerical Recipe page 289: Normal (Gaussian) Deviates
   public double NormalDeviate()
   {
      double rsq, v1, v2;
      if (_hasAnotherDeviate)
      {
         //we have an extra deviate handy. Reset the flag and return it
         _hasAnotherDeviate = false;
         return _otherGaussianDeviate;
      }
      do
      {
         v1 = UniformDeviate(-1, 1); //pick two uniform number
         v2 = UniformDeviate(-1, 1); //in the square extending from -1 to +1
         rsq = v1 * v1 + v2 * v2;    //see if they are in the unit circle
      } while (rsq >= 1.0 || rsq == 0.0);

      //now make the box-muller transformation to get two normal deviates.
      double fac = Math.Sqrt(-2.0 * Math.Log(rsq) / rsq);
      //Return one and save one for next time
      _otherGaussianDeviate = v1 * fac;
      _hasAnotherDeviate = true;
      return v2 * fac;
   }

   // Returns a uniformly distributed random number between min and max.
   public double UniformDeviate(double min, double max)
   {
      return (max - min) * _random.NextDouble() + min;
   }

   // Returns a random number between 0 and 1
   public double NextDouble()
   {
      return _random.NextDouble();
   }
}

This class encapsulates the generation of random uniform deviates as well as random normal deviates and has proven to be really handy.

In the next post, we will use the RandomGenerator on a real life example and generate a ton of Gaussian random numbers....sounds like fun :-)

Nitpicker corner:
I am actually talking here about "pseudo-random" number, as the sequence of generated numbers is deterministic given the pseudo-random generator algorithm and the seed value used to initialize the generator. So be advised, that when I use "random" in this article, I actually mean "pseudo-random".

Don't be fooled by the RealColumnEdit in a DevExpress GridView

2010-12-08T15:46:00.000-05:00

We are making heavy use of the DevExpress Components Suite for our Desktop applications. Today I stumbled upon a really weird behaviour in the GridColumn object that I wanted to share. It might help someone out there!

Context:
When binding a GridView to an object, let say a DataTable with 3 Columns, the fabulous databinding mechanism (note the sarcasm here) fills up the grid view automatically. Sweet. You don't have to specify anything and you even get for the same price a default editor for each column automatically assigned. Even better.

Let's take a look at some simple code to illustrate the problem at hand:


public partial class Form1 : Form
  {
     private readonly DataTable _dataTable;

     public Form1()
      {
         InitializeComponent();

         //create table
         _dataTable = new DataTable();
         _dataTable.Columns.Add(new DataColumn("double", typeof(double)));
         _dataTable.Columns.Add(new DataColumn("int", typeof(int)));
         _dataTable.Columns.Add(new DataColumn("bool", typeof(bool)));
         _dataTable.Columns.Add(new DataColumn("date", typeof(DateTime)));
         _dataTable.Columns.Add(new DataColumn("text", typeof(string)));
         //add a few rows
         AddData(1.1,1,true,new DateTime(2010,01,01),"hello");
         AddData(2.2,2,false,new DateTime(2010,02,02),"bonjour");
         AddData(3.3,3,true,new DateTime(2010,03,03),"guten tag");
         //bind to grid
         gridControl1.DataSource = _dataTable;
      }

     public void AddData(double value0, int value1, bool value2, DateTime value3,string value4)
      {
         var row = _dataTable.NewRow();
         row[0] = value0;
         row[1] = value1;
         row[2] = value2;
         row[3] = value3;
         row[4] = value4;
         _dataTable.Rows.Add(row);
      }
  }

These few lines of code and we get a nice grid with already some built-in editors:

Problem:
Now comes the tricky part. According to the documentation, if a repository item is assigned to the ColumnEdit property, RealColumnEdit returns this repository item. Otherwise it returns the default edit with respect to the column type.

What the documentation does not say, is that the default edit is actually the same instance of the editor with respect to the column type.In our example, the double, int and text column would actually be assigned the same instance of the editor. If you start to define some behavior to one of the assigned editor, you might get some weird bugs in your application.

Let say I decide to ensure that only numerical values can be entered in the double column. (index 0)
I could do that by simply defining a mask to the editor


var editor = (RepositoryItemTextEdit) gridView1.Columns[0].RealColumnEdit;
editor.Mask.MaskType = MaskType.Numeric;

It works fine for the double column. However the last column, which is sharing the same instance of the RealColumnEdit, only accepts numerical values as well!!

Solution:
When assigning special behavior to column editors, never use the RealColumnEdit. Instead, specify a new instance of the required editor by setting the property ColumnEditor and you will be good to go


var editor = new RepositoryItemTextEdit();
gridView1.Columns[0].ColumnEdit = editor;
editor.Mask.MaskType =MaskType.Numeric;

Hope this helps,

How to Move a Subversion Repository to Another Server

2010-12-05T20:33:00.000-05:00

Today I had to mirror our svn repository to another server. The task has been luckily made really simple by the svn team (thanx guys!):

Here is the procedure to follow:

Create a dump of the old repository

The best way to do it is to use the tool svnadmin in the console

svnadmin dump old_repository_path > repository.svn_dump
example: svnadmin dump c:\dev\svnrepos > repository.svn_dump

Create a new repository on the new server

svnadmin create path_to_new_repository
example: svnadmin create d:\dev\svnrepos

Import the backup repository into the newly created repository

svnadmin load path_to_new_repository < repository.svn_dump
example: svnadmin load d:\dev\svnrepos < repository.svn_dump

That's pretty much it. Hope this helps!

Note: To avoid any conflict during the process, make sure that none of your team mate is updating the old repository while creating the new repository...

Till next time,