I am about to leave MS, and this blog will be frozen.

You are more than welcome to visit my new blog, dedicated to Dynamics AX: http://sashanazarov.blogspot.com

I hope that the new blog will benefit from me being closer to our clients.

Cheers,
Sasha

This is an example of the X++ job. You can use it to understand how well your algorithm does from the performance point of view.

static void testPerformance_Job(Args _args)
{
    #define.Limit(128)
    #define.ExecutionTime(1)
    int elements;
    int time;

    void doSomething_LinearTime(int _elements)
    {
        sleep(_elements * #ExecutionTime);
    }

    void doSomething_QuadraticTime(int _elements)
    {
        sleep((_elements * #ExecutionTime) * (_elements * #ExecutionTime));
    }

    elements = 1;
    while (elements <= #Limit)
    {
        time = WinAPI::getTickCount();
        doSomething_LinearTime(elements);
        //doSomething_QuadraticTime(elements);
        time = WinAPI::getTickCount() - time;

        info(strFmt("Elements %1, time %2 ms, %3 elements/ms",
                    elements,
                    time,
                    time == 0 ? 0 : elements / time));

        elements = elements * 2;
    }
}

The idea is pretty simple: you increase complexity in a fast manner and check how many elements get processed per millisecond. The job above results in the following:

Elements 1, time 0 ms, 0 elements/ms
Elements 2, time 0 ms, 0 elements/ms
Elements 4, time 0 ms, 0 elements/ms
Elements 8, time 16 ms, 0,50 elements/ms
Elements 16, time 15 ms, 1,07 elements/ms
Elements 32, time 31 ms, 1,03 elements/ms
Elements 64, time 78 ms, 0,82 elements/ms
Elements 128, time 125 ms, 1,02 elements/ms

So, the "complexity-to-time" function is linear (ignore the lines with zero execution time). Cool. Now, let's check another method's performance:

        //doSomething_LinearTime(elements);
        doSomething_QuadraticTime(elements); 

The following execution log is printed: 

Elements 1, time 0 ms, 0 elements/ms
Elements 2, time 0 ms, 0 elements/ms
Elements 4, time 16 ms, 0,25 elements/ms
Elements 8, time 62 ms, 0,13 elements/ms
Elements 16, time 265 ms, 0,06 elements/ms
Elements 32, time 1030 ms, 0,03 elements/ms
Elements 64, time 4087 ms, 0,02 elements/ms
Elements 128, time 16380 ms, 0,01 elements/ms

Here, the number of processed elements per millisecond drops. Imagine how many years it would take to process 1.000.000 elements with this bad performance? About 32.000 years. And for the first, linear algorithm, it would take only 12 days.

So, whenever you are in doubt about how fast your algorithm is when number of elements to process is growing, write this kind of job. It will immediately reveal problems with the performance.

static void testLike(Args _args) {     str someString;     ;         someString = "Johnny";       if (someString like "Joh?ny" || someString like "*ny")     {         info("Dammit, I should have known this before!");     } }

It looks very much like I don't need Global::strStartsWith() and Global::strEndsWith() methods anymore...

And this is how it may be used:

static void exampleQuickSort(Args _args)     {         QuickSort       quickSort;         ListEnumerator  itemEnumerator;         str             itemId;         Qty             qty;         ;           quickSort = QuickSort::construct(Types::String, Types::Real);         quickSort.add('Item1', 10.00);         quickSort.add('Item2', 12.00);         quickSort.add('Item3',  9.00);           itemEnumerator = quickSort.getEnumerator();         while (itemEnumerator.moveNext())         {             [itemId, qty] = itemEnumerator.current();             print itemId, ' ', qty;         }           pause;     }

The output will look like this:

Item3 9,00
Item1 10,00
Item2 12,00

You may find the class in the attachment.

Class_QuickSort.xpo

Be aware, that Vanya Kashperuk has published another version of this class, valid for both 4.0 and 2009.

Quite often people wonder whether there is a simple way to limit this list to a set of allowed values. Maybe there is a solution posted somewhere in the net - please let me know if you met one. As I has not found anything like that, I propose the following.

1. Create a class, named, say, SysCustomizedEnumComboBox. In the class declaration, write:

class SysCustomizedEnumComboBox {     FormRun     formRun;     int         comboBoxControlId;     EnumId      enumId;     Set         allowedEnumValuesSet;       Map         enumValue2ComboBoxItemMap;     SysDictEnum sysDictEnum; }

2. Create parm-methods for each of the first 4 variables, and a constructor method without input parameters.

3. Now, create init() method (thanks to Palle Agermark who proposed a way to build comboboxes at run-time):

protected void init() {     #define.List(1)       FormComboBoxControl formComboBoxControl;     SetEnumerator       allowedEnumValueEnumerator;     int                 comboBoxItemNumber;     int                 allowedEnumValue;     ;       sysDictEnum = new SysDictEnum(enumId);       formComboBoxControl = formRun.form().design().control(comboBoxControlId);     formComboBoxControl.enumType(0); // don't assign any enum type     formComboBoxControl.label(sysDictEnum.label());     formComboBoxControl.helpText(sysDictEnum.help());     formComboBoxControl.comboType(#List);     formComboBoxControl.items(allowedEnumValuesSet.elements());       enumValue2ComboBoxItemMap = new Map(Types::Integer, Types::Integer);     comboBoxItemNumber = 1;     allowedEnumValueEnumerator = allowedEnumValuesSet.getEnumerator();     while (allowedEnumValueEnumerator.moveNext())     {         allowedEnumValue = allowedEnumValueEnumerator.current();         formComboBoxControl.item(comboBoxItemNumber);         formComboBoxControl.text(sysDictEnum.value2Name(allowedEnumValue));         enumValue2ComboBoxItemMap.insert(allowedEnumValue, comboBoxItemNumber);         comboBoxItemNumber++;     } }

4. Create a method that will construct the class and initialize it:

public static SysCustomizedEnumComboBox newParameters(     FormRun _formRun,     int     _comboBoxControlId,     EnumId  _enumId,     Set     _allowedEnumValuesSet) {     SysCustomizedEnumComboBox sysCustomizedEnumComboBox =         SysCustomizedEnumComboBox::construct();     ;       sysCustomizedEnumComboBox.parmFormRun(_formRun);     sysCustomizedEnumComboBox.parmComboBoxControlId(_comboBoxControlId);     sysCustomizedEnumComboBox.parmEnumId(_enumId);     sysCustomizedEnumComboBox.parmAllowedEnumValuesSet(_allowedEnumValuesSet);     sysCustomizedEnumComboBox.init();       return sysCustomizedEnumComboBox; }

5. And finally, add a couple of methods that will manipulate the combobox:

public void select(int _enumValue) {     FormComboBoxControl formComboBoxControl;     ;       if (!enumValue2ComboBoxItemMap.exists(_enumValue))         throw error(Error::wrongUseOfFunction(funcName()));       formComboBoxControl = formRun.control(comboBoxControlId);     formComboBoxControl.selection(enumValue2ComboBoxItemMap.lookup(_enumValue) - 1); }

public int selection() {     FormComboBoxControl formComboBoxControl;     int                 ret;     ;       formComboBoxControl = formRun.control(comboBoxControlId);     ret = sysDictEnum.name2Value(         formComboBoxControl.getText(formComboBoxControl.selection()));     return ret; }

6. That's it.

Now, you may use the class in a form. For example, you have a form named ReserveTickets. It is used for booking airplain tickets for employees. There are 2 classes that represent employees and managers, and Manager class extends Employee. The booking form may be called by either of the classes. Depending on what class is the caller, the types of the tickets are different, so that employees may book only economy seats, while managers - economy and business seats. Let's say we have an enum SeatType representing both seat types.

So, first of all we have to add a method to Employee class, and override it in the sub-class:

// Employee class method  public Set allowedSeatTypeValuesSet() {     Set allowedSeatTypeValuesSet;        ;       allowedSeatTypeValuesSet = new Set(Types::Enum);     allowedSeatTypeValuesSet.add(SeatType::Economy);     return allowedSeatTypeValuesSet; }

// Manager class method  public Set allowedSeatTypeValuesSet() {     Set allowedSeatTypeValuesSet;        ;       allowedSeatTypeValuesSet = super();     allowedSeatTypeValuesSet.add(SeatType::Business);     return allowedSeatTypeValuesSet; }

And finally, let's correct the form ReserveTickets (assuming that it has a combobox named SeatTypeComboBox). Declare sysCustomizedEnumComboBox member-variable in the form class declaration. Then override init() method of the form as follows:

public void init() {      Employee   caller = this.args().caller();     ;       sysCustomizedEnumComboBox = SysCustomizedEnumComboBox::newParameters(         element,         control::SeatTypeComboBox,         enumNum(SeatType),         caller.allowedSeatTypeValuesSet());             super();                                                                          }

Done. From now on, whenever this form is called by Employee class - only economy tickets will be selectable, and when called by Manager - then both economy and business tickets will.

We don't actually use select() and selection() methods of SysCustomizedEnumComboBox in this form example. These methods would become handy if there was another class behind the form, and the form was used as a user interface for this class member-variable SeatType. I don't provide the example here, but I know - you understand the concept.

Abs
 [HEADER]

Returns the absolute value of arg.

Examples
Abs(-100.0) returns the value '100.0'.

Abs(30.56) returns the value '30.56'.
static void Job_Examples_22885_1_abs(Args _args)
{
  real r1;
  real r2;
  ;

  r1 = abs(-3.14);
  r2 = abs(3.14);
  if (r1 == r2)
  {
    print "abs of values are the same";
    pause;
  }
}

-----------------------------------------------

Unfortunately, special symbols like ‘>’ are converted to something like ‘&lt’, but still this is a way to understand what the kernel function does.

But the day has come, when I found a way to fix this problem - Microsoft Office Project. So, I took "Code Complete" and split the remaining 660 pages into 33 groups of 20 pages each, and then I assigned a business day to each of the groups. According to the plan, I should have read the rest of the book in about 1,5 months. The last day has become tangible - I knew the exact date, when the book would be read. More then that, I promised myself, that I would burn a 100 DKK bill (about 20 USD) whenever I spend an evening without reading the planned 20 pages. The plan was printed and put onto the wall. I crossed one small blue "task" rectangle with a green marker every time I was done with another bunch of pages.

And, you know, I have burnt no money. Instead, the Day has come, when I read the last sentense and closed the book. I can't describe what I felt at the moment. It was a mixture of two feelings - impression by the book and impression by the fact. The plan has done its job, and I have become a better developer!

Several other books have been read since then, mostly recommended by Steve McConnell for a developer "reading plan". Each book was split and planned. 20 pages a day. Very little daily effort, but huge yearly improvement. It is not a big deal to read 2 books in parallel, 20+20 pages a day, but one book is still fine.

The funny thing is, that my wife has also decided to use this approach while preparing for her last Danish exam: she is reading 2 pages of grammar and processes 2 pages of exercises, every day. She did not promise to herself that she would burn anything if the plan is not followed, still she follows it since the beginning. Our plans hang on the wall - side by side.

There is definitely a sort of magic in a printed Gannt chart. No doubt about that. Try it out.

'10510', '49', '0'
'10511', '49', '3'
'10600', '49', '0'
'10600', '49', '6'
'10600', '50', '0'
'10651', '49', '0'
'10651', '50', '0'
'10800', '49', '0'
'10811', '49', '0'
'10900', '49', '0'

and so on. As can be seen from the sample:

• only department 49 and cost center 0 are valid for the account 10510;
• only departments 49 and 50 are valid for 10600, while cost centers 0 and 6 are valid for department 49, and cost center 0 is valid for department 50;
• the accounts 10800, 10811 and 10900 have department 49 and cost center 0 as the only valid values

etc.

I have written a sample job that generates dimension set rules based on this information.

Pre-conditions for the job:

1. “Dept-cc” dimension set is created, composed of Department and Cost Center dimensions.
2. The dimension set has neither hierarchies nor rules created.
3. All mentioned ledger accounts exist in the chart of accounts.

As a result of the job execution:

1. Several dimensions set hierarchies will be generated. The number of hierarchies will be less than number of accounts, because some accounts have similar validation rules.
2. The hierarchies will be updated and approved.
3. There will be a dimension set rule collection created for “Dept-cc” dimension set.
4. There will be several dimension set rules created – one per ledger account. The rules will be assigned to the rule collection.

The job may be found in the attachment.

job.txt

Quite a funny book, very easy to read. Highly recommended! Here are some of the facts he mentions and elaborates on:

• Fact 2 - "The best programmers are up to 28 times better than the worst programmers, according to "individual differences" research. Given that their pay is never commensurate, they are the biggest bargains in the software field."
• Fact 7 - "Software developers talk a lot about tools. They evaluate quite a few, buy a fair number, and use practically none."
• Fact 23 - "One of the two most common causes of runaway projects is unstable requirements."
• Fact 37 - "Rigorous inspections can remove up to 90 percent of errors from a software product before the first test case is run."
• Fact 45 - "Better software engineering development leads to more maintenance, not less."

And here is a couple of the fallacies:

• Fallacy 8 - "Given enough eyeballs, all bugs are shallow."
• Fallacy 10 - "You teach people how to program by showing them how to write programs."

(...damn, all these books make me more and more sober-minded!..)