Truncate BizTalk Servers database log files to clear up space
22 December 11 09:50 PM | Johan Hedberg

First: A Disclaimer. Do NOT attempt this in your production environment.You risk loosing data.

We had an issue in a test environment where the Backup BizTalk job was not configured and had caused the log files to fill the disk to it's limit. The data in the environment wasn't important and destroying a coherent backup chain and point in time restore was not a big deal. We just needed to get the environment back fast to allow test to continue.

I quickly wrote and ran the script below that does the job of truncating BizTalk Servers log files to make the environment functional again. Be aware that this will break the coherence of the log backup chain. To get a point in time that you can restore to you could opt to take a full backup immediatly following this operation if that is important to you. Before running this script you should stop all services that uses the database and make sure that all connections are closed if you want to make sure that your databases are left in a transactionally coherent state.

USE master
ALTER
DATABASE BizTalkMgmtDb SET RECOVERY SIMPLE WITH NO_WAIT
ALTER DATABASE BizTalkDTADb SET RECOVERY SIMPLE WITH NO_WAIT
ALTER DATABASE BizTalkMsgBoxDb SET RECOVERY SIMPLE WITH NO_WAIT
GO

Use BizTalkMgmtDb
DBCC SHRINKFILE (N'BizTalkMgmtDb_log' , 0, TRUNCATEONLY)
GO

Use BizTalkDTADb
DBCC SHRINKFILE (N'BizTalkDTADb_log' , 0, TRUNCATEONLY)
GO

Use BizTalkMsgBoxDb
DBCC SHRINKFILE (N'BizTalkMsgBoxDb_log' , 0, TRUNCATEONLY)
GO

USE master
ALTER
DATABASE BizTalkMgmtDb SET RECOVERY FULL WITH NO_WAIT
ALTER DATABASE BizTalkDTADb SET RECOVERY FULL WITH NO_WAIT
ALTER DATABASE BizTalkMsgBoxDb SET RECOVERY FULL WITH NO_WAIT
GO

Keep in mind that this is just a sample, add and deduct databases as needed, change the name of log files etc. Once done restart the BizTalk Services and you should be good to go.

You really should, as a first, second and third option, configure the Backup BizTalk job to stop unchecked log file growth. The backup job will make sure that log files don't grow out of control. You will however need to set something up to clear away the backup files created instead. Here is one option for doing that

There is also something you can do to reduce the size of the log files - enable compression. You can read more about that here.

This log file growth happens because BizTalk Servers databases by default uses the FULL recovery mode. Setting the BizTalk Server databases in SIMPLE mode permanently is a so-so idea. If you really do not need and will never do backups and understand that restore or recover in this case will mean re-install and start from scratch, then ok. If that is not the case, then SIMPLE mode is a bad idea. You can read more about why here. I'll give a hint though - DTC transactions.

HTH
/Johan

Used and unused hosts sql script
22 December 11 08:34 PM | Johan Hedberg

This is just a log post of a script I put together. When setting up a plattform we are not always certain what hosts and handlers the customer wants. We usually set it up according to common requirements and best practices. In that case it's also interesting to see what hosts are indeed used and not used once the solution is deployed, so you know which ones can be removed if requested. This is a sql script for that. Although this information can be found out using the Administration Console these kind of reports are not easy to get out and there is no one view for it. It's much easier to access the database BizTalkMgmtDb directly for these things.

select h1.Name from adm_Host h1 where h1.Name not in(
select distinct h.Name as Host --, a.Name as Adapter, rp.nvcName as Port
from adm_host h
join adm_receivehandler rh on h.id = rh.HostId
join adm_receivelocation rl on rl.ReceiveHandlerId = rh.Id
join bts_receiveport rp on rp.nID = rl.ReceivePortId
join adm_adapter a on a.id = rh.AdapterId
UNION
select
distinct h.Name as Host --, a.Name as Adapter, sp.nvcName as Port
from adm_Host h
join adm_SendHandler sh on h.Id = sh.HostId
join bts_sendport_transport spt on spt.nSendHandlerID = sh.Id
join bts_sendport sp on sp.nID = spt.nSendPortID
join adm_Adapter a on sh.AdapterId = a.Id
UNION
select
distinct h.Name as Host --, '*Orchestration' as Adapter, o.nvcName as Port
from adm_Host h
join bts_orchestration o on h.Id = o.nAdminHostID
--UNION
--select distinct h.Name as Host, * --, '*Tracking' as Adapter, NULL as Port
--from adm_Host h
--where h.HostTracking = 1
)

HTH
/Johan

Filed under: , ,
Updates to bLogical.BizTalkManagement powershell BizTalk Server database restore commandlets
19 December 11 03:19 PM | Johan Hedberg

I've uploaded a new version of the bLogical.BizTalkManagement restore powershell commandlets originally posted by Mikael. The updates are minor and adress the parsing of filenames and cleanup of the code to get rid of some god intentions that never became more then intentions, aka unused code.

If you have no idea what I am talking about, feel free to read the original article and give them a try. We are using these heavily for customers instead of log shipping and it really makes the whole process of restoring your databases easy.

How I diagnosed en elusive ‘is not a valid Win32 application’ exception
06 December 11 10:06 PM | Johan Hedberg | 4 comment(s)

We were using BizTalk Server 2010 and the MQ Client (MQSC) adapter from Host Integration Server 2010 (HIS 2010). We had been getting an exception on and off on servers without really knowing why it appeared on some servers and not on others. We even opened a case with Microsoft, but they are only human like the rest of us and can’t magically diagnose and solve errors remotely based on vague input, so that really didn’t lead anywhere other then things like “Make sure you are running the adapter in a 64-bit process”. The exception message was this:

The adapter "MQSC" raised an error message. 
Details "Could not load file or assembly 'Microsoft.BizTalk.Adapter.Mqsc.ImqWrapper.dll'
or one of its dependencies. is not a valid Win32 application. (Exception from HRESULT: 0x800700C1)".

It’s enough to say that we investigated the error in a number of ways, including making sure that the specific dll mentioned was present. But as we all know the “or one of its dependencies” can hide any number of referenced dlls. So we made sure that the machines that worked and the ones that didn’t had the same assemblies available, which they did. Still no luck in narrowing it down. Luckily the exception happened right when you enabled a receive location so it was easy to identify and therefore to reproduce and troubleshoot.

I resorted to using Process Monitor (not to be confused with Process Explorer, although also a great tool not the best in this scenario). I started the tool, found the PID for the process running my MQSC adapter process (see this post for details on identifying the BTSNTSvc process that belong to a certain host and get the PID) and set a filter for just that PID to reduce the noise. Finally I enabled the receive location. That gave me this:

clip_image001

As you can see in the image BizTalk Server is probing for an assembly in different locations, and it’s not the Microsoft.BizTalk.Adapter.Mqsc.ImqWrapper.dll. It’s the imqb23vn.dll from the WebSphere MQ installation. It’s trying to locate the assembly and finding it in the WebSphere MQ\Bin64 folder. However it gets an Access Denied when trying to access it, so it then continues on to the WebSphere MQ\Bin folder, where it locates the 32-bit version, which is does have access to, and so it loads it.

The exception message then is not saying that a 32-bit process is trying to use an assembly meant for a 64-bit process, but the opposite; that the assembly we are trying to load cannot be loaded as the application that is loading it (in this case BTSNTSvc64.exe) is a 64-bit process, aka not a valid win32 application.

Setting the correct permission on the file and hooking onto the process once again to see what it is doing verified the theory. The image below shows how it loads the correct 64-bit version of the imqb23vn.dll and the continues on to the next assembly which has the same issue and causes the exception once again. The exact same exception, but this time caused by another underlying referenced assembly:

clip_image001[4] 

Setting appropriate access permissions on the entire folder made the process complete without exceptions and the adapter able to successfully connect to the MQ queue and pick up the messages on it and deliver them to the messagebox. Why the folders ended up getting different permissions in this way is still a mystery…

HTH,
/Johan

Book Review: Microsoft BizTalk 2010: Line of Business Systems Integration
24 October 11 10:53 PM | Johan Hedberg

If you are looking for more information on understanding the WCF LOB Adapter SDK and how to build adapters with it and how the pre-built adapters available in the BizTalk Server 2010 Adapter Pack can help getting data in or out of SQL Server or with handling IDOCs, RFCs and BAPIs in SAP then this is a book for you. If you are also interested in integrating with Dynamics CRM or Ax, working with Sharepoint Documents, Forms and Lists, and connecting to the cloud in the form of AppFabric and Salesforce then even better.

At first, from the title, I had expected this book to cover the Adapter Pack. It covers the parts in the first paragraph. This means it does not cover the full content of the Adapter Pack, but on the other hand it covers a lot more, which is a good thing.

This book contains detailed walkthroughs and step-by-step instructions. Not only will you learn how and what to do, you will also learn what no to do and share the authors real world experience. The book is sprinkled with tips and tricks from exposure to the technologies and products involved. And the book is just the beginning. Throughout you can find additional references to blog post, msdn pages and other resources.

I love getting that level of detail, especially accompanied with good visualizations and screenshots so there is no mistaking what a textual description means. Perhaps sometimes the level of detail might be unnecessarily high and the books intended target audience shouldn’t need a screenshot of how to deploy a BizTalk project, or the full context menu that you get when you right click a project to get to the Add… menu item, or the welcome screen of the Consume WCF Service wizard. But that only goes to show that nothing is left to chance and the reader wont be left guessing what was intended. I also like how a good mix of text and pictures make you feel that you are doing good progress reading the book.

My experience is, that of the time spent developing an integration, a large part is spent understanding how the systems you need to integrate work. Most BizTalk books don’t capitalize on that. Instead they use all of their space to explain how the BizTalk technology works in some aspect. This books differs in that respect in that it spends a large part explaining how the LOB systems work, and how you go about setting up and developing the integration components needed inside those systems before continuing on to BizTalk and the integration solution developed there. That to me is the real value add of this book. The day that you feel you don’t have to learn that is the day you can’t do integration work on your own but need someone else to do half the work for you.

Overall, the books content is still really fresh, even the chapters on cloud and AppFabric are still valid, which is always a risk when covering that kind of a rapidly evolving technology. Later releases has complemented some of the techniques presented with other options, but not necessarily replaced them.

I can highly recommend this book if the topics and systems it covers are part of your system integration landscape. I learned plenty and I know I’ll return to read parts of it again more closely as additional systems enter my landscape.

HTH
/Johan

Filed under: ,
Simpler, Smoother, Smarter
15 October 11 11:04 AM | Johan Hedberg | 2 comment(s)

We (Enfo) had an internal image contest on the above theme. Unfortunately the images that you could enter was supposed to be of yourself at arms length showing your face. Since I couldn’t quite imagine how I could make myself express those three things by simple face expression I took another picture. And since it wont make the image contest I am instead posting it here.

CloudPower1

I am no graphical designer, though at times I could fool a few, but hail Powerpoint as far as my image processing skills go ;)

Filed under:
Integration @ Sommarkollo 2011
22 June 11 09:43 AM | Johan Hedberg

So, once again it’s that time of the year. Summer. And with it Microsoft Sweden arranges a series of presentations across the country that goes under what word-by-word translates to summer school – Sommarkollo. I’m happy to be presenting about integration in the broad context of the Microsoft Application Infrastructure aka Middleware platform, aka BizTalk Server, Windows Server AppFabric and Windows Azure AppFabric. A lot of the content will be focused around Azure AppFabric, simply because that’s where most things are happening at the moment (1) (2).

image

Find the signup to my afternoon slot in Gothenburg on Tuesday the 28th of June here, and the same content in a morning slot in Stockholm on Thursday the 30th of June here.

Right now I’m at ~60 slides and 12 demos but I’m hoping to get access to the newly released Application Manager and Composition soon so I have time to incorporate some of that as well. We’ll see.

Also take a look at the pdf that nicely summarizes all available sessions.

See you there.

/Johan

BizTalk Mapper - How-to execute xslt statements and use the result as input to other functoids
10 June 11 07:09 AM | Johan Hedberg | 1 comment(s)

This post will present a short demonstration of how to use the result of a Scripting functoid doing XSLT to something else then creating a node in the destination document.

This post relies on the following concept, and your familiarity with them:

The sample is simple, and what it does could be solved in a much simpler way. I am not out to show of some complex application – I want to show a very simple example, and let you apply it to whatever complex scenario where you think it may be a fit.

Here is the map:

image

Given this (extremely simple) input:

<ns0:Root xmlns:ns0="http://SwebugMapping.C">
  <Cars>
    <Car>
      <Registration>Registration_0</Registration>
      <Brand>Brand_0</Brand>
      <Color>Color_0</Color>
    </Car>
  </Cars>
</ns0:Root>

It will create the same output (phew!). Nothing fancy by far.

As you might have seen from the screenshot though, the magic of it all, and what I want to show, is how I use xslt to transfer the data via an (for this small scenario) obscure and unneccesarily complex yet (for more demanding scenarios) extremely powerful and dynamic mix in of xslt in an otherwise “normal” map. There are scenarios where this is very useful.

The first functoid uses the global variable conecept to create an global variable. It also holds a method returning a void that allows it to be connected to the root node of the destination without creating an output. Additionally it uses a trick where a scripting functoid will allow you to specify multiple methods within the functoids script, although only the first will be the one triggered to create the functoids output. This second method will be used to update the value of the global variable.

string MyStringValue;

void initglobals ()
{}

void SetMyStringValue(string s)
{
  MyStringValue = s;
}

The second functoid uses and scripting functoid with the xslt call template to transfer the registration node. But it also, in bold and italic below, calls the user defined csharp method we created in the first functoid that updates the global variable. It can perform virtually any type of xslt logic and that pass that in as a parameter, like the keyed cumulative sum – but in this case simply selects the value of the Color node and sets that value. Like I said – I’m not out to present a complex scenario. I’m out to make it simple to understand. Putting it to good use in a complex scenario is your job!

<xsl:template name="MyXsltCallTemplate">
  <xsl:param name="registration" />
  <xsl:variable name="var:u1" select="userCSharp:SetMyStringValue(string(Color/text()))" />
  <xsl:element name="Registration">
    <xsl:value-of select="$registration" />
  </xsl:element>
</xsl:template>

Lastly the third scripting functoid simply outputs the value of the global variable completing the map that creates the same output as it got input.

public string GetMyStringValue()
{
  return MyStringValue;
}

Cool huh? At least I hope I got you thinking about how to combine the power of xslt and the BizTalk Mapper for those complex scenarios where direct usage of xslt just makes so much more sense then trying to get the same result out of mad series of chaining of “regular” functoids which sometime border on bringing about semi-suicidal thinking.

/Johan

Filed under:
BizTalk Mapper - How-to create global variables
09 June 11 12:20 PM | Johan Hedberg | 4 comment(s)

One of the things that can be fairly useful in BizTalk maps is the ability to create global variables. These can be any .Net class that can be accessed from the map, everything from simple bool or int values to generic classes such as List<string>. You create these from within a c# scripting functoid and can use them from within the same or other scripting functoids.

A good place to create and initialize global variables is in a scripting functoid at the top of the map (or in another standardized location) so you always know where to look for them.

For any functoid to be triggered it needs to be connected to an output node, and it needs to contain (at least) one c# method. Yet the functoid containing your global variable initialization you often do not want creating output. To create a functoid that will initialize your global variables without creating output create a method that return a void. Such a method will not create any output, yet it will – when connected to node in the destination schema - be included in the resulting and called from the xslt. A good practice is to connect this functoid to your Root node, whatever that node might be named.

The following is an example of a map that creates and uses a global variable:

image

The functoids has the following content, from top to bottom:

string myGlobalString = "hello";

void InitGlobals ()
{
// you can do any initialization logic here
}

This code creates a global variable and has an empty method returning void to fulfill requirements yet yield no output. This is really the only snippet needed, the one that shows how to create a global variable, the rest simply show some examples of how to use it.

string GetGlobalString ()
{
  return myGlobalString;
}

This method takes no input, but returns the globally available string that we defined in the first functoid and returns it – just to show that it’s available.

string UpdateAndReturnGlobalString(string s)
{
  myGlobalString = s;
  return myGlobalString;
}

This method takes an input, and then updates the global variable with that input, before returning it. This is just to show that you can do things to your variable – it is not a constant. For example, had this been a collection, you could add items to it.

This post, although something fairly well know within the community of seasoned BizTalk developers, is meant to illustrate how you can think outside the Mapper designer and the xslt box when developing BizTalk maps. I also created it for the purpose of being able to refer to it as I create posts that are more advanced in nature, without having to explain this concept in those posts.

/Johan

Filed under:
BizTalk Mapper - resolving decimal sum and separator issues, Keyed Cumulative Sum continued…
18 May 11 07:59 PM | Johan Hedberg

As a continuation of my Keyed Cumulative Sum post, where I did a key based summation using an xslt call template in a BizTalk map I got two main points of feedback worth repeating and showing.

Questions

  1. If I use Sum on a decimal number it gives me all sort of weird decimals in the Sum although it shouldn’t; ie a sum of 1.1 and 1.1 could result in 2.199999999999. How do I solve that?
  2. What if I am in Sweden (or Germany or some other country) and I want to use a comma (,) as a decimal separator instead of a period (.). How can I do that?

Answers

  1. You can use the xslt format-number function to remove erroneous decimal digits that are the result of using Sum on a decimal number.
  2. You can use the xpath translate function to replace a period with a comma. However this does not conform to an xsd:decimal, so make sure that the target schema does not have this field defined as a decimal if you wish to be compliant.

This will make the outlook of the xslt instead look like this (code is edited to improve readability):

<xsl:template name="OutputSum">
  <xsl:param name="param1" />
  <xsl:param name="param2" />
  <xsl:element name="Compensation_Amount">
    <xsl:variable name="SumOfNodes" select="//row[Compensation_SubCode=$param1 and   
Compensation_Level=$param2]/Compensation_Amount)"
/> <xsl:variable name="FormattedSum" select="format-number($SumOfNodes,'0.00')"/> <xsl:value-of select="translate($FormattedSum, '.', ',')" /> </xsl:element> </xsl:template>

The use of several variables are for maintainability only, and are not required. You could jam it all into the value-of select statement if you really want to.

/Johan

Filed under:
Yes, that’s my face in the paper today
03 May 11 07:00 AM | Johan Hedberg | 1 comment(s)

Annons1

In essence it says that we are looking for new recruits in the Microsoft (Integration) area. Great opportunities for the right person.

Also see http://www.zystems.se/

Filed under: ,
BizTalk Mapper - Keyed Cumulative Sum
02 May 11 11:52 PM | Johan Hedberg | 4 comment(s)

From time to time I get questions about mapping puzzles, and I love it! Send me more of those! (I realize might regret that statement later). This time the puzzle was how best to do a conditional cumulative sum, or keyed conditional sum, also possibly known as grouped conditional sum.

The scenario is this (I’ve removed some namespaces etc for readability):

<Compensation>
  <rows>
    <row>
      <Compensation_Code>1</Compensation_Code>
      <Compensation_SubCode>1</Compensation_SubCode>
      <Compensation_Level>1</Compensation_Level>
      <Compensation_Id>1113</Compensation_Id>
      <Compensation_Days>41856.50</Compensation_Days>
      <Compensation_Amount>25288084</Compensation_Amount>
      <Compensation_Tax>6690289</Compensation_Tax>
    </row>
  <row>
      <Compensation_Code>1</Compensation_Code>
      <Compensation_SubCode>1</Compensation_SubCode>
      <Compensation_Level>1</Compensation_Level>
      <Compensation_Id>1113</Compensation_Id>
      <Compensation_Days>41856.50</Compensation_Days>
      <Compensation_Amount>29627</Compensation_Amount>
      <Compensation_Tax>6690289</Compensation_Tax>
    </row>
    <row>
      <Compensation_Code>1</Compensation_Code>
      <Compensation_SubCode>1</Compensation_SubCode>
      <Compensation_Level>2</Compensation_Level>
      <Compensation_Id>1113</Compensation_Id>
      <Compensation_Days>41856.50</Compensation_Days>
      <Compensation_Amount>234348</Compensation_Amount>
      <Compensation_Tax>6690289</Compensation_Tax>
    </row>
  </rows>
</Compensation>

How do you best produce a map that as step one summarize all Compensation_Amount for each variation of Compensation_SubCode, and returns this (let’s call this scenario 1):

<Compensation>
  <rows>
    <row>
      <Compensation_SubCode>1</Compensation_SubCode>
      <Compensation_Amount>25552059</Compensation_Amount>
    </row>
  </rows>
</Compensation>

and as step two, summarize all Compensation_Amount for each combination of Compensation_SubCode and Compensation_Level, and return this (let’s call this scenario 2):

<Compensation>
  <rows>
    <row>
      <Compensation_SubCode>1</Compensation_SubCode>
      <Compensation_Level>1</Compensation_Level>
      <Compensation_Amount>25317711</Compensation_Amount>
    </row>
    <row>
      <Compensation_SubCode>1</Compensation_SubCode>
      <Compensation_Level>2</Compensation_Level>
      <Compensation_Amount>234348</Compensation_Amount>
    </row>
  </rows>
</Compensation>

You might start thinking custom xslt and xsl:sort or xsl:keys or muenchian methods and things like that. That’s one way to do it. I actually prefer using the mapper for most maps until performance forces me to go another way.

My solution for scenario 1:

clip_image001

My Solution for scenario 2:

clip_image002

I am not presenting a complete solution for scenario 1, since it’s really just a subset of the functionality required for scenario 2, but you should get the point from the explanation of scenario 2.

The magic of the scenario 2 solution happens in the three scripting functoids. The first one, connected to the destination root node contains the following snippet (again namespace deprived for readability):

List<string> keyList= new List<string>();
void initglobals() {}

It’s simply responsible for making sure that the variable keyList is set up. The empty method that return void ensures that I can connect this to an output node to make sure it triggers, yet it will produce no output.

The next functoid then makes use of that list, and adds all unique keys to it (which is unique combinations of the two keys separated by a secure character, in this case a colon):

public string AddKey(string key)
{
  if (keyList.Contains(key))
    return string.Empty;
  keyList.Add(key);
  return key;
}

The Not Equals functoid then makes sure that we will only see output when a new unique combination is found, by checking to make sure that the string outputted from the scripting functoids <> and empty string.

The third functoid then is responsible for doing the summation (I’ve inserted a linebreak and some spaces in the xpath statement for readability, so don’t just copy paste this):

<xsl:template name="OutputSum">
  <xsl:param name="param1" />
  <xsl:param name="param2" />
  <xsl:element name="Compensation_Amount">
  <xsl:value-of select="sum(//row[Compensation_SubCode=$param1 
              and Compensation_Level=$param2]/Compensation_Amount)" />
  </xsl:element>
</xsl:template>

This simple xslt call template takes the two key values in, and does a summation of all rows that has these key values set to these specific values.

Now someone might object and say that this would mean an unnecessary amount of summation gets done. But that’s actually not the case, the mapper is clever enough to only do this under the condition of the Not Equals functoid returning true, as the following xslt snippet shows (this is just a portion of the xslt generated):

<xsl:variable name="var:v3" select="userCSharp:LogicalNe(string($var:v2) , &quot;&quot;)" />
<xsl:if test="$var:v3">
  <row>
    ...
    <xsl:call-template name="OutputSum">
    <xsl:with-param name="param1" select="string(Compensation_SubCode/text())" />
    <xsl:with-param name="param2" select="string(Compensation_Level/text())" />
    </xsl:call-template>
  </row>
</xsl:if>
’So a short summation (pun intended) of the work involved:

1. Create a global variable, a list to hold keys

2. Add to that list once you discover a new key

3. Add logic to that discovery to only output your destination node when you hit a new key

4. Implement a xslt call template and use xpath to sum based on your keys

Filed under:
My TechDays 2011 presentations - something old, something borrowed, something new and something blue
30 April 11 05:10 PM | Johan Hedberg

This is bordering on being somewhat old news (but don’t blame me for that). I attended the Swedish TechDays as a speaker, user group leader and ask the experts answerer. Now as far as the first one goes my two sessions “Windows Azure AppFabric - Middleware i molnet” (Middleware in the cloud) and “.NET utvecklare - utöka verktygslådan med BizTalk Server” (expand your toolkit with BizTalk Server) are now available online (unfortunately there is no direct links since they are hidden away inside a Silverlight player application). However note that they are in Swedish. My presentation slides should be available alongside them shortly, and those are (at least mostly) in English. I’ll give you a preview…

BizTalk for NET Devs 1BizTalk for NET Devs 2

The site makes those available as pdf’s. If you ask me nicely though, I might let you get your hands on the pptx’s ;) I am however not shy to borrow from previous presentations held by Microsoft or other luminaries if those are made available online an encouraged to be (re-)used. And since I have been doing BizTalk presentations for quite some time I do have some of my my favorite slides in there, so if you have seen a presentation by me before, chances are you will recognize a slide or two, even if most of what I communicate is still new. Thus you will find “something old, something new, something borrowed and something blue” (since the theme for this years TechDays was blue on a black background). Enjoy.

emailsignature

The 70-595 exam and the first rule of fight club
29 April 11 11:08 PM | Johan Hedberg | 5 comment(s)

I’ve had a not-so-few asks to blog about the 70-595 exam. I’m answering those calls with this post.

The exam launched on march 30th. I actually tried taking it on the 7th of April, though due to technical difficulties, on Prometric and the testing sites behalf, I had to leave without getting a chance to do it after waiting 90 minute for the issue to be resolved (see my twitter history if you want more on that story). I found the time to come back a week later though, on the 14th, and manage to successfully pass the exam.

70-595 is the Developing Business Process and Integration Solutions using BizTalk Server 2010 exam. Its coverage includes core BizTalk functionality as well as extended capabilities. The excerpt from the exams Microsoft learning page is:

Configuring a Messaging Architecture (20 percent)
Developing BizTalk Artifacts (20 percent)
Debugging and Exception Handling (17 percent)
Integrating Web Services and Windows Communication Foundation (WCF) Services (14 percent)
Implementing Extended Capabilities (13 percent)
Deploying, Tracking, and Supporting a BizTalk Solution (16 percent)

Which brings me to the first rule of fight club, and why Tyler Durden would be a good MCP (therefore not claiming that we (MCPs) are all insomnia cursed paranoid schizophrenics in any way ;).  But, “You don’t talk about fight club”, as in “You don’t talk about the contents of certification exams”. In fact you actually agree to an NDA about the contents of the exam - not that that stops any of the cheat sheet providers out there or the people that use them, but it does me. Therefore, you will not find any details as to what kind of questions or what specific areas were covered. All I’m going to say about the contents of the exam is that it pretty much mirrored that division into areas.  So let’s delve into that…

…and rephrase those percentages in another way:
Core functionality (like messaging, development, debugging, deploying, tracking and troubleshooting) make up roughly 90%, and BAM, BRE, RFID and EDI make up the other 10 percent.

Since the test is 50 questions, that would mean that on an average 45 question would be on the core functionality and 5 questions on the rest.

Following on with the math lesson that means that you are very likely to make the passing score of 700 (out of 1000), without any deeper knowledge on the “extended capabilities”. Which I know will be a soothing thought for a lot of people. No guarantees though, because it’s not always a 1 question =  1000/50 points kind of thing.

If you want to truly ace the test, you’ll really need to know all of your BizTalk, including reading into things like RFID. I did not ace the test (as in a perfect 1000), though I did reasonably well; close enough for me to be pleased and well within the margin.

How did I prepare is a question that often follow along with the ask to write a post on the subject. Others might compose a prep guide. I won’t. Not in this post anyway. I do have a simple answer with two sides to it for you though. One the one side – I didn’t. On the other – I prepared working in real BizTalk projects over the course of 6 years, 5 version of the product and took the two exams that came before this one. What I am saying is – if that sounds anything like you you are likely to just as I did just go take the test, and you’ll likely be fine. If it doesn’t – well, you know yourself best – perhaps you need to study?

On the note of previous tests, I found this to be about the same level of difficulty as the 2006 exam, though easier then the 2006 R2 exam. I don’t know about the 2004 exam – I never did that – you’ll have to ask someone like Jan or Thiago about that comparison.

Anyway, I encourage you to go take the exam, and if you do – best of luck to you!

Certified Trainer renewal – and why €400 is a magic cc limit
13 April 11 08:49 PM | Johan Hedberg

I renewed my Microsoft Certified Trainer “license” (if you so will) for another year today. I really do enjoy spending some time in the classroom now and then. I recognize that I might not always be the best pedagogue, though you should know I try, but I do hope that that mix of theoretic learning material with that crucial ingredient of real world experience gives “this is how this thing works” that extra nuance of “this is how this thing is actually used”. And that’s super important and often left outside of the course material since it’s hard to convey, but in many cases I believe I can bring that to the table.

To those that are unaware, the certified trainer is not really a certification that you pass, although you do need to have passed a certification as one of the requirements, it’s more of a affirmation of your ability and commitment to pass on your insight into your-technology-of-choice to others.

Or as the MCT site puts it:

Become part of an elite, international community that spans more than 150 countries and regions and includes classroom and e-learning instructors, learning consultants, authors, conference presenters, and user group leaders. Microsoft Certified Trainers (MCTs) are the premier technical and instructional experts on Microsoft technologies, and are the only individuals authorized to deliver training for Microsoft Certification.

Now, why is €400 (or really 4000 Swedish crowns) a magic limit to (my) credit card companies? Well, that’s roughly what the MCT renewal cost me, and it bounced. When I called the cc company to see why, and verify that it had, I got told that they had an outage of the system that day, and that only amounts below the 4k Swedish crown limit were automatically approved when the system was unavailable. That sounds like a security hole if any to me. I really do hope there are more safeguards in place around that. Or is there someone there in need of an MCT for some security best practices classes?

Filed under:
More Posts « Previous page - Next page »

This Blog

News

    Messenger

    Twitter Updates

      Follow me on twitter

      Visitors

      Feedburner Subscribers

      Locations of visitors to this page

      Disclaimer

      All material is provided AS IS voiding any thinkable or unthinkable effect it might have for any use whatsoever. There... is that clear enough ;)

      Pages

    Syndication