Thoughts on Training #1: Getting Started
2014-6-9 18:32

I tend to think I am not that a sentimental goof, but probably this alone proves I am. Nevertheless I vision myself looking forward and spotting the opportunities that lie out there, rather than being a sourpuss. Or say, being the Waldorf and Statler of the Dynamics world (or at least one part of this illustrious couple). Even though, every now and then, I label myself more or less like that.

Having been into C/SIDE training intensively lately, I cannot help but getting somewhat retrospective on this subject. At the same time I dare think that it might be somewhat entertaining to share this with you. If it all proves not to be of any value to you, just let me warble in my chair and you just pass by.

Way back in 1999 I made a major shift in my working live, moving from being a high school teacher to being a fulltime C/SIDE trainer for the Dutch Navision Software subsidiary. The move wasn't as strange as it might sound at first. Having graduated from the Delft University of Technology as an engineer in applied physics, my first engagement was as a scientific software developer at a small company that developed medical instruments based on small computer systems. FORTRAN and C had been my software hinterland for quite some years already. Hence, eventually getting into C/AL, wasn't that big a move at all and surely it was fun, and after all these years still is. Albeit that things have changed in many aspects.

Just take the simple matter of getting the systems up and running for a course. In those days the students would gather at our training location mostly without a machine. It might have been that some did bring a laptop, but that clearly wasn't custom yet. Whatever system they would be using, the only requisite it did need to comply with was that it was running Windows; nothing more was needed.

After a small introduction I would hand out a Navision Financials product CD and let each of the students run the installation wizard by applying Next > Next > … > Next > Finish. Within less than 5 minutes everyone was up-and-running with a clean demo installation of Navision Financials.

No SQL Server, no .NET framework, report viewer or Visual Studio. How many NAV pros in that time had even heard of Visual Studio?

No hassle with specific builds to be sure everything compiled right. Always possible to import .fob files from older versions (who did ever decide that I cannot import a NAV 2013 .fob into NAV 2013 R2?).

Only 5 minutes that separated us from diving into the subject, not being distracted by technology.

Honesty says it still isn't taking very long to get your system "training ready" and it definitely takes a zillion time less than getting "training ready" for AX. However, it isn't as easy as it used to be and there are dozen more reasons that can make your installation do something you do not want to focus on during a training.

by Luc van Vugt | 2 comment(s)
Filed under: ,
How-to: Jump to a Function from C/AL Globals
2014-6-9 0:42

Pentecost weekend. Finally I have moved somewhat out of the razzle-dazzle of months passed. Glad I succeeded to have planned Friday off, going to the hockey World Cup in The Hague. Sit, simmer (in the sun) and shout. And I don't care about all those Canadians thinking this is not hockey. Probably they never achieved something in this sport. Cool

So here is me picking up blogging again. Haven't been doing that a lot lately and can't say my list of subjects diminished. You know it's not only time that helps this list to grow. Performing C/SIDE courses, which I have been doing a lot lately, typically contributes to it also. Sitting in one room with NAV pros, independent of their experience level, always brings useful thing "on the table". Just like this undocumented feature: jump to a function. Never had been aware of it myself for the 15 years working with NAV now. Or has it been added only recently? Still never to old to learn. Wink

OK, I find myself inside a C/SIDE object looking a the list of user-defined functions on the C/AL Globals window.

Now I want to jump right to this function, taken CheckBlockedCustOnDocs in Table 18 as our example. I can make use of the Go To Defintion functionality right clicking my mouse.

This works great and it will bring focus to the C/AL Editor window. But you know, probably I am old fashioned, but the lesser I can use my mouse the more I prefer it. Hence instead of using the mouse it turns out that clicking the F9 key achieves the same.

Customer Survey: Microsoft Dynamics NAV upgrade
2014-4-24 16:00

Microsoft is really working hard on improving the Dynamics NAV upgrade story. Those who took part in the round table we held at the Dutch Dynamics Community with Dmitry Chadayev and Morten Jensen from Microsoft on last March 11, and those that attended the Upgrade session by Dmitry later that day, can tell. Both Dmitry and Morten, but probably more of their colleagues are really committed to this. And while they have been and are still working hard on this they are still very much interested in input form the field. And for sure not in the least from customers.

So because of that they have published a survey on Customer Source and are asking you all to contribute to their effort by providing them with your input.

So go there an do your thing.

The Anomaly of the XMLport Request Page
2014-4-8 18:31

The user interface of the XMLport has always been somewhat of a black swan. On the classic platform it was absent and you had to work around it yourself. With the emerge of the windows client (RTC) we did get a request page as one of the incentives for us to start adopting the 3-tier technology. And of course, with NAV 2013, the XMLport became the lawful heir of the deprecated Dataport. Nevertheless, it remains a black swan as the request page does not meet some of the standard features we know from pages and report request pages, as I only found out a couple of weeks ago. Talking about a black swan. Geeked

Did you notice that the About This Page feature is lacking on the XMLport request page?

And what about that Copy Link to XMLport action on the ribbon?

Why has this been implemented different from the same on the report request page and page objects? Just for completeness have a look at the objects:

I wouldn't call this a consistent UX.

OK, the Link to ... does what it should do even though UX-wise it's not consistent, but the lacking About this Page is something different. I have no means to identify the ID of the XMLport  and use that in a bug report ...

Of course I created a msconnect entry here to ask for more consistency (or at least get an About This Page feature for the XMLport).

Poisson d'Avril - The Sequel, part #4
2014-4-1 15:46

4th time in a row Microsoft has given me the MVP award. Even though I personally feel I haven't been on the edge of things as in the previous years, I know I have been doing my best the past year to share my knowledge and experience and bother Microsoft enough. Having been engaged primarily with a dev team at an end-user clearly got me off-edge, not saying that it hasn't been worthwhile as it clearly was, not in the least due to the people I have been working with, but also the change of perspective. Thanx, guys!

I surely haven't been writing a lot recently having been very busy with different projects like SEPA updates, conducting and organizing course, the Dutch Dynamics Community, TFS consulting, etc. And of course, trying to balance it all with the rest of daily live, which continues to be challenge for me.

A big hand to all who have been part of this all and supported me very well.

Workshop NAV ALM using Team Foundation Server
2014-3-4 17:45

In close cooperation with the Plataan I will be conducting a 2 days workshop on NAV ALM using Team Foundation Server. You're welcome to join!

Plataan - Microsoft Dynamics - Learning + Competence Management

Please check out below our new workshop 'NAV ALM using Team Foundation Server'.

“A perfect - no, even better - alternative to the various home brewed source control and product planning systems is Visual Studio Team Foundation Server (TFS).”

TFS for NAV Development

Did you know that TFS is a powerful ALM (Application Lifecycle Management) tool that can support your NAV development projects? Do you know that you can build your fobs by using the TFS build systems?

In this unique two day workshop (10-11 April in Hasselt), Dynamics NAV MVP Luc van Vugt will show you how you can manage and control your developments projects better by using Team Foundation Server (TFS) for NAV development projects.

A hands-on development exercise

Luc van Vugt will learn you how to use TFS in your NAV development projects for source control, product and project planning, test planning and execution, requirements gathering and documentation, code history tracking, bug tracking and activity planning. Students will have the ability to practice these new insights with a hands-on development exercise.

You will learn how to use TFS with the NAV development environment that is not integrated with Visual Studio.

This unique MVP workshop will answer questions like:

- How can I get my organization to work with TFS?
- Which software and hardware do I need for TFS integration?
- How to integrate the NAV development environment with TFS?
- How to build fobs with the TFS build systems?
- How can I secure my code and get better insight in the history?
- How can I better manage and track my product development?
- How can I design and plan testing?
- How can I track bugs?

This is a unique session by an experienced NAV MVP specialized in integrating TFS and NAV.

Extend Go To Definition with Navigation History
2014-1-15 10:36

... and enable back and forth browsing.

I often find myself in the situation that I have been navigating through some C/AL code using the Go To Definition feature of which I recon each NAV developer is still very pleased with since the introduction of it in NAV 2009 R2. For sure I am still using it on a daily basis.

Now finding myself at the end of a "chain of Go To Definition actions" I would like to navigate back towards my starting point. Having navigated from one object to another this isn't to difficult as this simple means closing each object that has been opened. But when this chain occurs in one object I have no way of easily doing this.

So I am longing for a navigation history that allows me to navigate in reverse order; even select from this history an individual intermediate stage, likewise with any internet browser; or Dynamics NAV. Cool

If you think this awesome please go to msconnect and vote for the suggestion I created there.

by Luc van Vugt | 1 comment(s)
Filed under: ,
NAV ALM with Team Foundation Server | How-to Videos
2014-1-15 8:48

As you probably have noticed I have been detailing my NAV TechDays starting with branch and merge strategies. Meanwhile "TFS brother in arms" Soren Klemmensen has taken off with how-to videos. Very instructive!

Click on the image to go to Soren's blog.

Soren has already created two videos:

NAV Branching & Merging Matters: Incorporating Standard NAV
2014-1-11 13:09

Reading my posts NAV ALM with Team Foundation Server | Branch Strategy and NAV ALM with Team Foundation Server | Merge Strategy you probably have been thinking: "Thanks and well done Luc, but doesn't sound like NAV specific."
You're totally right! The setups I discussed there are totally product independent; and these are only three of them. You might even study the wider range of setups discussed in the Branching and Merging Guide by the Visual Studio ALM Rangers and choose (or conceive) one that fits your needs better.

Now the logical question following would be: "Aren't there any NAV specific matters to consider?"
Sure there are, such as:

  • In most cases we use NAV standard as the basis of the product we are developing
  • Potentially we are not the only one making changes to this standard code as MS is frequently releasing hotfixes that we might want or need to incorporate into our product
  • Using (other) add-ons into our product in the same matter as NAV standard
  • Developing a product for an international market, i.e. being released to various local countries

In this post I am going to elaborate on how you could incorporate NAV standard in case you are developing a product for a local market (bullets 1 and 2). In later posts I might pay attention to the more broader picture of the third and fourth bullets.

Local Add-on

So your add-on is being developed for a local market in, let's say, the Netherlands (NL), meaning your code is added to NAVNL. Partly new objects and partly customized NAVNL objects.
Therefor we need a container to hold the NAVNL code (NAV/main) which we branch to our add-on (add-on/main):

To this add-on branch we will apply a strategy as discussed in NAV ALM with Team Foundation Server | Branch Strategy.
The schematic TFS structure would then look as follows:

Applicable hotfixes issued by MS will first be checked-in into NAV/main from where it will be integrated into the add-on:

Additional Layers

In the different development setups I have been working so far I have implemented a number of extra layers, which more or less results in a structure as displayed below:

Note that ...

  • NAV contains copies of the RTM code of all versions that have been relevant to us so far; this not only has historical sense, but has proven its worth dozens of times when needing to compare current code with previous versions of NAV
  • NAV/main is the folder as discussed above and always contains the code of the NAV version we are currently "on" with our product
  • Above NAV you might have noticed that the folder dynamics_NAV_development; this is the name of the Team Project that holds our NAV code (next to possibly other team projects holding .Net code)
  • Anywhere product (or add-on) is mentioned this can also be applied to project
feliz NAVidad and much more for 2014
2014-1-1 12:16

... to all of you.

I hope on next New Year's Eve you will all be able to look back upon 2014 concluding that it has been worthwhile, whatever it was that crossed your "road". Goosebumps on your skin, love in your heart, even though that "road" can be very, very, very tough.

Thanx to all that across my road in 2013.

by Luc van Vugt | with no comments
Filed under:
NAV ALM with Team Foundation Server | A Day in the Life of ...
2013-12-31 13:46

After our exploratory talk a couple of weeks ago, I was booked for yesterday by a Dutch NAV partner to help them out on their first steps 'into' TFS. Using Visual Studio Online we did setup a collection and a team project, drafted and implemented a branch structure and discussed the use of work items in relation to code check-ins and scrum methodology.

And among this all these basic questions recurred: what does it basically mean to be a NAV developer in a TFS environment? What are the specific task to be executed?

So here we go for a typical day in the life of … Luc, NAV developer happily using TFS.

  1. My Work
  2. Sync my TFS workspace
  3. Sync my NAV "workspace" - Import
  4. Do my "thing"
  5. From NAV to TFS workspace - Export
  6. Inspect pending changes
  7. Check-in change

1. My Work

Having had our stand-up with my team, I pour myself another cup of tea - yes, tea, as after half a century I still abhor coffee - and start up my laptop. I open my Visual Studio client and in the Team Explorer Home pane I click My Work to see what tasks are desperately waiting for me to get finished.

Nearing the end of our sprint unsurprisingly not very much. Some unfinished work (suspended work > participants) and two development tasks.

As one of my colleagues had pointed out during the stand-up that the … error when adding seminars … issue needs to be finished first to allow it to be tested, it's clear what I need to pick up. So I drag and drop 109 from available work items to in progress work

2. Sync my TFS workspace

But before I can start I need to make sure that my local development environment is in sync with TFS.

Get Latest

So I right click on the add-on node in the Source Explorer and select Get Latest Version. Any code change that has been checked into TFS by others will also now reside in workspace.

Forward integrate (optional)

If we are using a branching strategy with separate branches for each developer, like in the DTAP setup in my branching strategy post, I might also need to perform a forward integration (FI) - and check-in - to incorporate the latest changes in the beta/test branch into your own.

3. Sync my NAV "workspace" - Import

Now that I have updated my TFS workspace I need to make sure that my NAV "workspace" is synced too; i.e. import the updated objects into my local NAV development database.

I can do this per object, which makes sense when it concerns only a handful of objects. Or I could use some tricks to get this done more efficiently. I will dive into this in another post.

4. Do my "thing"

Now I can go ahead to do my "thing". Looking at the info the already resides on work item 109 (and the accompanying bug) I see that it's a simple issue due to an incomplete table relation definition, fix it in a couple of minutes and verify the fix with some straightforward unit tests.

5. From NAV to TFS workspace - Export

As the change has been implemented, it has to be exported to my TFS workspace.

6. Inspect pending changes

As I overwrite the existing version of the object in my TFS workspace TFS automatically checks it out for me appending it to the pending changes list to which I already have added the work item.

But before I will check-in this change I make sure I provide (1) some useful description of this change, (2) add the bug work item and (3) …

…, last but not least, will inspect the changes I made. This is one of these TFS features that makes me feel happy every time I am using it. I just have to right click on a changed object and select Compare with Latest Version to get a comparison between the current version on the server and the (changed) version in my workspace:

A simple, efficient and powerful way to check whether the changed objects do contain the fix or feature I implemented. Or did I forget to export the latest version from NAV?

7. Check-in change

Now that check, double-check proved me that all changes reside in my workspace I can check it in.

Using a branching strategy, like in the DTAP setup in my branching strategy post, I probably should propagate my changes to the consolidation branch beta/test. For this I need to perform:

  1. forward integration (FI), including a check-in, to incorporate the latest changes in the beta/test branch into my branch
    note that this is needed to make the next action simpler as it will first handle any changes in beta/test separate from mine
  2. a backward integration (BI), also including a check-in, to incorporate my change in the beta/test branch

Ouch …

… you might say as this seems typically more actions than you might be used in a traditional NAV setup where all devs code in a centralized database. You might be right, but we should not forget the broader picture of the setup we are in now.

  • Linking each check-in to the relevant work items ensures that code changes and information like requirements and design decisions are bounded
  • Each changeset can be propagated in a controlled way from one branch to another
  • I have current and previous versions of each objects at hand that can help me to easily check my changes against
  • ...
Christmas Eve: Merry, Merry Xmas
2013-12-24 13:54

Christmas Eve. Rain outside and moderate temperature. Cosy inside, having set the tree and decorated it with silver, red and gold, and the old electric candles that I inherited from days gone. Haven't used them for ages and still shining bright. Preparing our Kerststol with the dough to rise and now waiting for it. Wife and children gathering in our kitchen for some bread and setting up Smallworld. And urging me to join them.

So have to keep it short and thus remains to wish you all a merry Xmas!

by Luc van Vugt | with no comments
Filed under:
The Next Generation PartnerSource/CustomerSource?
2013-12-2 16:02

Did you see this communication on PartnerSource/CustomerSource?

Having been harsh on MS various times with respect to PartnerSource I must admit I was quite astounded by this news. I really had to overcome some disbelief and force myself to read the article and let go of my prejudice. Yes, I still have to wait to January 11 before I will be able to believe my eyes. And yes, I will do my utmost best to be positively surprised and fiercely hope this promise will stand.

And as the Microsoft Dynamics Community Team writes:

Let us know your thoughts!

Again, this is just the first step in a longer journey. At launch in January, we’ll provide a detailed 2014/2015 roadmap and show you a list of the capabilities we’re shooting for, not just in PartnerSource, but also in how we evolve the customer journey. We also recommend reviewing the Next Generation PartnerSource and CustomerSource FAQ to help alleviate some general questions you may have. If you’d like to submit questions or comments prior to launch, please contact us at and we’ll get back to you quickly.

Book Review: Microsoft Dynamics NAV 2013 Inside
2013-11-26 18:19

When Rene Gayer informed his fellow Dynamics NAV MVPs, me included, about his new book on NAV 2013, I directly volunteered to read it and provide him with feedback. Looking back I guess I did not fully understood the implication of the first lines in his May 28, 2013, mail to us:

finally..uff our new Book NAV 2013 Inside will be available on 01.06.2013..
puuhh deferral of 6 month .. hard work ..

Now finally having read this 500+ pager, I do. I guess you understand why it took me almost half a year to get to finish the book, next to doing some many others things. As said a 500+ pager, discussing zillions of useful things about NAV 2013. Both Technical and functional.

But let me, before I continue, first make a small, but essential, correction here: it's not his, i.e. Rene's, book alone, it's a joint cooperation of three Dynamics NAV pros, who did a darn good job by compiling all this information into this Inside. Thumbs up for Rene, Michaela and Christian. Yes

Table of Contents

Just a simple glance at the table of contents shows the extend of the book:

  • Chapter 2 – General Introduction to Microsoft Dynamics NAV® 2013
  • Chapter 3 – Usability improvements
  • Chapter 4 – Application Enhancements
  • Chapter 5 – Installation, Configuration and Maintenance
  • Chapter 6 – Page Design in Microsoft Dynamics NAV 2013
  • Chapter 7 – Report Design in Microsoft Dynamics NAV 2013
  • Chapter 8 – Query Design with Microsoft Dynamics NAV 2013
  • Chapter 9 – Introduction to the Web Client
  • Chapter 10 – Introduction to the SharePoint Client
  • Chapter 11 – General News in C/AL and C/SIDE
  • Chapter 12 – Debugging in Microsoft Dynamics NAV 2013

Being around in the NAV world for almost 15 years now, and having been included in the TAP program of NAV 2013, I had some smug internal voice wondering if it would really be worthwhile for me to read it at all; to spend my precious time on it. Luckily there were still other voices taking a so much different standpoint. Thank you!

Now having taken the trouble of reading the book, I am glad I did. Now I know that, next to the standard Microsoft Dynamics NAV 2013 resource on MSDN, I can turn to this resource and most probably find answers regarding NAV 2013 issues. Or direct others to, and herewith do!

Of course you might wonder, if I am only positive to help Rene et al, and that's not the case. I really like the book for what it is, forwhat I said above. But indeed, there are a couple of minor points:

  1. Being nonnative English writers, they did quite a good job, but it's not always smoothly to read
  2. I do miss an index; of course using a .pdf I have the Adobe Reader text search functionality, but if you buy a hardcopy, you will have that and then searching for something specific might prove a hard job to do

But these will not keep me from using the book. Stick out tongue


Did I convince you of the value of this book? Then go out to and buy a copy yourself.

NAV ALM with Team Foundation Server | Merge Strategy
2013-11-24 8:51

With my branch strategy post, I have provided you with a basis to design a source control structure to store your code in TFS. However, this is just half the story when it comes to how to keep the various branches in sync to the right extend. So here comes in the merge part of the strategy, i.e. the "what about all those FI and RI arrows going up and down?" question I left hanging in the air at the end of my branch strategy post.

Note: the branch strategies discussed (and also not discussed but to be found in the the Branching and Merging Guide by the VS ALM Rangers) can also be applied to other source control systems like Perforce.

We'll use the DTAP setup to dive into details.

Scenario 1: hotfix implementation and propagation

A hotfix is typically issued on a release. Using the DTAP setup you would be ending up updating the code in the relevant release branch, say Release 2.1. So let's focus on this.

A bug has been reported on release 2.1 and this needs a hotfix that at ...

  1. ... will be implemented in the related branch: Release 2.1

    as this bug was also proven to exist in our current product, i.e. Main, you want to integrate this fix at ...
  2. ... from Release 2.1 into Main, which is called a reverse integration (RI) as Release 2.1 was branched from Main

    to bring the rest of our structure in sync with this change we also need to propagate this to the other branches starting at ...
  3. ... with a forward integration (FI) from Main to Test - forward as Test is branched from Main

    and at ..
  4. ... with a forward integration (FI) from Test to DevelopmentDevelopment is branched from Test!

As there are many roads that lead to Rome, there are various ways to achieve this hotfix implementation and propagation, the above being one of them. And alternative scenario could be the following, leaving it to you to fill in the details from steps 1 to 4.

You might consider this scenario to establish a double check before propagating the fix to Main.

Scenario 2: feature development

Clearly the development of a new feature will be done in (one of) the Development branch(es). You've got all requirements and some kind of technical design, thus ready to take off.

But before you start make sure at ...

  1. ... to bring your Development branch in sync with Test by means of a forward integration (FI) and then continue at ...
  2. ... to do the implementation of the feature; once ready, i.e. code ready and technically tested, you would like to propagate it to Test

    now before you do this, always makes sure that code in Development and Test share the same base as this will make the merging much easier, therefor at ...
  3. ... bring Development branch in sync with Test by means of a forward integration (FI) and then continue at ...

    Note that in our case this FI is strictly not necessary as we already did this at step 1, however, during the time you are developing the feature, and before you want to integrate it with Test, most probably other updates have been propagated to Test, thus this FI
  4. ... to integrate your feature from Development to Test

    for the sake of ease let's assume the feature has been fully tested and approved to be brought into Main, but, likewise step 3 above, you first need to bring Test at level with Main, so at ...
  5. ... bring Test branch in sync with Main by means of a forward integration (FI) and then continue at ...
  6. ... to integrate your feature from Test to Main

In a later stage the feature will be part of the release by means of the release creation (i.e. branch) at 7.


  • Reverse and forward integrations can be performed with the standard TFS merge functionality, either from the UI or cmd
  • So far this all is not NAV specific


More Posts Next page »

Recent Posts


Email Notifications

This Blog


Favorite BLOGS


Team Foundation Server BLOGS