One of my favourite extensions is the spell checker for the editor, which is great for pointing out spelling mistakes, which for me can only be a good thing

To install the extension, it is as simple as downloading it, clicking on the downloaded file, restarting Visual Studio and using it.

The spell checker I use with Visual COBOL 2010 is:

http://visualstudiogallery.msdn.microsoft.com/en-us/7c8341f1-ebac-40c8-92c2-476db8d523ce

For those interested, here it is in action…

And the output of the program is:

Anyway, after some research, I found they British Gas just re-badged them from Drayton Digistat and here is the links to the pages that contain the .pdfs’.

http://www.gasapplianceguide.co.uk/DigistatPlus2.pdf
http://www.draytoncontrols.co.uk/WorkArea/DownloadAsset.aspx?id=4235

Microsoft Application Architecture Guide, 2nd Edition

The guide helps you to:

• Understand the underlying architecture and design principles and patterns for developing successful solutions on the Microsoft platform and the .NET Framework.
• Identify appropriate strategies and design patterns that will help you design your solution’s layers, components, and services.
• Identify and address the key engineering decision points for your solution.
• Identify and address the key quality attributes and crosscutting concerns for your solution.
• Create a candidate baseline architecture for your solution.
• Choose the right technologies for your solution.
• Identify patterns & practices solution assets and further guidance that will help you to implement your solution

The guide can be downloaded from: http://www.microsoft.com/downloads/details.aspx?FamilyID=ce40e4e1-9838-4c89-a197-a373b2a60df2&DisplayLang=en

Interoperability between languages is very important to COBOL environments just as much as other languages. Some platforms such as Microsoft’s .Net with their CLR makes life much easier by allowing all languages to share a common infrastructure ie: the instruction set and the VM (MSIL and CLR) along with a base class library to get you started.

Environments such as Sun’s VM (JVM) provide two different approaches to interoperability with Java, the first is via JNI/JNA and the second is producing bytecode that runs as is on the VM.

Although the Micro Focus COBOL compiler does not support JVM bytecode or Java source generation it does have support for invoking classes/methods via the OO invoke verb.

This mechanism is very simple to use, you just need to let our object COBOL runtime know the class is a Java class, which can be done by placing $JAVA$ before the name of the class and ensuring the class itself can be found by the JVM itself usually by adding an extra directories or .jar files to the CLASSPATH environment variable.

With Java 6.0 and JSR 223 support for Java based scripting languages were provided via the package javax.script.

Java has a wealth of scripting languages from awk to xlst. My favourites being jpython, jruby and javascript.

The java.net website has a comprehensive list of scripting languages -
https://scripting.dev.java.net/.

To use the scripting packages, you first need to create a ScriptEngineManager, then use this to create a specific ScriptEngine object for your chosen scripting language and use it.

For example:

In COBOL this is quite simply:

The actual Javascript being execute is contained in the invoke statement, which is simply:

To use the above example, we first need to compile the code and run it.. which is done as follows:

This is just the start, the next thing piece that is required with interoperability to another language is the ability to pass parameters to in and out of the script. Luckily for us the clever chaps on the jsr group have provided ‘put’ and ‘get’ methods that allows us to simply put a name parameter and get the resulting updated or new parameter.

So consider the example, where we need to setup a parameter called ‘message’ for the script and then read a parameter called ‘replyMessage’ after the script has been executed. The javascript to do this is:

To setup the message parameter, we just need todo.

The after the script has executed, we just need to use the ‘get’ method..

The completed COBOL example below, uses a side file for the javascript too, the code is as follows:

As you can see from the code above, setting up parameter is pretty easy todo but sometimes we just want to execute a function in the scripting language such as:

The ScriptEngine object that we have created to use the scripting engine may implement an optional interface called javax.script.Invocable, if the scripting engine we are using does provide this interface then a method called invokeFunction(..) can be used.

In order to reduce the size of the COBOL code, I have coded a simple utils class in java as a simple proxy layer, the code is pretty simple but does make it easier for the COBOL to use the invokeFunction() method.

Which gives us the following output when executed.

The completed example is as follows:

Conclusions: Using a Java based scripting language from COBOL is quite easy, so feel free to use it. Now which scripting language should I use…?

The default UK keyboard mapping on a MacBook are pretty much useless when using Virtual PC emulators such VirtualBox or VMWARE.

With this in mind, have produced a custom keyboard layout which maps all the keys to right place.

The only two exceptions are the two OPT keys, which I could only managed to map them to ALT-n keys, so the alternative mapping for these are:

€ aka left OPT 2 is mapped to right ALT 2

# aka left OPT 3 is mapped to right ALT 3

To use the customer keyboard mapping, download the .zip, unzip it.. and click on mbkbd\setup.exe and it will install the custom keyboard called “United Kindom – MacBook – Custom“.

And this me using it… boy did this make more productive!

This a screen shot me trying it out…

(link fixed)

As I am both a Mac and Windows user my choices were various from using a pdf printer on Windows to using various .chm readers on the Mac.

I first tried to use a .pdf printer on Windows but this not work due me using a 64bit version of Windows 7 and all the free pdf printers failed to either install or just simply did not work… much to my own frustration, so I turned to the Mac as this has native pdf support but did not have native .chm support! Don’t you just love computers…

On my mac I tried out various, these being:

Again, I was meet with disappointment all of them either failed to display the embedded html in the .chm magazine (complaining about a nbsp entity) or just not displaying anything. So decided to raise a bug against the most the one I thought had the most chance of being fixed, which was the iChm application.

So to my joy and delight the developer fixed it in version 1.4.2 and I was then able to load up the .chm, select Unicode encoding (as without this the pages did not display correctly) and then use the iChm function to export the .chm as a .pdf, copy it to the iriver story and I could then get back to reading all the years issues I had failed to read!

So my tip for converting .chm to .pdf on the Mac is to use iChm as it works and the developer is very responsive to issues raised or was at least was for me!

As it is close to Christmas and I wanted to do something with 12 in the title, I’ve thrown together some useful if not un-ordered list of 12 things tips using Micro Focus COBOL.

Remember I am just a developer and just want to help fellow developers out so…

Merry Christmas!

and here is my list…

1. Use DLLs/Shared objects rather than .int code
2. DLLs/Shared objects can be preloaded using:
   01 my-ptr procedure-pointer.
   set my-ptr to entry "sodllname"

   Note; sodllname does not have the extension… let the runtime choose it for you!

3. Use a good development environment such as Visual Studio or on Unix use Eclipse offering if you have a workstation, otherwise I personally use vim/gvim if terminal access is the only choce.
4. Remember you have a great choice of platforms from Windows to Linux to a load Unix platforms, so choice is king. (did I say that…)
5. Try using managed code (.Net) if you want to create WPF/WinForms or use WCF
6. Interopability is great, so if you see a Java Class, .Net Class, COM object, ‘C’ function or a Web Service… use it! You can even mix unmanaged and managed applications..
7. Avoid using the following if performance is key, as this really does help our code generator:
   alter
   perform thru
   next sentence
   segments
   go to section-name
   go to paragraph outside the current section
8. Try to end your routine with a “stop run [returning..]” or “exit program [returning..]” or “goback [returning..]” as this gives our code generators a defined end to the routine, which really does help our code analysis/generator
9. Use comp-5, integers for speed in calculations or native .Net types in managed
10. Use comp-x for portability (file formats etc..)
11. Make your application more robust, use tracing in production systems, either our own CTF tracing or your own or third party… it will save your life one day! Use runtime routines to catch error and log them (CBL_ERROR_PROC), ensure your programs shutdown cleanly always use CBL_EXIT_PROC.
12. Use the generator directive nocheck if you are happy your code is solid and want to a little more performance. ie: it turns off runtime bounds checking

Further reading:

Yes.. its a bit of a mixed list.. but hey it may be of help!

Rather than doing a cut-paste job, here is a quote from alex, along with a link to the “real” article itself.

Enjoy.

Alex Turner said:

A Comparison Of .Net COBOL, Visual Basic and C#

Introduction

If you are a COBOL programmer wanting to learn C# or a VB programmer wanting to learn COBOL as a .net language (or any other combination of VB.net, C# and COBOL) then this is a good place to start.

Background

If you are a COBOL programmer wanting to learn C# or a VB programmer wanting to learn COBOL as a .net language (or any other combination of VB.net, C# and COBOL) then this is a good place to start.

It has often been noted that the richness of the COBOL language in its Micro Focus .net implementation is not well known. Robert Sales and I have worked on this document to help bring the language to peoples’ attention and to help people who need to work with COBOL on the .net platform.

Click here to continue reading the rest of the article…

COBOL is a old language that naturally prohibits you from using modern design patterns.

rubbish I say… COBOL can be used in good ways and bad ways.

I will try and show you that COBOL can be used in a good way… lets take the “Singleton pattern“, as the first example.

First.. lets start off my creating a singleton class in csharp… so here it is:

Not too shabby.. but lets see what we can do in COBOL…

What… COBOL is smaller… that can’t be true… sorry but it is…

To complete the example… lets use it…

And I am sure some people… will say sure… this is really true… it is… here is it running..

Now it seems to me that COBOL is being under rated… perhaps someone should shout about it!

Last friday night we spent the night in London and we found a really good little Spanish Tapas restaurant and I thought I would share it… just because we enjoyed it soo much..

The place is called : El Parador – 245 Eversholt Street, London NW1 1BA.

…

The next day we headed for Brugge via the Eurostar and true to form Maria (my partner) found the the best Chocolate shop in the country, which we believe is ‘The Chocolate Line‘.

foodies enjoy!

The taste of the pudding mix.. is in the eating.. so lets see it working…

When CLR v2.0 was introduced a few new methods in System.IO.File for block reading/writing files were introduced, these works on arrays aka “OCCURS ANY” fields. Using these APIs instead of using traditional line sequentials is a breath of fresh air, especially if you just want to do some code something quickly without the need of records/group items.

So lets.. have a little play around, lets read a “MonthNames” from the CLR, write them to disk, read them back, reverse and sort it, while display them…

Which when executed gives us:

That was pretty easy… and the code looks okay too… can’t be bad…

References : System.Globalization.DatetimeFormat

So.. lets the show on the road…

Setting up arrays/occurs items in COBOL and manipulating them can be painful. Lets look at some traditional code for playing around with a “months” table.

Now, imagine we can use one or two of the .Net’s base class libraries combined with some nifty natural extensions to COBOL to do some of the heavy lifting.

Defining the month item as a native .Net type ie: a string combined with using the base class libraries Split methods allows us to setup a array quickly.

The .Net version, besides being smaller feels much easier to read, especially if you have any exposure to the .Net base class library from other languages such as C# or VB.Net.

Of course in a real world example, we don’t need to use the split method to setup an array, we could just use the “values” clause… for example:

If however you don’t want to hardcode the months, you can always use: CultureInfo.CurrentCulture.DateTimeFormat.GetMonthName() in the System.Globalization namespace.

So… lets just do it…

Now, I hope you feel like I do that COBOL and .Net are indeed perfect partners to each other.

The above COBOL .Net code will execute on Micro Focus Net Express and I suspect it will also work on Fujitsu’s netCobol too.

The main reason for using Java in a unsafe manor is performance, some unsafe operations are optimised by the JVM itself.

The boot class loader grants enough permissions to access a key undocumented class sun.misc.Unsafe. As I will state, this is an undocumented class and as the name implies it’s unsafe.

This class provides methods that allows you to manipulate objects and the memory of the objects directly.

For example, you could use it to access the object itself, lets look at an example to manipulate a String object.. not nice I hear you say…. and boy are you are so right. The purpose of this example is to demonstrate the power of the JVM if used to the extreme but not to demonstrate how to destroy the JVM.

Then, the output of the example on my little macbook is:

As you can see the String object is changed but the hashCode remains the same.

Even if the above example seems weird to the extreme and it is, I offer you one take home from this blog…

Be very careful what you place on your “bootclasspath!”
]]> http://www.gennard.net/blog/2009/11/unsafe-java-for-the-wierd/feed/ 0 http://www.gennard.net/blog/2009/11/nunit-and-cobol-net/ http://www.gennard.net/blog/2009/11/nunit-and-cobol-net/#comments Fri, 06 Nov 2009 19:44:44 +0000 spgennard http://www.gennard.net/blog/?p=126 A while back, I spent a afternoon converting some C# NUnit documentation into COBOL .Net, so I thought I would share the document with the world, with the hope that it will help any one interested in using NUnit and COBOL.

Enjoy!

Let’s start with a simple example. Suppose we are writing a bank application and we have a basic domain class – Account. Account supports operations to deposit, withdraw, and transfer funds. The Account class may look like this:

Now let’s write a test for this class – AccountTest. The first method we will test is TransferFunds.

The first thing to notice about this class is that it has a TestFixture attribute associated with it – this is the way to indicate that the class contains test code (this attribute can be inherited). The class has to be public and there are no restrictions on its superclass. The class also has to have a default constructor.

The only method in the class – TransferFunds, has a Test attribute associated with it – this is an indication that it is a test method. Test methods have to return void and take no parameters. In our test method we do the usual initialization of the required test objects, execute the tested business method and check the state of the business objects. The Assert class defines a collection of methods used to check the post-conditions and in our example we use the AreEqual method to make sure that after the transfer both accounts have the correct balances (there are several overloadings of this method, the version that was used in this example has the following parameters : the first parameter is an expected value and the second parameter is the actual value).

Compile and run this example. Assume that you have compiled your test code into a Example1.dll. Start the NUnit Gui (the installer will have created a shortcut on your desktop and in the “Program Files” folder), after the GUI starts, select the File->Open menu item, navigate to the location of your bank.dll and select it in the “Open” dialog box. When the bank.dll is loaded you will see a test tree structure in the left panel and a collection of status panels on the right. Click the Run button, the status bar and the TransferFunds node in the test tree turn red – our test has failed. The “Errors and Failures” panel displayed the following message – “TransferFunds : expected <250> but was <150>” and the stack trace panel right below it reported where in the test code the failure has occurred “at AccountTest.TransferFunds() in xxxx\Example1\Example1\AccountTest.cbl:line 42”

That is expected behavior; the test has failed because we have not implemented the TransferFunds method yet. Now let’s get it to work. Don’t close the GUI and go back to your IDE and fix the code, make your TransferFunds method look like this:

Now recompile your code and click the run button in GUI again – the status bar and the test tree turn green. (Note how the GUI has reloaded the assembly automatically for you; we will keep the GUI open all the time and continue working with our code in IDE and write more tests).

Let’s add some error checking to our Account code. We are adding the minimum balance requirement for the account to make sure that banks continue to make their money by charging your minimal overdraft protection fee. Let’s add the minimum balance property to our Account class:

We will use an exception to indicate an overdraft:

Add two new classes reference to the repository:

Add a new test method to our AccountTest class:

This test method in addition to Test attribute has an ExpectedException attribute associated with it – this is the way to indicate that the test code is expecting an exception of a certain type; if such an exception is not thrown during the execution – the test will fail.

Compile your code and go back to the GUI. As you compiled your test code, the GUI has grayed out and collapsed the test tree as if the tests were not run yet (GUI watches for the changes made to the test assemblies and updates itself when the structure of the test tree has changed – e.g. new test is added). Click the “Run” button – we have a red status bar again. We got the following Failure : “TransferWithInsufficentFunds : InsufficientFundsException was expected”. Let’s fix our Account code again, modify the TransferFunds method this way:

Compile and run the tests – green bar. Success! But wait, looking at the code we’ve just written we can see that the bank may be loosing money on every unsuccessful funds Transfer operation. Let’s write a test to confirm our suspicions. Add this test method:

We are testing the transactional property of our business method – all operations are successful or none. Compile and run – red bar. OK, we’ve made $300.00 out of a thin air (1999.com déjà vu?) – the source account has the correct balance of 150.00 but the destination account shows : $450.00. How do we fix this? Can we just move the minimum balance check call in front of the updates:

What if the Withdraw() method throws another exception? Should we execute a compensating transaction in the catch block or rely on our transaction manager to restore the state of the objects? We need to answer those questions at some point, but not now; but what do we do with the failing test in the meantime – remove it? A better way is to temporarily ignore it, add the following attribute to your test method

Compile and run – yellow bar. Click on “Tests Not Run” tab and you will see AccountTest.TransferWithInsufficientFundsAtomicity() in the list along with the Reason this test is ignored.

Looking at our test code we can see that some refactoring is in order. All test methods share a common set of test objects. Let’s extract this initialization code into a setup method and reuse it in all of our tests. The refactored version of our test class looks like this:

Note that Init method has the common initialization code, it has void return type, no parameters, and it is marked with SetUp attribute. Compile and run – same yellow bar!

I have no idea why our default exception handler for Java exceptions just displays a such a simple message with little or no information.

For those who have not seen it, display something similar to:

Luckily for me and you, we do expose a mechanism for replacing the default exception handler.

Anyway, with very little effort I created a different “default” system exception handler that display this instead:

The key difference being that a Java stack trace is included, boy did this help me.

The program below is the code that implements the exception handler. I am sure someone else can take this example and make it much nicer and provide more features but for this blog I will keep it simple.

To use the above code, you just have to first cut-paste to code into a file called ExceptionCatcher.cbl and include this in your project, and then add the directive INITCALL”ExceptionCatcher”, then away you go.

My test programs for the above example are:

and the Java class itself:

References: Studio Enterprise 6.0 Document for COBOL/Java Interop

Anyway, the mobile just cost €20 from Vodafone at El Corte Ingles and the phone can be topped up at ATM’s and shops.. This should hopefully cut down on our roaming charges..

Remember, you need to show a passport or the number will not be registered and you could lose it.

After a couple of frustrating conversations with their support the issue was identified.

The map update process had managed to zero out two important files, these being traffic.dat and tmccodes.dat. The support person said they would email the two files but I needed a quicker solution rather than waiting for the email (which so far has taken 1hr… as opposed to the 15mins that was promised).

Any the solution to is to extract these files from your downloaded maps, which will be in the TomTom Downloads area… on my mac these are found in the file “Western_Europe.zip”.

So I just extracted the files with:

mkdir tmp
cd tmp
unzip -x ../Western_Europe.zip traffic.dat tmccodes.dat

and then replaced the files in the maps/Western_Europe directory on the TomTom itself, safely unmounted the TomTom drive, reboot it… and it worked…