Author: tw

I’m not saying that having disabled best practice checks is desired, but it might be helpful, when enabling version control on a system with lots of legacy development, thereby still requiring some minimal best practice checks.

The know location for enforcing all best practices in version control is here: Menu>>Tools>Development tools>>Version control>>Setup>>System settings:

Exclude certain best practice requirements by editing SysTreeNode.allowCheckIn:

Issue

Various Developments are in different stages of development, testing and release.
It can be challenging to keep track of all changes and keep the different systems in sync.

Release management option 1: Use XPOs

Process

• Development system (DEV): Development w/o special consideration of release process
  When done, move completed developments via xpo to TEST.
• Test system (TEST): Testing
  When done, move successfully tested object to PROD (or REL) using xpo
• Release system (REL): Create release layer if desired
  When done move Layer to PROD.
• Productive system (PROD): Active code base

Issues

• Manual identification and extraction of relevant objects required
• Three different code bases
• Danger of object-Ids being out of sync
• Objects can simultaneously contain modifications in different stages of development; some should be release, others not

Release management option 2: Use configuration keys

Process

• Development system (DEV): Development adding configuration keys allowing to deactivate the newly created code parts. (Do not use configuration keys for Database objects – PROD, TEST and DEV databases should be identical –> Enabling/Disabling configuration keys will never result in database issues).
  When done, move entire layer to TEST (synchronization between developers required, to ensure that all have disable their changes using configuration keys.)
• Test system (TEST): Activate Configuration Keys ready for testing; Test. Additional checks required that deactivated developments do not have unintended side effects.
  When done, move entire layer to PROD. (In some cases the code might have been release earlier, so only enabling configuration keys is required in PROD.)
• Production system (PROD): Enable configurations keys.

Advantages (referring to option 1)

• Simple identification and activation using configuration keys
• One code base
• Identical object-ids in all systems
• No issues in with objects simultaneously containing modifications in different stages of development.

Disadvantages

• Incorrectly disabled code can cause issues à additional testing required (release document needs to identify new added – but not enable code)

My conclusion

In my opinion the advantages of Option 2 outweigh the disadvantage of the additional “disabled”-testing required.

Practical aspects

Configuration key structure

Add a configuration key parent for pending objects and one for released objects. In DEV all configurations are always enabled (this can be ensured by script – see below), in TEST only some configurations in the “Release pending” group might be enabled. In PROD, no configurations in the “Release pending” group might are enabled.

After successful testing the configuration keys are moved into the released group. Note: Moving between the “Release pending” and the “Released” group does nothing in itself – it is recommended for keeping track of the status of the various objects and can be used by scripts to identify the status of configuration keys.

Enable DEV/TEST configuration keys after restore

The following code enables all config keys under ReleasePending. It is useful after a restore of the PROD database into test and can be run as manually executed job or can be included in Info.startupPost() to automatically run when the current database is TEST (SysSQLSystemInfo::construct().getloginDatabase()).

/// <summary>
/// Activate all configuration keys under ReleasePending ==> for test system only!
/// </summary>
static void enableControlledReleaseConfigs()
{
    int i;
    Dictionary dict = new Dictionary();
    SysDictConfigurationKey sDCK;
    ConfigurationKeySet configurationKeySet;
    ;
    configurationKeySet = new ConfigurationKeySet();
    configurationKeySet.loadSystemSetup();

    for (i=dict.configurationKeyCnt(); i; i--)
    {
        sDCK= new SysDictConfigurationKey(dict.configurationKeyCnt2Id(i));
        if(sDCK.parentConfigurationKeyId() == configurationKeyNum(ReleasePending))
        {
            configurationKeySet.enabled(sDCK.id(),true);
        }
    }
    SysDictConfigurationKey::save(configurationKeySet.pack());
    SysSecurity::reload(true,true,true,false);
}

My only trick to find the resource number of an image is to use the resource browser.

In one installation I missed the resources browser (which should be found in the Menu: Tools –> Development tools –> Embedded Resource)

I didn’t find out why the menu option was missing but the workaround is easy:
in the AOT you can look for the form SysImageResources, which still works fine:

I don’t like that the function Global::str2con(str _value, str 10 _sep = ‘,’) converts strings to numbers, if it can. It does this on a field by field basis, i.e. the resulting container might be a mixed bag of strings and numbers, which is difficult to process.

I added my own function to avoid this:

public static container str2strCon(str _value, str 10 _sep = ',')
{
    #define.SC("¶") //special character (for reversibility of strCon2str with str2strCon)
    int length = strlen(_value), sepLength = strlen(_sep);
    int i = 1;
    int j = strscan(_value, _sep, 1, length);
    container ret;
    ;
    while (j)
    {
        ret += strReplace(substr(_value, i, j-i),#SC,_sep);
        i = j+sepLength;
        j = strscan(_value, _sep, i, length);
    }
    ret += strReplace(substr(_value, i, length-i+1)),#SC,_sep);
    return ret;
}

While we’re at it:
The reverse function con2str does not guarantee reversibility – if a component of the container contains the separator, then the reversing function (str2Con) will result in a larger container. So I added a similar function strCon2str() to generate strings from a container while removing the separator character from strings in a container. This guarantees the reversibility of the function. My str2strCon() function above restores the separator character in the component-strings.

static str strCon2str(container c, str 10 _sep = ',')
{
    #define.SC("¶") //special character (for reversibility of strCon2str with str2strCon)
    str ret, s;
    int i;
    ;
    for (i=1; i<= conlen(c); i++)
    {
        s = conpeek(c,i);
        ret = (ret?ret + _sep:"") + strreplace(s,_sep,#SC);
    }
    return ret;
}