Git is a wonderful and easy way to manage your source code of any kind of project and using GitHub as the central is a smart move. Especially when you developing a web project it is always good to have a staging site where you can see the latest stage of the development in a production-like environment.

But what if your company wants you to separate the source code into development, staging and production stages? You can use branches even completely separated repositories to achieve that.

In my current project I’ve set up this branching system with a single repository:

• master
• protected/development
• protected/staging
• protected/production
• [...] all other branches from my team

Note: the prefix protected/ is a valid prefix for branch names

The workflow is:

• everything that is in master will be pushed periodically to protected/development
• as soon as changes in protected/development are detected, the development site will be deployed
• every morning the latest source from protected/development will be pushed to protected/staging and the staging deployment site is started
• once we are happy with the state of the staging site, we decide to manually start the deployment of the production site by pushing the source from protected/staging to protected/production
• using the protected/* branches directly by the team members is not allowed

We are using JetBrains Teamcity to manage and execute these steps automatically. One of these steps is a shell script to synchronize the git branches.

you can call this script as following: ./sync_repos.sh [path_to_work_in] [ssh/http-origin] [ssh/http-destination] [origin-branch] [destination-branch]

example: ./sync_repos.sh ~/repos/dev git@github.com:user/project.git git@github.com:user/project.git protected/development protected/staging

Note: The path_to_work_in is necessary to create a bare repository as working base

Bonus: here is a script that makes a backup of you whole repository including the tags.

Have fun setting up your own branching system!

This is a .net ORM Mapper Framework from Microsoft to help you talking with your Database in an object oriented manner. Wikipedia

Database Transaction

A database transaction, by definition, must be atomic, consistent, isolated and durable. Database practitioners often refer to these properties of database transactions using the acronym ACID. Transactions in a database environment have two main purposes:

1. To provide reliable units of work that allow correct recovery from failures and keep a database consistent even in cases of system failure, when execution stops (completely or partially) and many operations upon a database remain uncompleted, with unclear status.
2. To provide isolation between programs accessing a database concurrently. If this isolation is not provided, the program’s outcome are possibly erroneous. Wikipedia

.NET Transactions

A .NET Transaction can be used in different ways by different frameworks to support transactions. The .NET Transaction itself is not connected with the database by any means. MSDN

.NET Transactions and the EntityFramework

If you are using the Entity Framework during an opened TransactionScope, EntityFramework will open a new Transaction right with the next command that will be sent to the Database (CRUD Operation).

Consider this code block:

The database.SaveChanges() call sends your changes to the database and executes them but they are not really persisted because you are in the database transaction scope. transaction.Complete() actually finishes the database transaction and your data is saved.

That behavior is actually cool and very useful, right?

NO. Absolutely not. full stop.

Why not using .NET Transactions along with EntityFramework

The default isolation mode is read committed and fits perfectly to 99% of your needs, eg. reading data. When you want to save the changes you made to the database (Create, Update, Delete), EntityFramework is smart enough to create a transaction without your notice behind the scenes to wrap the changes. You can be sure that everything will be saved or every change will be discarded (Atomicity).

By using transactions in EntityFramework, you change that behavior and force every CRUD operation during a transaction scope to be executed in serializable isolation mode which is the highest and most blocking type. No process will be able to access the tables you have touched (even reading from it) during your transaction. That can lead to Deadlocks pretty fast and you want to avoid them at all costs!

That’s how the code looks like without the explicit usage of transactions:

Rule of Thumb: Save only once per task and don’t use transactions.

Drawing

GIMP
MyPaint
Kitara
InkScape

Photographie / Imaging

Darktable Raw Image Editor
CMYKTool Rich Converter for CMYK from/to RGB

Office

Xournal
Calligra Suite BrainDump, Flow (Diagram / Flowcharts), Karbon (Vector Graphics), Kexi (Visual Database Creator), Krita (Sketching, Painting), Plan (Project Management), Stages (Presentations), Sheets (Calculation, Spreadsheet), Words (Writing)
Scribus Desktop Publishing like InDesign

Audio

Audacity Rich Music Editor
Hydrogen Advanced Drum Machine
MIXXX Free DJ Software

3D / Animation / Movies

Blender 3D 3D Modeling, Rigging, Animation, Raytrace Rendering, Physics and Particles, Game Engine, UV Editing, Movie editing, Raw Footage tracking, Image Compositing and many many more
Synfig Studio
Kdenlive Video Editor

GNOME Specials

Gnome Color Manager
Wacom Control Panel

Sharing Service

Sparkleshare Uses GIT under the hood and can be self hosted.

Hope you like it!

The new version arrives and I have some highlights to point out:

• First of all: ITS FREE (and will stay free)
• Obtain stable results in
  • WPF applications using .NET 3.5 and higher
  • New: Silverlight 5.0 applications
• New: Localization source/provider can be changed freely at arbitrary nodes
  • Use the Provider property in LocalizeDictionary to change the provider for the particular sub tree
  • Use the DefaultProvider property to set the provider for the whole application
  • Built-in RESX provider for resource file lookup (Default) – fully backward compatible to older versions of this extension
  • Interface for custom providers
  • Notification about provider changes and errors
  • Get the list of all available cultures from a provider – or just take the bindable merged list from LocalizeDictionary
  • CSV provider project in the Tests folder as an example for custom providers
    
• Supports binding-like write style like “Text = {lex:LocText ResAssembly:ResFile:ResKey}”
  • Define a default assembly and / or resource file to reduce the key to ResAssembly::ResKey, ResFile:ResKey or even ResKey
  • If no key is specified, the Name and Property Name of the target are used (e.g. MyButton_Content)
  • Default assembly, dictionary and culture can be changed dynamically
  • Default assembly and dictionary inherit along the visual tree and can be redefined at each node
• It is available at designtime (MS Expression Blend 3.0 & 4.0, MS VisualStudio 2008 & 2010
  • not for dynamic loaded assemblies which only can be found at runtime and as long the resource (.resx) is built at designtime
  • Even for Silverlight!
  • No extra preview application needed
  • Offers a DesignValue Property to support custom values during design mode
• Full support of various application scenarios
  • Works with normal dependency properties
  • Works with normal properties (e.g. Ribbon)
  • Works with control/data templates
• Various culture setup features
  • Works with the .resx-fallback mechanism (e.g. en-us -> en -> invariant culture)
  • Supports culture forcing (e.g. “this object has to be in english all the time”)
  • Buffering allows fast switching of the language at runtime
  • Offers a design language for visual testing at designtime
  • Offers a “SpecificCulture” to use as IFormatProvider (e.g. (123.20).ToString(LocalizeDictionary.SpecificCulture) = “123.20″ or “123,20″)
  • Does not alter the culture on Thread.CurrentCulture or Thread.CurrentUICulture (can be changed easily)
• Code behind features:
  • Can be used in code behind to bind localized values to dynamic generated controls
  • Implements INotifyPropertyChanged for advanced use
  • Offers some functionality to check and get resource values in code behind (e.g. ResolveLocalizedValue)
• Easy to use
  • Can be used with any resource file (.resx) accross all assemblies (also the dynamic loaded one at runtime)
  • Does not need any initializing process (like “call xyz to register a special localize dictionary”)
  • Can localize any type of data type, as long a TypeConverter exists for it
• Example extensions included for
  • Formating e.g. “this is the ‘{0}’ value” (not bindable at the moment)
  • Prefix and suffix values (currently with LocText extension)
  • Upper and lower Text
• Last, but not least
  • Does not create any memory leaks
  • Leaves the UID property untouched
  • Does not need an additional build task
  • Is in use in various productive systems

Uwe Mayer was so kind to create a short Workflow Video about how it works:

http://www.youtube.com/watch?v=a4s3qAzerMI

I used particles, cycles, glowing materials and the compositor.

how do you like it?

[
    {
        Key: "key1",
        Value: "value1"
    },
    {
        Key: "key2",
        Value: "value2"
    }
]

But you want a correct JSON dictionary format:

{
    "key1": "value1",
    "key2": "value2"
}

What happens here? Serializing a dictionary is the same as you would serialize a list of objects.

This means that this:

Dictionary<string, object> dic = new Dictionary<string, object>();
dic.Add("key1", "value1");
dic.Add("key2", "value2");

… is the same as this:

public class KeyValue
{
    public string Key { get; set; }
    public string Value { get; set; }
    [...]
}
 
public class Dictionary
{
    public List<KeyValue> Values { get; set; }
    [...]
}

The serializer takes every item from Dictionary.Values and writes the KeyValue object into the output.
This behaviour is not bad or wrong but it is unsuitable for a JSON dictionary output.

What we want is a “Key: Value” output like this:

{
    "key1": "value1",
    "key2": "value2"
}

What you need to do is implementing a Dictionary-like object that inherits from ISerializable.

Here is the implementation of it:

/// <summary>
/// This key value collection is used to serialize a dictionary into json format and back.
/// </summary>
[Serializable]
public sealed class KeyValueCollection : ISerializable
{
    /// <summary>
    /// Holds the internal dictionary.
    /// </summary>
    private readonly Dictionary<string, string> _dictionary;
 
    /// <summary>
    /// Initializes a new instance of the <see cref="KeyValueCollection"/> class.
    /// </summary>
    public KeyValueCollection()
    {
        this._dictionary = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
    }
 
    /// <summary>
    /// Initializes a new instance of the <see cref="KeyValueCollection"/> class.
    /// </summary>
    /// <param name="dictionary">The dictionary.</param>
    public KeyValueCollection(Dictionary<string, string> dictionary)
    {
        this._dictionary = new Dictionary<string, string>(dictionary, StringComparer.InvariantCultureIgnoreCase);
    }
 
    /// <summary>
    /// Initializes a new instance of the <see cref="KeyValueCollection"/> class.
    /// </summary>
    /// <param name="info">The serialization info.</param>
    /// <param name="context">The streaming context.</param>
    protected KeyValueCollection(SerializationInfo info, StreamingContext context) : this()
    {
        foreach (var entry in info)
        {
            this._dictionary.Add(entry.Name, entry.Value.ToString());
        }
    }
 
    /// <summary>
    /// Gets or sets the <see cref="System.String"/> with the specified key.
    /// </summary>
    public string this[string key]
    {
        get
        {
            return !this._dictionary.ContainsKey(key) ? null : this._dictionary[key];
        }
        set
        {
            this._dictionary[key] = value;
        }
    }
 
    /// <summary>
    /// Gets the internal dictionary as copy.
    /// </summary>
    /// <returns>The internal dictionary as copy.</returns>
    public Dictionary<string, string> GetDictionary()
    {
        return new Dictionary<string, string>(this._dictionary);
    }
 
    /// <summary>
    /// Populates a SerializationInfo with the data needed to serialize the target object.
    /// </summary>
    /// <param name="info">The SerializationInfo to populate with data.</param>
    /// <param name="context">The destination (see StreamingContext) for this serialization.</param>
    /// <exception cref="T:System.Security.SecurityException">The caller does not have the required permission.</exception>
    void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
    {
        foreach (string key in this._dictionary.Keys)
        {
            info.AddValue(key, this._dictionary[key], typeof(string));
        }
    }
 
    /// <summary>
    /// Adds the item with the specified key.
    /// </summary>
    /// <param name="key">The key.</param>
    /// <param name="value">The value.</param>
    public void Add(string key, string value)
    {
        this[key] = value;
    }
}

Note:

As you might have seen that i use Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
The StringComparer.InvariantCultureIgnoreCase argument helps me to treat all the keys case insensitive.

If you want to work on the directory directly (query) use the method GetDictionary().

Sources:

First http://blog.masonchu.com/2012/03/wcf-webapi-dictionary-json.html
Second http://stackoverflow.com

But this is especially needed is you want to use “-setParam” for a tokenized (transformed) web.config file and wont / can’t change the SetParameter.xml!
(The names of the parameters for -setParam can be found in the SetParameter.xml file in the same directory as the Package.zip. They are also act as default values if not set in the command line call. )

So I wrote this quick tutorial how to get command line call for MSDeploy.
(Please consider that the paths you will later use are absolute / relative to the working directory.)

Step 1: Get the publish ready with MSBuild

Before we will get some further results please get your deployment call working.

msbuild.exe
SomeWebProject.csproj
/P:Configuration=Release
/P:DeployOnBuild=True
/P:DeployTarget=MSDeployPublish
/P:MsDeployServiceUrl=https://TargetServer/MsDeploy.axd
/P:AllowUntrustedCertificate=True
/P:MSDeployPublishMethod=WMSvc
/P:CreatePackageOnPublish=True
/P:UserName=Username
/P:Password=Password
/P:DeployIisAppPath=TargetWebSite/TargetWebApp

Configuration: This is the configuration you will use eg. Debug, Release or a custom one
AllowUntrustedCertificate: You will need this if you do not have a valid certificate on the server
DeployIisAppPath: The name of the target website eg. “Default Web Site/MyWebApp”
TargetWebSite/TargetWebApp: Please consider the different usages below!

Step 2: Get the command line for MSDeploy

Append the parameter “/P:UseMsdeployExe=True” to the msbuild.exe call. If you do so, you will see the call in the console like this:

MSDeployPublish:
Start Web Deploy Publish the Application/package to https:/TargetServer/MsDeploy.axd?site=TargetWebSite …
Running msdeploy.exe.
msdeploy.exe -source:package=’C:\SomeWebProject\obj\Release\Package\SomeWebProject.zip‘ -dest:auto,ComputerName=’https://TargetServer:8172/MsDeploy.axd?site=TargetWebSite‘,UserName=’Username‘,Password=’Password‘,IncludeAcls=’False’,AuthType=’Basic’ -verb:sync -disableLink:AppPoolExtension -disableLink:ContentExtension -disableLink:CertificateExtension -allowUntrusted -retryAttempts=2

Gotcha! This is the important MSDeploy command line call.

Step 3: Get the two things together

now we can split the automatic deployment of MSBuild into 1. create only the package with MSBuild and 2. only deploy with MSDeploy.

msbuild.exe
SomeWebProject.csproj
/P:Configuration=Release
/P:DeployOnBuild=True
/P:CreatePackageOnPublish=True

msdeploy.exe
-source:package=’C:\SomeWebProject\obj\Release\Package\SomeWebProject.zip‘
-dest:auto,ComputerName=’https://TargetServer:8172/MsDeploy.axd?site=TargetWebSite‘,UserName=’Username‘,Password=’Password‘,IncludeAcls=’False’,AuthType=’Basic’
-verb:sync
-disableLink:AppPoolExtension
-disableLink:ContentExtension
-disableLink:CertificateExtension
-allowUntrusted
-retryAttempts=2
-setParam:’IIS Web Application Name’=’TargetWebSite/TargetWebApp‘

Have a nice day.

This is my interpretation:

The colors and the strong reflection is my personal taste.

The .blend file can be downloaded HERE.

While exploring the new features i found two new functions!

First – Import brush textures from a dictionary / single brush textures (without add-on!).
After adding, you will have all your brush textures you choose in the selection box.

You can find many nice brush textures at Pixologic ZBrush Download Central. (The .psd files can be converted to .png files with free converters.)

Second: Brush Overlay
This shows you where your brush would take influence on the mesh.

And also tiling / rotating (angle) of the brush is supported!

i hope you will find this information useful!

Happy blending