mfp's two cents

...on Dynamics AX Development!
  • mfp's two cents

    migrax(tm): A new way to do code upgrade.


    More Dynamics; one of the Gold Sponsors on Convergence 2009; has just released what I find to be a very interesting product: migrax™. migrax™ can assist in migrating AX solutions from version 3 and version 4 to AX2009.

    The approach taken is quite different from the code upgrade tools available in AX. The existing AX code upgrade tools live inside MorphX; and can harvest the benefits of MorphX, such as access to the AOT, Compare tools, BP tools, etc. However; living inside MorphX also induces certain limitations; for example all editing has to go through the AOT modeling API.

    migrax™ does it differently. It is an external application. You start by loading your solution as an XPO file. It will be converted to XML and persisted in a database inside migrax™. Using XML techniques migrax™ is able to automatically resolve most code conflicts and produce an XPO file upgraded to Dynamics AX 2009.

    migrax™ is capable of solving logical conflicts caused when the standard application (typically in the SYS layer) changes, and the changed element has been customized. migrax™ is by-nature not capable of resolving conceptual conflicts, like conflicting or redundant functionality. Here a set of human eyes is still needed.

    One might argue that migrax™ is competing with the standard tool set in MorphX in upgrading code. I have a different perspective. The goal for me is to enable customers and partners to upgrade to Dynamics AX 2009 as seamless as possible. Having a larger tool box is a benefit to everyone.

    Make sure to check-out the migrax™ site, and visit More Dynamics at Convergence 2009 in New Orleans.

  • mfp's two cents

    Innovating to improve the planet


    At Microsoft, we are committed to software and technology innovation that helps people and organizations around the world improve the environment. Our goals are to reduce the impact of our operations and products and to be a leader in environmental responsibility.

    For more information see:

    Also see the Microsoft Dynamics AX Environmental Sustainability Dashboard:

  • mfp's two cents

    Its today!


    My flight was full of familiar faces. Homeland Security in Seatac learned that Microsoft is hosting a Dynamics AX Conference. So did the receptionists at my hotel. Almost everyone at the breakfast buffet was wearing a Dynamics AX logo. The weather is warm. You can smell the pine wood surrounding the area and you can feel the anticipation building up. Today is  the day! In just 3 hours the registration for the Dynamics AX 2011 Technical Conference 2011 will open. Welcome to Redmond and Microsoft Campus - my home away from home.


  • mfp's two cents

    Session list for Technical Conference 2011 is available


    The first major AX event this year is not even a week away. I encourage you to plan your conference - there is so much too see, and so much you don't want to miss.

    The session list has recently been published here:


  • mfp's two cents

    Microsoft Dynamics AX 2009 Programming: Getting Started


    A new book on Microsoft Dynamics AX 2009 development has recently been published by Packt Publishing. The book is aimed at developers new to Dynamics AX, and offers what I believe is both a detailed and pragmatic approach by focusing on the most important aspect and providing tons of in-depth step-by-step examples. Naturally, you can debate what areas are the most important, which in this case was decided by the book's author Erlend Dalen. By looking at the book's table of content, I believe he did an excellent job. Once I receive my copy of the book I'll post a more detailed review.

    From the publisher's description:

    What you will learn from this book

    • Get to grips with the AX Development environment
    • Understand the basics of the  X++ language
    • Reduce the time spent on coding by storing and relating data
    • Create Reporting Services reports in Visual Studio using the new Reporting Service extensions
    • Optimize data retrieval to ensure each transfer contains only the data necessary for the further operations
    • Manipulate data in X++
    • Effectively handle transaction scope by using different operators
    • Develop a .Net class in Visual Studio and then use it in AX
    • Build rich web portals with Enterprise Portal and ASP.NET
    • Optimize application performance and extensibility
    • Create services and expose them to external applications
    • Build a new module in AX

    If you want a free sample of one of the book's chapters, you can download the chapter "Searching for Data".

  • mfp's two cents

    Review of: Microsoft Dynamics AX 2009 Programming: Getting Started


    This is an excellent book for getting started with AX. The book’s language is straight forward and simple, so you don’t need a computer science education to reap the gold nuggets buried inside.

    The first half of the book is a case study of a step-by-step implementation of a car rental application. This is a great idea, as these steps take you through many areas of AX development, and on the way introduces you to most of the building blocks of X++. The approach used is to jump straight into the action, without spending many words on background information, which quite impressively doesn’t make the material harder to grasp, but rather makes the book a pleasant and easy read. The book is full of source code examples and screenshots, which will make it easy for you to follow the same steps in your own AX installation.

    The second half of the book is a collection of standalone chapters. I particularly liked the chapter on integration with various AX modules. This chapter provides a 10,000 feet overview of the main modules in AX, such as GL, AR, AP and Inventory. Further it provides code samples on how common customizations can be implemented.

    There are two kinds of books. Those that struggle to reach the final page count by cutting the original manuscript, and those that struggle to produce enough pages to justify calling it a book. (Something similar is true for sauces). This book is of the latter kind, which is a shame. Important information even for beginners is missing in critical places; whereas plenty of pages are spent on low value information. For example, the book contains a 10 page source dump of an data export/import feature the author has implemented – not because the one already in AX isn’t good enough, but simply because he could.

    The vital information that is missing is the primary reason I cannot give this book 5 stars. Here are some examples: In the same chapter the book explains the benefits (speed) of using set-based data base operations, and the powers of overriding table trigger methods like insert() and update() – but the book forgets to mention that overriding such a method will reduce all set-based operations to row-by-row operations on the AOS (incredibly slow in comparison). This cause and effect is one of the typical reasons AX customers are having performance problems. Similarly the book explains the concurrency model of AX4 (pessimistic) and not the concurrency model of AX2009 (optimistic). Another important topic not covered is how to develop a 3 tier application – without such information it is hard to write an application that scales beyond a few users.

    It is clear that the author has worked with AX for a long time. Some of the information provided is outdated in AX2009. For example, the chapter on how to create a web service in AX explains all the hassle you had to go through in AX4, instead of explaining how simple the same could be achieved in AX2009 using the Services node in the AOT. The same is true for the BC.Net examples that use the AX4 way of talking to AX, instead of using the automatically generated proxies available in AX2009, which are much simpler to use – and much more reliable.

    Finally, the technical accuracy of the book is high – it rarely state something that is wrong, but often omits what I believe is critical information. So kudos to the author. However; the editors of the book didn’t do a very good job. The book is full of typos, double words, poorly phrased sentences and what appears to be copy-paste errors. And I do mean full – I spotted one on almost every other page. It is clear that no one took the time to read the book end-2-end before printing it. For example, the appendix with useful web links has half of the URLs wrong – they are duplicates from the previous page and don’t match the description at all.

    I’m giving this book a 4 out of 5 star rating, because it does deliver what it promises: A quick start on developing in AX without providing too much background information.

    The book is written by Erlend Dalen and published by Packt Publishing.

  • mfp's two cents

    New layout of my blog


    As you may have noticed my blog just got a facelift. All MSDN blogs have been updated, mine included.   I hope you like it :-)   I do.

  • mfp's two cents

    Dynamic objects in C# 4.0 …and X++


    C# 4.0 which recently has been released introduces a new static type with the name dynamic. The semantic of declaring a variable as dynamic is to defer all type checking from compile-time to run-time.  This feature doesn’t enable new run-time capabilities, but it certainly makes your code more readable – especially when you interacting with not-strongly-typed languages, such as javascript or dynamic languages.

    Consider this example in C#. The example uses reflection to invoke a named method - “Add” in this case. There is no enforcement at compile time, i.e. there is no guarantee that obj has an “Add” method that takes 2 ints as parameters and return an int. Further, which is the point of this discussion, the example contains quite a lot of glue code, which obscures the intention.

      1: using System;
      2: using System.Reflection;
      4: class Class1
      5: {
      6:     static void Main(string[] args)
      7:     {
      8:         object obj = <some constructor>; 
      9:         object[] parameters = new object[] { 2, 5 };
     10:         Type type = obj.GetType(); 
     11:         int res = (int)type.InvokeMember("Add", 
     12:                BindingFlags.InvokeMethod, null, obj, parameters);
     13:         Console.Write("Result: {0}", res);
     14:     }
     14: }

    Now, let us rewrite the example to use the dynamic type. Notice how the intention is crystal clear. You still don’t get compile-time checking – but hey, you didn’t have that before either.

      1: using System;
      3: class Class1
      4: {
      5:     static void Main(string[] args)
      6:     {
      7:         dynamic obj = <some constructor>;
      8:         int res = obj.Add(2, 5);
      9:         Console.Write("Result: {0}", res);        
     10:     }
     11: }

    There is, of course, much more to this feature in C#. For example, you are able to control how the runtime checking behaves, and how the late-bound invocation is implemented.

    So far so good – but what does that have to do with X++?  Well, X++ is a strongly typed language – like C#; and like in C# you sometimes need to call into weakly typed objects. In AX forms, reports and datasets are weakly typed (i.e. they are not known to the X++ type system). So since the very first version of AX we have had the challenge of bridging this gap – without ruining the code readability.

    The interesting thing is that we in 1996 came up with the same solution to this problem, namely: Create a static type that instructs the compiler to relax all checks on operations on variables of the type. The C# solution is in many ways cleaner, more flexible and more robust – but the main principle of the solution is the same. You may already have guessed the X++ solution, but here it is: Types declared as object are not subject to compile time checking. This is of course an overloading of the object semantics – object is also the root base type of all classes. 

    Here is an X++ example, similar the C# examples above:

      1: static void LateBindingJob(Args _args)
      2: {
      3:     object obj = <some constructor>;
      4:     int res = obj.Add(2, 5);
      6:     info(strfmt("Result: %1", res));
      7: }

    Call me a geek – but it makes me happy when the two languages converge.

  • mfp's two cents

    TechTalk @ MDCC : Project Roslyn - Compilers and Services for the Masses by Brian Rasmussen


    If you are in the neighborhood and can spare a morning,  you are most welcome at Microsoft Developer Center Copenhagen for a TechTalk by Brian Rasmussen. It is free – but remember to sign up.


    The goal of the Roslyn project is not only to deliver the next generation C# and Visual Basic compilers and language services. Roslyn also provides a rich set of APIs for interacting with the entire compiler pipeline and data model. The Roslyn APIs make parsing source code, querying semantic information, analyzing data and control flows as well as scripting easy. In this talk we look at several examples of how to use the APIs to enhance tools and applications.

    About Brian Rasmussen

    Brian is a Senior SDET at Microsoft working on the next generation C# and Visual Basic language services in Roslyn. Before joining Microsoft Brian was a Microsoft MVP for Visual C# for four years. Brian is blogging on the C# FAQ ( and can be found on Twitter (@kodehoved).

    When:             May 24, 2012 at 09.30 – 10.30

    Where:            Microsoft Development Center Copenhagen, Frydenlunds Alle 6, 2950 Vedbaek

    Sign up:          Here

  • mfp's two cents

    Microsoft Dynamics AX 2012 Development Cookbook


    A new AX development book has just been published. It is an AX 2012 version of Mindaugas Pocius’ development cookbook for AX 2009.

    I’m looking forward to reading this new book and writing a review.

    You can download an eBook version of the book today, or order an hard copy here.

Page 16 of 19 (182 items) «1415161718»

mfp's two cents

...on Dynamics AX Development!