Posts tagged: COBOL

Design Patterns and COBOL

comments Comments Off
By spgennard, November 29, 2009 11:40 pm

As part of my working life I happy to say I use COBOL and for better or worse it is here to stay. With this in mind it annoys me I here/see saying things such as

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:

using System.Collections;

public sealed class MySingleton {
    private static readonly Hashtable sharedHashtable = new Hashtable();

    // Explicit static constructor to tell C# compiler
    // not to mark type as beforefieldinit
    static MySingleton() {
    }

    private MySingleton() {
    }

    public static Hashtable Singleton {
        get {
            return sharedHashtable;
        }
    }
}

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

      $set ilusing"System.Collections"
       class-id.  "MySingleton".

       01 shared-hashtable  type "Hashtable"
            static property as "Singleton" with no set.

       method-id. "New" static.
          set shared-hashtable to new type "Hashtable"
       end method "New".

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

To complete the example… lets use it…

      *> Add two items to the single hashtable
         invoke type "MySingleton"::"Singleton"::
                "Add"("01234567","Ian")

         invoke type "MySingleton"::"Singleton"::
                "Add"("987654321","Stephen")

      *> Now get one of the items of the singleton
         display "Account 01234567 - Contains: "
             type "MySingleton"::"Singleton"::"Item"("01234567")

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

c:\temp> cobol MySingleton.cbl ilgen(sub);
c:\temp> cobol UseSingleton.cbl ilgen ilref"MySingleton.dll";
c:\temp> UseSingleton.exe
Account 01234567 - Contains: Ian
c:\temp> csc MySingleton.cs /target:library
c:\temp> UseSingleton.exe
Account 01234567 - Contains: Ian

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

categories CLR, COBOL, Tips | tags , ,

Type Safety and COBOL

comments Comments Off
By spgennard, November 24, 2009 12:27 am

Having read a recent bog about COBOL and type-safety, I though I would jot down some comments.

ANS85 COBOL is naturally is type-unsafe due as every data item being part of one memory region (or storage area), because of this it can make is difficult to talk to type-safe language such as Java or the CLR.

However, just like any computer language it does not stay still. Object oriented features were added to COBOL, at this point in time you we were given the verbs to create 100% type safe application.

The key to writing type safe code is the use OBJECT-REFERENCE will a TYPE and using them on in your methods and using the INVOKE verb.

For example:

      IDENTIFICATION DIVISION.
       PROGRAM-ID.   "TypeSafeExample".
       ENVIRONMENT DIVISION.
       CONFIGURATION SECTION.
       REPOSITORY.
              CLASS SYS-STRING AS "System.String".
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 hello-world-string    OBJECT REFERENCE SYS-STRING.
       
       PROCEDURE DIVISION.    
          SET hello-world-string TO "Hello World"
          DISPLAY hello-world-string
          STOP RUN.

The use of COBOL pictures can still be used, however for easy interop with other type-safe languages you really have to stick to the right types for your target environment when exposing your COBOL program to the other languages, this means if you are creating classes, the method to be consumed by other languages should use standard types, for .Net/CLR applications the use of CLS-COMPLIANT types is the right approach. For JVM applications, keep to the “core” java.lang types.

Keep to these simple rules and COBOL will happy interop with type-safe languages. :-)

categories CLR, COBOL, JVM, TypeSafety | tags ,

Base Class Library, Arrays, Queues and Stacks

comments Comments Off
By spgennard, November 19, 2009 10:41 pm

Continuing the series of blogs about COBOL and the .Net base class library…

The .Net base class library has a wealth classes and an huge of amount of methods/properties.

The .Net base class library has a key handy namespace that contains are the lovely classes, which is System.Collections.

As you can see from the above link, it does have quite a lot, so for this blob entry I will look at:

  • arrays of numbers
  • queues
  • stacks

    • Lets start the first example by using an array of numbers… just to demonstrate its not just strings you can assign to the arrays using “values”.

           01 numbers  binary-long occurs 10
              values 10 20 30 40 50 10 20 30 40 50.

           01 num       binary-long value 0.
           01 average   binary-double value 0.

           procedure division.
              perform varying num through numbers
                add num to average
              end-perform
              divide average by numbers::"Length" giving average
              display "Average is : " average

    Running the above code gives us:

    Average is : +00000000000000000030

    The next class that is helpful, is the Queue class, this allows us to “Enqueue” and “Dequeue” item using the same methods, the queue is again displayed using the “perform through” syntax.

          $set ilusing"System"
          $set ilusing"System.Collections"

           01 alphabetQueue     type "Queue".
           01 item              object reference.

           set alphabetQueue to new type "Queue"()
           invoke alphabetQueue::"Enqueue"("A item")
           invoke alphabetQueue::"Enqueue"("B item")
           invoke alphabetQueue::"Enqueue"("C item")

           display "The initial queue is: "
           perform varying item through alphabetQueue
             display " " item
           end-perform

           display "".
           display "De-Queue an item: " alphabetQueue::"Dequeue"()

           display "".
           display "Afterwards is: "
           perform varying item through alphabetQueue
             display " " item
           end-perform

    Running the above queue example gives:

    The initial queue is:
     A item
     B item
     C item

    De-Queue an item: A item

    Afterwards is:
     B item
     C item

    Next, lets look at the ‘Stack’ class, this is very similar, expect it uses the “Push”, “Pop” methods and we iterate through the Stack using the ‘perform through’ syntax.

          $set ilusing"System"
          $set ilusing"System.Collections"

           01 alphabetStack     type "Stack".
           01 item              object reference.

           set alphabetStack to new type "Stack"()
           invoke alphabetStack::"Push"("A item")
           invoke alphabetStack::"Push"("B item")
           invoke alphabetStack::"Push"("C item")

           display "The initial stack is: "
           perform varying item through alphabetStack
             display " " item
           end-perform

           display "".
           display "Pop item: " alphabetStack::"Pop"()

           display "".
           display "Afterwards is: "
           perform varying item through alphabetStack
             display " " item
           end-perform

    Running the above stack example gives:

    The initial stack is:
     C item
     B item
     A item

    De-Stack an item: C item

    Afterwards is:
     B item
     A item

    As you can see using the base class library collection classes with COBOL is just as easy as using C#… so if you are already using COBOL… continue and try out the .Net base class library.. it really is very easy to use and it will make you more productive.. so please explore and enjoy .Net and its Base Class library.

    categories CLR, COBOL | tags , ,

    TechEd 2009 – Keynote with Jazon and Mark

    comments Comments Off
    By spgennard, November 12, 2009 9:29 am

    My boss (Mark Conway) the other day was lucky enough to demonstrate some of the wonders of next release at TechEd 2009 in the keynote with Jazon Zander’s entitled: “Visual Studio 2010: New Challenges, New Solutions”

    The demo shows off some of the nice features of Visual Studio 2010 and how we looking to use it for COBOL. I think it looks great! :-)

    Tip: Skip to about 34 mins into it for Mark

    Click here for TechEd Online – for the actual video

    And finally here is Jazon Zander’s Blog.

    categories COBOL, IDE, TechEd | tags , , , ,

    Too Iterate or not…

    comments Comments Off
    By spgennard, November 10, 2009 9:51 pm

    Over the next couple of weeks, I will explore some of the reasons why I think managed environments are good for COBOL.

    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.

           01 month-val.
               05  FILLER                    PIC X(10)  value "January".
               05  FILLER                    PIC X(10)  value "February".
               05  FILLER                    PIC X(10)  value "March".
               05  FILLER                    PIC X(10)  value "April".
               05  FILLER                    PIC X(10)  value "May".
               05  FILLER                    PIC X(10)  value "June".
               05  FILLER                    PIC X(10)  value "July".
               05  FILLER                    PIC X(10)  value "August".
               05  FILLER                    PIC X(10)  value "September".
               05  FILLER                    PIC X(10)  value "October".
               05  FILLER                    PIC X(10)  value "November".
               05  FILLER                    PIC X(10)  value "December".

           01 month-tab redefines month-val.
               05  months occurs 12 times.
                   10  month-NAME            PIC X(10).

           01 month                          PIC 99.

           01 secondQuarterMonths            pic x(70).
     
           display "The months are:"
           perform varying month from 1 by 1 until month equals 12
             display " " months(month)    
           end-perform

           display " "
           display "The second quarter months are: "

           string months(4) delimited by space
                  "/" delimited by size
                  months(5) delimited by space
                  "/" delimited by size
                  months(6) delimited by space
              into secondQuarterMonths
              on overflow
                 display "FATAL Error - secondQuarterMonths is too small"
                 stop run
           end-string

           display " " secondQuarterMonths

    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.

            01 commaDelimited       string value
             "January,February,March,April,May,June,July,August," &
             "September,October,November,December".

            01 months              string occurs any.
            01 month               string.

            01 secondQuarterMonths  string.

            set months to commaDelimited::"Split"(',')

            display "The months are: "
            perform varying month through months
              display " " month
            end-perform

            display " "
            display "The second quarter months are: "

            set secondQuarterMonths to type "System.String"::"Join"('/', months, 3, 3)

            display " " secondQuarterMonths

    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:

          01 months  string occurs 12 values
             "January" "February" "March" "April" "May" "June"
             "July" "August" "September" "October" "November" "December".

           01 month string.

               perform varying month through months
                   display month
               end-perform

    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…

           01 Months string occurs any.
           01 Month string.

           set Months to type "System.Globalization.DateTimeFormatInfo"::
              "CurrentInfo"::"MonthNames"
               
           perform varying Month through Months
              display Month
           end-perform

    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.

    categories CLR, COBOL, Tips | tags , , ,

    Panorama Theme by Themocracy