If had it in C#, we would have less crashes because of the NullReferenceException.

In the real world I would not use this feature, because none of git bash, git extensions or tortoise git could work like this. But it is cool!

[UPDATE]:  At the beginning gitscc uses ngit (a jgit port) at the beginning, which works well with utf-8 file names. But it does handle autocrlf flag and not triggering hooks. Later on gitsscc uses msysgit instead. It then went into some issues related to non-ascii file names with msysgit.

Good news is that it looks like msysgit will soon have utf-8 support.

This is only relevant if you used non-ASCII file names with previous Git
for Windows versions (V1.7.6 and earlier).

Previous Git for Windows versions stored file names in the default
encoding of the originating Windows system, making these repositories
incompatible with other Windows language-versions and other Git versions (including Cygwin-git and JGit / EGit on Windows).

The Unicode-enabled Git for Windows stores file names UTF-8 encoded.

It displays commits horizontally with heads, tags and remotes annotations.

Other Git programs, such as Gitk, Git Extensions, TortoiseGit usually show git logs vertically. But Git documentations, books and tutorials usually use horizontal view to illustrate the structure of the Git repository. E.g the one from git-merge help page.

And the one from  Pro Git Book.

I believe horizontal view is easier to understand. A lot of documents that explain the concept of branching and merging use horizontal view. They even have traces back to SVN and CVS.

Anyway, What’s new in gitscc’s view besides being horizontal?

The view has simplified (or condensed) mode, which omits commits that are less important. It only shows commits that have refs (heads, tags and remotes) or have multiple parents/children. E.g. There are 5 commits in the following picture.

Using the simplified (or condensed) mode, it becomes like below.

The simplified view has huge benefits. It highlights the structure of the git repository with less tiny details. The first picture of this post is a simplified view of gitscc repository. 10+ commits between 0.7.0 and V0.8.0 are omitted.

It solves a concern of the idea of commit often. The concern was too many smaller commit crowd the log view. With the simplified view this is no longer an issue. Smaller commits won’t show up.

I am planning add more interactive actions to this new Git History View. E.g, I can drag the ‘master’ head and drop it on the ‘develop’ head. It triggers a merge of these two branches ……

Stay tuned. It will come in gitscc V0.9.

A preview (version as 0.6.8) has been released. Final version (0.7.0) will be release ready soon I hope. But UI like this has many tedious details. Any help is welcome,  please fork the source at github.

[UPDATE #1] The screenshot above shows that I use gitscc in developing gitscc. I noticed that with this new pending changes window, the recent commits I made are more organized, tidy and meaningful. This is truly a result of a convenient tool can provide.

[UPDATE #2] TFS gets the concept of “local”. Although it has only local workspace (working directory) and no local history yet, it is still a good news. It has not the instant diff view. But the its web page like pending changes display is interesting …

It has tab completion on commands and even on remotes and branch names. It does not show current branch name in prompt. That’s OK to me. But it cannot push to guthub through https. It hangs and does not show a prompt/dialogue to collect password. This seems to be a problem to me, because I only use https.

@inherits Rabbit.WebForm
@functions {
         void button_click(string name)
         {
         }
}

Or

@inherits Rabbit.MvcController
@functions {  
    [Get("/")]
    void Index() {
}

Another interesting thing I did is to sync data between C#, JavaScript and HTML inputs.

1. C# fields (both public and non-public) are populated with HTML inputs.

<input type=”text” name=”txtEmail” value=”@txtEmail”/>

@functions {
    string Email = “”; // it will have the value user typed after post.
}

This is similar to the model binding concept found in ASP.NET MVC. The difference is here we bind to fields, where ASP.NET MVC binds to action parameters (actually, we do that too).

2. C# public fields are synced with JavaScript through a JavaScript object, called webForm.

@functions {
      public int count = 20;
}

<script>
alert(webForm.count); // it shows 20
<script>

And vice versa, if changed the value in JavaScript, the C# field has the new value after post.

The C# data are serialized into JSON. On the client side, it can be rendered into HTML using jQuery template or jsrender.

It also could be a solution to view state to some degree I think.

Download the sample site to see how it works.

libgit2sharp, a wrapper to the libgit2 linkable C Git library, supposed to provide native speed, freaked me way off after seeing a few time memory access violation exceptions.

GitSharp,  manual port of JGit to C#. The project is a bit old and seems stopped updating. I was able run it locally and on Azure, but have not figured how to walk the commits yet.

ngit, automated JGit port to C#, is newer than GitSharp. It has a strange behavior that every time you open a repository, it tries to read configure files which do not exist on the server that has no git installed.

Good news is that I was able to deploy Git.exe to Azure by following this post.

I have been manually editing the .nuspec XML file and running the command line to create two packages. One of the MIX 11 section mentioned the NuGet Explorer. It is a great tool that can save a lot time and effort. I used it to create my third package. Enjoyed it.

BTW, I haven’t touched Windows applications for a while. The source code of the NuGet Explorer has many goodies to explore.

http://rabbit.codeplex.com

So, I created a small Windows Forms application that monitors the web site folder (using FileSystemWatcher). When web file changed, it searches all IE browsers that are from the web site. and send key F5 (actually post message via p-invoke).

It works very well especially on two monitors. Saving files on one monitor, browser refreshes on the other.

It is very convenient. After saved the files, I will see the result immediately. It is not only useful for developing UI. It is also great for unit testing.

After modified and saved the tests in the Rabbit Framework, the test runner page refreshes automatically.

I didn’t make it a Visual Studio Plug-in, because I need it when using Visual Studio Express and WebMatrix.