Manage custom customer releases

Question

As an alternative to this question , what is the best way to manage custom software versions for a particular client?

Most of the differences between client versions are changes in the user interface to customize the software so that it belongs to the client. Most often this is not, this is a simple logo change. Sometimes the color scheme changes. But there are cases when functions will be enabled or disabled based on the client. What is the best way to update all of these versions and make them available to users of a particular client?

At the moment, we have five different clients, each of which has its own software assembly and its own installer (complete with their logo in the installer). This is becoming a pain for management, and it will only get worse as more and more customers start using our software.

So, assuming a related question is not a way, what is the best way to manage these releases?

Answer 1

"This is becoming a pain for management, and it will only get worse as more and more customers start using our Software."

The only way to really solve this part is to make sure your software has an architecture that supports settings as a layer on top of your main product. Ideally, they will simply be runtime configuration parameters (colors, logos, and on / off are ideal for this). If you get (or want) a very large number of customers, push the configuration directly into the main product and give customers the opportunity to configure themselves.

During the upgrade, you create (and verify) the main product once and create custom versions, simply linking (referring) to the already built main product as a library. You can have each client in a separate assembly, or you can have one build process that generates updates for all currently supported client assemblies (the latter is probably better for more clients). If you have a version of "vanilla", you can create it as part of the kernel or together with client versions, it will depend on your specific case.

Depending on your technology, it may be possible that a customization level will be created regardless of the main product. In this case, customer recovery will rarely be necessary (perhaps only for certain significant changes) - you can simply refer to the updated main product at runtime. For deployment to the client, you will only need to deploy the updated kernel if you have a deployment method that supports this.

It is difficult to say in more detail, not knowing your platform, but you have kindly kept this question agnostic.

Answer 2

• Separate the common and custom parts in the source tree. This can eliminate the vast majority of mergers, depending on the testing and release policies. There is always a way to abstract and customize the build resource, even if your build process needs to call a script to overwrite some file.

• The wise use of branching in a good source code management system. They are not called configuration management systems. These are tools optimized specifically for this task, so you probably won’t get anything better without building on top of it.

Subversion is good at setting up multiple branches, but the last time I checked, it could only perform three-way merging, one file at a time. Perforce is amazing in this section because it keeps track of the branch history by file and uses this to automate merging entire sets of changes between entire branches. This is really cat pajamas.

Git and darks can have similar powers, but I haven't used them. They seem to be based on the idea that every working validation tree will have copies of all changes from the start. This sounds impractical to me, as I need to keep some of the large and changing SDKs under SCM control.

Answer 3

Perhaps the only difference should be the branch of any release that you have, with changes unique to it. For example:

/project /trunk /branches /release-v1 /customer-branches /release-v1-google /release-v1-microsoft .... 

If your customers release branches of your client releases. Since these branches will never be folded into the trunk or other release branch, do not contaminate the regular development / branch tree.

Answer 4

I assume that it depends on the level of configuration that you need for each client, but can you make the basic application “configure” itself based on the configuration file ?, so that you could have luggage, which is a complete application, and then have special configuration files for each client that control the appearance, as well as features that are included, and your release process will cause the correct configuration files to be deployed to the installers.

It seems that if you always deliver custom (ish) versions of your application for each client, it would be wise to extend the application this way.

Answer 5

I installed a header file called branding.h that contains a bunch of #ifdefs, like the following example, to change any bits that need to be changed. In Visual Studio, it is easy to configure multiple assemblies with the corresponding specific client symbol.

 #if defined BRAND_CLIENT1 # define COMPANY_NAME "Client 1" # define PRODUCT_NAME "The Client 1 Widget App" # define LOGO_FILE "res/logoClient1.ico" #elif defined BRAND_CLIENT2 # define COMPANY_NAME "Client 2" # define PRODUCT_NAME "The Client 2 Super Widget App" # define ENABLE_EXTRA_MENU # define LOGO_FILE "res/logoClient2.ico" #endif 

That all implies C ++, of course.