I found the book to be quite a good introduction as well as a suitable book for power users.
The book starts with the basics – the common uses that most users will have of git, it then goes into workflows followed by more esoteric uses and an in depth look into git internals.
In the in-depth chapters, the details are very low level – how git stores different objects, what they look like and what information the different object types contain.
The book is very *nix centric – some chapters and commands assume a *nix environment, and it isn’t clear how these specifics translate to windows (examples include hooks and hook scripting).
Things I found interesting:
- I did not know that I could just use a network share for collaboration (using the local protocol). This is very simple to setup – could be perfect for a small office/home office environment where code doesn’t need to be on the Internet.
rerere – recording confict resolution. A git feature that allows recording how merge conflicts have been resolved, so future conflicts can be automatically resolved using the same strategy (this is a rare use but can be very helpful if the same merge needs to be performed repeatedly).
- Git hooks for customizing actions – for example, special commit rules, running commands when fetching and more (the book doesn’t make it clear if/how to manage this on Windows).
filter-branch – a very powerful, but very dangerous feature, that allows rewriting history across the whole repository and commits in it. Can be useful for removing certain files from all revisions (say a private key file was committed by error and should be completely expunged).
reset works – the section explains the different states of a repository being tracked, what HEAD means and how to think about it and what
reset does. Clarified quite a bit for me.
- Splitting a repository – for example, if the repository has grown a lot and only the recent history is of interest, it is possible to split a repository into old historical/current.
I recommended this book if you feel you are not using git effectively.
It contains lots of info about how different commands work, and is a good introduction to many tools, some of which you may not be familiar with (
reset, bundling, rebasing and more) as well as a chapter dedicated to the use of github.
The book can be read online, downloaded for free (supported formats are pdf, epub, mobi and HTML), and a dead tree edition is available on amazon.
Microsoft.VisualBasic.FileIO (Microsoft.VisualBasic.dll) namespace lives the
This useful little class can be used to parse structured text files – either delimited or fixed length. You can iterate over the lines in the file and extract the data through the
Since it is provided by Microsoft, you can use it in environments that do not allow “third-party” libraries and as it is a .NET libarary you can use it in any .NET language (yes, C# and F# included) – just import the library.
The examples on MSDN are all in VB.NET, but are easily translated to other .NET dialects.
– How to: Read From Comma-Delimited Text Files
– How to: Read From Fixed-width Text Files
– How to: Read From Text Files with Multiple Formats
Why is that?
If one takes the time to think about it, class libraries only ever execute in the context of an application – a web application, a console application, a unit test runner or some other executable.
A class library gets loaded into the memory space of the application and gets called and executed there.
It makes sense then that the executing application should be the one deciding on how to configure a class library it is using, rather than the other way around.
The .NET framework configuration subsystem subscribes to this idea – when using the
System.Configuration namespace, the application configuration file will be the one queried, even if there is a configuration file matching the dll name.
I would add that configuration should be treated as a dependency – the values should be injected into any class or method that required them – read the excellent blog by Paul Hiles – Configuration Settings Are A Dependency That Should Be Injected.
One of the most common misunderstandings I see on StackOverflow regarding the
DateTime structure is the difference between the value of a
DateTime instance and how it is displayed.
DateTime instance (say one representing midnight of March 26th 2011) has an internal representation that has no specific formatting – it is not something that will make sense to any human being in that form (this post is not about what exactly that representation is).
What this means is that every time you see a value for a
DateTime instance, you are seeing this internal value after it has been formatted for human eyes.
How this formatted value comes to be is the subject of this blog series, starting with this introduction.
In future posts I will discuss the roles of
IFormatProvider and format strings, Cultures and the Regional settings.
When formatting a currency for display, always use a CultureInfo object when outputting in order to get the correct formatting – different places will have a different thousands separator, decimal separator and more.
In many cases, you can get the CultureInfo from the UI thread and in a web application you could guess which one is the correct one, by parsing out the user agent header.
If you always want the exact same output, you do not have to specify a format string, simply use CultureInfo.InvariantCulture, this is a dummy culture and does not correspond to any country/region. The different settings are similar to “en-US”.
This example will output the format for the Swedish culture.
decimal value = -16325.62m;
This example will output the format for the InvariantCulture.
decimal value = -16325.62m;
Here is a list of culture names.