On April 23rd I had a job phone interview. The talk was about a Software Development Engineer in Test (SDET) position at Microsoft.

I already blogged about a C# Thread Safe Circular Queue, which was one of the questions of a screen test (prior to a phone interview) I completed on January for the same Microsoft job position.

On this last interview we (me and the Microsoft employee-interviewer) would talk a little bit and then get to the coding questions. It didn't happen as expected. Firstly the Microsoft interviewer tried to call me on my cellphone. I just couldn't hear a word of what he was saying. The sound was very low. Then we decided to start with the coding questions and then on the phone land line we would talk so that he could explain more about the position, etc.

We started a meeting on Microsoft Office Live Meeting. I was asked about a simple and easy question.

The question:

Write a program that changes the position of the words of a given sentence. For example, given the sentence "How are you going" as input, the output should be "are How going you".

Simple, isn't it? I thought that too at the moment.

As you can see, the first and second words change of position and then the third and forth words change of position and so forth.

The interviewer explained that I could write any code. It didn't need to be written with the syntax of a programming language, it could be a pseudocode.

I'm so used to code using code auto-completion (IntelliSense) and the debugger that I just didn't write any good code to solve the question. It was really frustrating. All what I needed to do was clear in my mind but I just couldn't express it. Was that the case of me being nervous? Beats me.

Today I decided about writing a post with a possible solution to this simple programming question. I opened Microsoft Visual Studio C# Express and wrote some code. In just 5 minutes I had a working code that did the job.

There are things in life that are really weird. I passed more than 45 minutes trying to write a pseudocode and then with the help of IntelliSense and debugger catching my mistakes, things flowed flawlessly and rapidly. Why that faster? I don't know how to explain it, maybe because of IntelliSense and the presence of a handy debugger!

For sure the solution I present here isn't the better, but it's a solution and that's what was asked.

Bellow is the code I wrote:

namespace WordPermuter
{
  class Program
  {
    static void Main(string[] args)
    {
      List<string> sentences = new List<string>()
      {
        { "How are you going my dear?" }, // are How going you dear? my

        { "I am going fine honey." } // am I fine going honey
      };

      DoPermutation(sentences);
    }

    static void DoPermutation(List<string> sentences)
    {
      foreach(string sentence in sentences)
      {
        // Split the sentence when it reaches a white space
        var splitted = sentence.Split(' ');

        // Increment the counter on a scale of 2
        for(int i = 0; i < splitted.Length; i = i + 2)
        {
          if(i < splitted.Length - 1)
          {
            var aux = splitted[i];

            splitted[i] = splitted[i + 1];

            splitted[i + 1] = aux;
          }
        }

        foreach(var str in splitted)
          Console.Write(str + " ");

        Console.WriteLine();
      }
    }
  }
}

What's the purpose of this code? Aha... It isn't the code itself but what approach you took to get to a solution. The interviewer wants to see how is your thinking process. No matter if you coded it wrong, but at least you should show something. As the recruiters always say: "Think it loud so that we can help you."

After a solution has been presented, the interviewer will probably ask you what if questions. What if I did this way? What If I did that way? What is the breach? What are the possible bugs?... The list of possible questions is innumerable.

I think my solution is OK! If you find any bug, please tell me.

Windows API
The Windows API, informally WinAPI, is Microsoft's core set of application programming interfaces (APIs) available in the Microsoft Windows operating systems. All Windows programs except console programs must interact with the Windows API regardless of the language.

Win32 API
The Win32 API is the 32-bit API for modern versions of Windows. The API consists of functions implemented, as with Win16, in system DLLs. The core DLLs of Win32 are kernel32.dll, user32.dll, and gdi32.dll. Win32 was introduced with Windows NT.

Words of wisdom
Dealing with the Win32 API appears to be a regression since it takes us to the last century, that is, when programming with such API we are writing code that resembles the code written 15 years ago or more. Regression was the feeling I felt when the teacher said we'd study this API. Nevertheless, there are billions of lines of code that need maintenance because great part of these lines are used in legacy systems. So you see that learning this API is fundamental even today. This is in contrast with the mainframe computers dilemma. Even today there are a bunch of companies that still use them because of legacy systems. The feeling of regression was substituted by a enthusiasm one in the end.

Mouse interaction app
One coursework related to the Object Oriented Systems discipline I had to develop was a program that draws on the screen by free hand with the mouse assistance. The program must monitor the mouse movement, indicating its position (x, y) in the upright corner of the application window, in the format (xxx, yyy). Pressing the left mouse button it draws and pressing the right mouse button, it wipes off the screen content.

Some valuable tips that the teacher gave:
Use the events WM_MOUSE, WM_LBUTTONDOWN, WM_LBUTTONUP, WM_RBUTTONDOWN, WM_RBUTTONUP and the function SetPixel()

lword(lParam) has 0 x
hiword(lParam) has 0 Y

I originally implemented this program using DevC++. Today while composing this post I just created a new Win32 Project application using the Microsoft Visual Studio C++ Express Edition. Although the implementation differs a little bit, it wasn't difficult to port it to the Microsoft programming environment. I'll provide both implementations at the end of the post.

Let's see the mouse app main block of code. It's inside the WndProc function that is responsible for processing the messages for the main window. The code is commented so I think it's unnecessary to add more to it.

//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND     - Process the application menu
//  WM_PAINT       - Paint the main window
//  WM_DESTROY     - Post a quit message and return
//  WM_LBUTTONDOWN - Left mouse button clicked
//  WM_RBUTTONDOWN - Right mouse button clicked
//  WM_LBUTTONUP   - Left mouse button released
//  WM_RBUTTONUP   - Right mouse button released
//  WM_MOUSEMOVE   - Controls the mouse movement
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
  int wmId, wmEvent;

  switch(message) //Handle the messages
  {
    case WM_DESTROY:

      PostQuitMessage(0); // Send a WM_QUIT to the message queue

      break;

    case WM_PAINT:
      // TODO: Add any drawing code here...  
      hDC = GetDC(hWnd);

      BeginPaint(hWnd, &paintStruct);

      EndPaint(hWnd, &paintStruct);

      break;

    // Left button event used to print the screen
    case WM_LBUTTONDOWN:

      flag = true;

      // Black color   
      newColor = RGB(0, 0, 0);

      xMouse = LOWORD(lParam);

      yMouse = HIWORD(lParam);

      SetPixel(hDC, xMouse, yMouse, newColor);

      break;

    // Right button event used to erase the screen content
    case WM_RBUTTONDOWN:

      flag = true;

      // White color           
      newColor = RGB(255, 255, 255);

      xMouse = LOWORD(lParam);

      yMouse = HIWORD(lParam);

      SetPixel(hDC, xMouse, yMouse, newColor);

      break;

    // Sets the flag to false so that we know the left mouse button was released
    case WM_LBUTTONUP:

      flag = false;

      break;

    // Sets the flag to false so that we know the right mouse button was released
    case WM_RBUTTONUP:

      flag = false;

      break;

    // Controls the mouse movement and shows its current position on the Window title
    case WM_MOUSEMOVE:

      if(flag)
      {
        xMouse = LOWORD(lParam);

        yMouse = HIWORD(lParam);

        SetPixel(hDC, xMouse, yMouse, newColor);

        sprintf_s(strTitle, "  x=%d y=%d", xMouse, yMouse);

        SetWindowText(hWnd, strTitle);

        SetWindowText(hlabel, strTitle);
      }
      else
      {
        xMouse = LOWORD(lParam);

        yMouse = HIWORD(lParam);

        sprintf_s(strTitle, "  x=%d y=%d", xMouse, yMouse);

        SetWindowText(hWnd, strTitle);

        SetWindowText(hlabel, strTitle);
      }

      break;

    case WM_COMMAND:
      wmId    = LOWORD(wParam);
      wmEvent = HIWORD(wParam);
      // Parse the menu selections:
      switch(wmId)
      {
        case IDM_ABOUT:
            
          DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
          
          break;
      
        case IDM_EXIT:
            
          DestroyWindow(hWnd);
          
          break;
          
        default:

          return DefWindowProc(hWnd, message, wParam, lParam);
      }

    break;

    default:  // For messages that we don't deal with

      return DefWindowProc (hWnd, message, wParam, lParam);
  }

  return 0;
}

Reference
To get more insight regarding the Win32 API, go to the Win32 Development site at the Microsoft Development Network: http://msdn.microsoft.com/en-us/library/aa139672.aspx

Dev-C++ and Visual Studio Projects
DevC++ project
http://leniel.googlepages.com/Win32APIMouseInteractAppDevCPlusPlus.zip

Visual Studio Win32 project
http://leniel.googlepages.com/Win32APIMouseInteractAppVCPlusPlus.zip

Following the coursework related to the Compilers Construction discipline I attended during the Computer Engineering course, I was asked to indent and capitalize the reserved words (keywords) of a source code file. More specifically, to do this work I should use the Syntactic Analyzer built with Flex and YACC that was created in a previous coursework task.

The source code file in question is the one being analyzed by the syntactic analyzer. This way at the same time it analyses the syntactic structure of the file it also indents and capitalizes the keywords.

The following is the content of the syntactic analyzer file named sinan.yacc:

%{
   #include <stdio.h>
   #include <stdlib.h>

   int c;
%}

%token PROGRAM
%token ID
%token SEMIC
%token DOT
%token VAR
%token COLON
%token INTEGER
%token REAL
%token RCONS
%token BOOL
%token OCBRA
%token CCBRA
%token IF
%token THEN
%token ELSE
%token WHILE
%token DO
%token READ
%token OPAR
%token CPAR
%token WRITE
%token COMMA
%token STRING
%token ATRIB
%token RELOP
%token ADDOP
%token MULTOP
%token NEGOP
%token CONS
%token TRUE
%token FALSE

%%

prog : PROGRAM {printf("PROGRAM "); c = 0;}

       ID {printf("%s", yytext);}

       SEMIC {printf(";\n\n");}

       decls

       compcmd

       DOT {printf(".");}
       {
         printf("\n Syntactical Analisys done without erros!\n");

         return 0;
       }
     ;

decls : VAR {printf("VAR ");} decl_list

      ;

decl_list : decl_list decl_type
            decl_type
          ;

decl_type : id_list COLON {printf(":");} type SEMIC {printf(";\n");}
          ;

id_list : id_list COMMA {printf(", ");} ID {printf("%s", yytext);}
          ID {printf("%s", yytext);}
        ;

type : INTEGER {printf(" INTEGER");}
       REAL {printf(" REAL");}
       BOOL {printf(" BOOL");}
     ;

compcmd : OCBRA {int i; for(i = 0; i < c; i++)printf(" "); printf("{\n"); c = c + 2;} cmd_list CCBRA {printf("\n"); int i; for(i = 2; i < c; i++)printf(" "); printf("}"); c = c - 2;}
        ;

cmd_list : cmd_list SEMIC {printf(";\n\n");} cmd
           cmd
         ;

cmd : {int i; for(i = 0; i < c; i++)printf(" ");} If_cmd
      {int i; for(i = 0; i < c; i++)printf(" ");} While_cmd
      {int i; for(i = 0; i < c; i++)printf(" ");} Read_cmd
      {int i; for(i = 0; i < c; i++)printf(" ");} Write_cmd
      {int i; for(i = 0; i < c; i++)printf(" ");} Atrib_cmd
      compcmd
    ;

If_cmd : IF {printf("IF ");} exp THEN {printf(" THEN\n");} cmd Else_cmd
       ;

Else_cmd : ELSE {printf("\n"); int i; for(i = 0; i < c; i++)printf(" "); printf("ELSE\n"); c = c + 2;} cmd {c = c - 2;}

         ;

While_cmd : WHILE {printf("WHILE ");} exp DO {printf(" DO\n");} cmd
          ;

Read_cmd : READ {printf("READ");} OPAR {printf("(");} id_list CPAR {printf(")");}
         ;

Write_cmd : WRITE {printf("WRITE");} OPAR {printf("(");} w_list CPAR {printf(")");}
          ;

w_list : w_list COMMA {printf(", ");} w_elem
         w_elem
       ;
w_elem : exp
         STRING {printf("%s", yytext);}
       ;

Atrib_cmd : ID {printf("%s ", yytext);} ATRIB {printf("= ");} exp
          ;

exp : simple_exp
      simple_exp RELOP {printf(" %s ", yytext);} simple_exp
    ;

simple_exp : simple_exp ADDOP {printf(" %s ", yytext);} term
             term
           ;

term : term MULTOP {printf(" %s ", yytext);} fac
       fac
     ;

fac : fac NEGOP {printf(" %s", yytext);}
      CONS {printf(" %s", yytext);}
      RCONS {printf(" %s", yytext);}
      OPAR exp CPAR
      TRUE {printf("TRUE ");}
      FALSE {printf("FALSE ");}
      ID {printf("%s", yytext);}
    ;


%%

#include "lex.yy.c"

As you can see there is an integer variable named c right beneath the #include section. This variable is incremented and decremented according to the section of code being analyzed (parsed). Such variable is then used inside the for loops. According to its current value blank spaces are written on the screen so that the next token parsed is printed on the right position (indented).

Each keyword parsed is capitalized and printed on the screen through a simple printf command.

Let's run a simple test case with the following source code file named test.txt. The code is intentionally not indented and it doesn't do much. It's just for a testing purpose.

program factorial;

var n, fact, i: integer;
{
read(n);

fact = 1;

i = 1;

while i <= n do
{
fact = fact * i;

i = i + 1
};

if i >= fact then
{
i = fact;

fact = fact + 1
}
else
i = fact + 1;



if i < fact then
{
i = fact;

fact = fact + 1
};

write("The factorial of ", n, " is: ", fact)
}.

In blue are the keywords, so the output should present them in CAPITALIZED letters. The blocks of code should also be presented with indentation according to the logic specified above. I use 2 white spaces to indent the blocks of code. That's why I use c = c + 2 (to increment) and c = c - 2 (to decrement) the c variable is responsible for controlling the indentation.

To run the test case it's necessary to build the syntactic analyzer. I won't show here all the steps involved since it's already done in the paper described in the post Syntactic Analyzer built with Flex and YACC. So I'll just compile the sinan.yacc file since it's the only file that was modified to accomplish this task. The other necessary files to generate the executable file - such as the lexical analyzer ones - are included in the download package at the end of this post.

For a better understanding of the commands used in this post and to set up the development environment I recommend that you read at least section 3.3 of the paper Syntactic Analyzer built with Flex and YACC. That said, let's do the job. :-)

To run this test case, follow the steps listed bellow:

1. Create a folder called IndentCapCode on the root directory C:\, which will contain all the files created henceforward.
2. Open a command prompt and type: path=C:\MinGW\bin;%PATH%. I consider that the MinGW installation was done in the folder C:\MinGW. Change it accordingly. After completing this step the tools to build the syntactic analyzer will be available in the command prompt.
3. Generate the file y.tab.c in the command prompt with following command: yacc sinan.yacc.
4. Compile the files with GCC in the command prompt with the following command: gcc y.tab.c yyerror.c main.c -osinan -lfl.

The result file for the syntactic analyzer is sinan.exe. To use it just type sinan < test.txt. The file test.txt contains the source code to be analyzed by the syntactic analyzer.

You can see the commands listed above in action through the following screenshot:

In a next post related to compilers construction I'll show the implementation of a semantic analyzer. This implementation was another coursework task. I used the same principle shown here to indent the code and even to colorize the keywords. But this is for another day.

You can get the .ZIP package that contains the files used in this post: http://leniel.googlepages.com/CodeIndenterCapitalizerFlexYACC.zip

Note: if you want, you can use a batch file (.bat) to automate the steps listed above. A .bat file named ini.bat is included in the .ZIP package. For more information about batch files, read my previous post Programming-Constructing a Batch file.

While completing a screen for a Software Development Engineer in Test (SDTE) position for Microsoft I had to implement a thread safe circular queue.

The question was the following:

Implement a circular queue of integers of user-specified size using a simple array. Provide routines to initialize(), enqueue() and dequeue() the queue. Make it thread safe. A really good observation was: Please do not to use existing class libraries for this question. Thanks!

My first attempt was obviously get more information about a circular queue and bring it back to my mind. That's because I had studied it a long time ago when I was in the beginning of the computer engineering course. If you don't use it you forget it. That's the truth.

This post aims to present an implementation of a thread safe circular queue in C#. I won't deal with theory. For theory, I advise you to read the Wikipedia article about circular queue (buffer) to get started.

I reused some code from the links I present in the references section at the end of this post.

I'll break down the code I implemented so that you can go through the functions that were asked in the problem statement.

class ThreadSafeCircularQueue
{
  private int[] queue;
  private int head;
  private int tail;
  private int length;

  static Object thisLock = new Object();

  public CircularQueue()
  {
     Initialize();
  }

  ...
}

The class ThreadSafeCircularQueue has five properties: an integer array (the queue) and the queue's head, tail and length. A static object thisLock is used to make the queue thread safe.

private void Initialize()
{
  head = tail = -1;

  Console.Write("Circular Queue size: ");

  string length = Console.ReadLine();

  this.length = int.Parse(length);

  queue = new int[this.length];
}

The function Initialize() does what its name means. The queue's head and tail are set to appropriate values and the user has the opportunity of specifying the queue's size (length) by entering an integer value. A new queue is then created and has the user specified size.

The Enqueue() and Dequeue() functions shown bellow do the hard work, that is, they control all the circular queue functionality.

The Enqueue() function receives an integer value to be enqueued. Note the use of the thisLock variable. It is used so that we get thread safety, that is, all the code section inside the lock statement can't be executed by two threads at the same time. This avoids the problem of two concurrent threads trying to access the queue data structure simultaneously. If it's not controlled in the source code level we can get invalid values in the queue what could lend to a corrupted queue. That's not what is expected. When the code section that is inside the lock statement is being executed by a thread and other thread reaches the same section of code, this second thread waits till the first thread exits such code section. This way the queue has a valid set of values and its data is maintained secure.

Firstly is checked if the queue is full. It is full when it's head points to index 0 and its tail points to length - 1 or when its tail + 1 equals the same value of head. Remember that it is a circular queue.

In case the queue is full a message is shown to the user. If it still has room we check if the "end" of the queue (tail) that points to the last element has an index of length minus 1. If it is then the tail will now point to the the "start" of the queue. The other possibility is to increment the tail variable. The position referenced by the tail variable is then used to enqueue the value parameter into the queue. Then the just enqueued value is printed in the screen. A check is done to verify if the head variable has a value of -1. If it's the case then head will point to index 0.

private void Enqueue(int value)
{
  lock(thisLock)
  {
    if((head == 0 && tail == length - 1)  (tail + 1 == head))
    {
      Console.WriteLine("Circular queue is full.");

      return;
    }
    else
    {
      if(tail == length - 1)
        tail = 0;
      else
        tail++;

      queue[tail] = value;

      Console.WriteLine("In -> {0}", value);
    }

    if(head == -1)
      head = 0;
  }
}

The Dequeue() function also uses the lock statement because it must be a thread safe function.

Firstly is checked if the queue's head points to -1. Remember that in the Initialize() function when the queue is initialized its head and tail variables are set to -1. If head has a value of -1 then the queue is empty and the user is informed about that. A value of -1 is returned to conform with the function signature that needs to return an integer value.

If the queue is not empty the integer variable v receives the value that is indexed in the queue's head position. The value 0 is then assigned to the position that was just dequeued.

Now it's necessary to update the head position inside the queue. To accomplish that it's checked if head is equal tail, if it is, then head = tail = -1. This last operation states that the queue is empty after the dequeue operation. Else it's checked if head is equal length - 1. If it is the case then head receives 0. The last possible condition increments the value of head. In the end the value being dequeued (v) is printed in the screen.

Printing the values in the screen is a good way of keeping track of what is going on while the program is running.

private void Dequeue()
{
  lock(thisLock)
  {
    int value;

    if(head == -1)
    {
      Console.WriteLine("Circular queue is empty.");

      value = -1;
    }
    else
    {
      value = queue[head];
      queue[head] = 0;

      if(head == tail)
        head = tail = -1;
      else
        if(head == length - 1)
          head = 0;
        else
          head++;
    }

    Console.WriteLine("Out -> {0}", value);
  }
}

Now take a look at the Show() function bellow. Again the lock is present. Why? In an instant you'll get to the point. Hold your horses! :-)

A check is done to verify if the queue is empty. If it is the case the callee function just returns to the caller function. If it is not the case we proceed to show the values already present in the queue. If tail is less than head a for loop starting in 0 and ending in length - 1 iterates the queue and each value is written in the screen. Otherwise a for loop starting in 0 end ending in tail iterates the queue and each value is written in the screen.

private void Show()
{
  lock(thisLock)
  {
    int i;

    if(head == -1)
    {
      Console.WriteLine("Circular queue is empty.");

      return;
    }
    else
    {
      if(tail < head)
      {
        //for(i = head; i <= size - 1; i++)
        for(i = 0; i <= length - 1; i++)
          Console.Write("{0} ", queue[i]);
      }
      else
        //for(i = head; i <= tail; i++)
        for(i = 0; i <= tail; i++)
          Console.Write("{0} ", queue[i]);

      Console.WriteLine();
    }
  }
}

The following is the EnqueueDequeue() function responsible for calling the Queue(), Dequeue() and Show() functions. In this function I execute a simple test case and comment the operations being carried out.

public void EnqueueDequeue()
{
  Enqueue(1);
  Enqueue(2);
  Enqueue(3);
  Enqueue(4);
  Show();
  Enqueue(5); // Circular queue is full!
  Dequeue();
  Dequeue();
  Dequeue();
  Dequeue();
  Dequeue(); // Circular queue is empty!
  Dequeue(); // Circular queue is empty!
  Show();
  Enqueue(6);
  Show();
  Enqueue(7);
  Show();
  Dequeue();
  Dequeue();
  Enqueue(8);
  Enqueue(9);
  Show();

  // Supposing a 4 size queue:  0 ¦ 0 ¦ 0 ¦ 0
  //
  //                            1 ¦ 0 ¦ 0 ¦ 0  <- Enqueue 1
  //
  //                            1 ¦ 2 ¦ 0 ¦ 0  <- Enqueue 2
  //
  //                            1 ¦ 2 ¦ 3 ¦ 0  <- Enqueue 3
  //
  //                            1 ¦ 2 ¦ 3 ¦ 4  <- Enqueue 4
  //              
  //                            1 ¦ 2 ¦ 3 ¦ 4  <- Circular queue is full when trying to enqueue 5.
  //
  //                            0 ¦ 2 ¦ 3 ¦ 4  <- Dequeue 1
  //
  //                            0 ¦ 0 ¦ 3 ¦ 4  <- Dequeue 2
  //
  //                            0 ¦ 0 ¦ 0 ¦ 4  <- Dequeue 3
  //                   
  //                            0 ¦ 0 ¦ 0 ¦ 0  <- Dequeue 4
  //
  //                            0 ¦ 0 ¦ 0 ¦ 0  <- Circular queue is empty when trying to dequeue.
  //
  //                            0 ¦ 0 ¦ 0 ¦ 0  <- Circular queue is empty when trying to dequeue.
  //
  //                            6 ¦ 0 ¦ 0 ¦ 0  <- Enqueue 6
  //
  //                            6 ¦ 7 ¦ 0 ¦ 0  <- Enqueue 7
  //
  //                            0 ¦ 7 ¦ 0 ¦ 0  <- Dequeue 6
  //
  //                            0 ¦ 0 ¦ 0 ¦ 0  <- Dequeue 7
  //
  //                            8 ¦ 0 ¦ 0 ¦ 0  <- Enqueue 8
  //
  //                            8 ¦ 9 ¦ 0 ¦ 0  <- Enqueue 9
  //
  // * 0 is set in a position when dequeueing so that it's easier to watch the queue variable.
}

Now the main start thread:

class Program
{
  static void Main(string[] args)
  {
    ThreadSafeCircularQueue circularQueue = new ThreadSafeCircularQueue();

    Thread[] threads = new Thread[10];

    for(int i = 0; i < threads.Length; i++)
    {
      threads[i] = new Thread(new ThreadStart(circularQueue.EnqueueDequeue));
    }

    for(int i = 0; i < threads.Length; i++)
    {
      threads[i].Start();
    }

    Console.ReadLine();
  }
}

As you can see above I declare an object of type ThreadSafeCircularQueue. An array of 10 objects of type Thread is then created. In a for loop I instantiate each Thread passing to it a delegate that represents the method that'll be invoked when the thread begins executing.

In the subsequent for loop I call the Start() method of each thread and they start executing simultaneously, tough they won't concur when accessing the functions Enqueue(), Dequeue() and Show().

Visual Studio C# Console Application
You can get the Microsoft Visual Studio Project and the app executable at: http://leniel.googlepages.com/ThreadSafeCircularQueueCSharp.zip

References
During the research phase of this implementation I recurred to some sites to get more information regarding the circular queue data structure. The following list can provide you a better understanding of such a data structure.

Thread Safety articles
[1] Venners, Bill. Designing for Thread Safety: Using Synchronization, Immutable Objects, and Thread-Safe Wrappers. 1998. Available at <http://www.artima.com/designtechniques/threadsafety.html>. Accessed on April 29, 2008.

[2] Suess, Michael. A Short Guide to Mastering Thread-Safety. 2006. Available at <http://www.thinkingparallel.com/2006/10/15/a-short-guide-to-mastering-thread-safety/>. Accessed on April 29, 2008.

[3] Allen, K. Scott. Statics & Thread Safety: Part II. 2004. Available at <http://www.odetocode.com/Articles/314.aspx>. Accessed on April 29, 2008.

Circular Queue sample code
[4] Kumar, Nunna Santhosh. Circular Queue Implementation using Arrays in C++. Available at <http://www.sourcecodesworld.com/source/show.asp?ScriptID=887>. Accessed on April 29, 2008.

Thread material
[5] Albahari, Joseph. Threading in C#. 2007. Available at <http://www.albahari.com/threading/>. Accessed on April 29, 2008.

Distance education or distance learning is a positive manner of tackling global education shortcomings. If we think about the world population we can imagine that not everyone has easy access to the resources we’re so accustomed to. Considering time constraints, distance education reveals itself a great alternative because the time spent to get to a classroom can be a negative factor. Think about people that live outside of big cities. They can't even apply for a course they want because there is no such a course where they live. These barriers lessen education availability and so someone somewhere that doesn’t fit on the above time and place prerequisites has their plans thwarted and can't move forward towards the mainstay “Education”. It’s a really beautiful word. Look at it for an instant and realize what would be of you if you didn’t have the basic of it. To those people to acquire a diploma in some area of knowledge can be considered an unthinkable action.

With the advent of the Internet we have today a classroom right inside our own home. We have the information we want at the exact moment we want and in most part all the information is freely available, that is, we have the opportunity to learn about any subject without having to pay for that end avoiding expenses with specific material that in most cases will be used only once or at most twice to be frank.

Obviously there are prestigious institutions that provide distance education, which confer the most prestigious titles to those that finish a course without at least being present in a classroom. All that with the help of new technological advances that pervade our lives, which in turn make distance education something viable.

Particularly I don’t like the idea of distance education. I prefer to be present at the classroom. It would feel weird taking an educational leadership course in a virtual classroom. I believe that presence education is more enriching. I write this based upon all point of views, being the most important: more active social life interaction.

The virtual classroom world is interesting, yet it’s necessary to heed, for this can bring some undesirable consequences such as the lack of a direct liaison between the teacher/professor and their students and colleagues. Great part of our development is done through social interaction and this is almost foregone when we talk about distance education. There are plenty of other factors that influence my opinion, but for now this demonstrates one of the big bottlenecks that refrains the distance education of evolving in faster paces. There are still conservatives. It can be the case that in a near future such conservatives perish the thought.

The actual distance education environments, such as TelEduc in Brazil enable the distance education practice to reach more and more people. My alma mater UBM constituted a center for distance education called NEAD and uses TelEduc as its environment. I have used it and what I write here has as background my experience as a user of the system.

Tertiary institutions as the case of UBM offer a vast range of improvement courses for their employees and even support courses for students that are undergoing their internship programs and college conclusion projects. The idea appears to be good, but in practice it’s not adopted by everyone, perhaps because of the lack of information regarding the distance education platform’s features and capabilities.

It’s good to highlight that the devices and techniques used to implement distance education are in great part the result of advances pertaining to information and communication technologies. These technologies aggregate people from the more diverse knowledge fields. Information and communication technologies include the set of technological and computational resources set aside to generate and propitiate the use of information. Thus, such technologies are established on the following components: hardware and their peripheral devices, software and their resources, telecommunication systems and data and information management.

The people responsible for the development and management of these components are increasingly requested on the market. Between them are computer engineers, computer scientists, system analysts, business analysts, chief information officers (CIO), chief executive officers (CEO), chief financial officers (CFO) just to name a few.

The instructional level has been growing a lot during the last years, what rises the competitiveness on the job market. A proven fact is that executives have been using distance education to leverage their academic degree, attending courses, such as a Master of Business Administration (MBA) at international universities as MIT, University of Cambridge, University of California, Berkeley, etc. Notwithstanding the executives are on their houses in the comfort of their couches or beds.

I complete this brief analysis of the influence of distance education stating that the use of new technologies like the Internet and well developed distance education environments are making life a lot easier if we take into account the commodity and easy access to information of any given area.

It’s worth to remember about the inherited risks that most of the times pass by unnoticed. The utilization of technology in excess can enslave men, transforming them in slaves of their own inventions. Wherefore we must discuss such subject, aiming at the discovery of a steady point between the virtual and real life, providing a better way for a rich development environment where all people can evolve in a natural manner. I wrote and meant everybody, what presupposes the integration of the underprivileged people into this whole new world of information called Internet. Long live the blogs of life.

On last January I started playing around with the Google Maps API that is especially intended to instigate the coding skills of the developers around the world. At that time I created a simple page to host a map that showed the directions from a start city to a destination city. Then I did other test in which I used Microsoft Visual C# 2008 Express to retrieve and parse the XML data generated by a Google Map search query. I was curious about how I could send a search to Google Map webservice and as a result get back the structured data to be consumed by some application. I just wanted to explore and see how it worked. At that time I set plans to blog about the Google Map functionally and so today I'm doing just that.

As the title states, I'm going to list here the steps necessary to add a Google Map on a web page and I will comment about the drawbacks I had to overcome to get it functioning the way I wanted.

The map I'll show has different markers. When one of these markers is clicked an info windows is opened to display some useful information. For a real example look at the map I place here on this blog. It's on the sidebar. As you can see the map starts in a hybrid fashion, that is, it shows normal and satellite views. The zoom level is adjusted based on the bounds of the existing markers. I'll detail what is necessary to do to get a map just like the one you see on this blog so that you can make your own.

The programming language used to construct the map is basically JavaScript. It's a good idea to check the Google Maps API documentation in order to get acquainted with the object types used when coding the map. For more information regarding a specific map object, refer to the documentation.

The steps I followed to get a functional map were:

1. Obtain a Google Maps API key at the Sign Up for the Google Maps API form
   The Google Maps API lets you embed Google Maps in your own web pages. A single Maps API key is valid for a single "directory" or domain. At the end of the sign up form just enter your domain name and you'll be given a key. Without this key your maps won't function.
2. Implement the map code

The following is the code I used to build the map:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">  <html xmlns="http://www.w3.org/1999/xhtml" xmlns:v="urn:schemas-microsoft-com:vml">
    <head>
      <meta http-equiv="content-type" content="text/html; charset=utf-8"/>
      <title>Leniel Macaferi's blog - Places I cite on this blog - Google Maps JavaScript API Example: Asynchronous Data Retrieval</title>
      <script src="http://maps.google.com/maps?file=api&amp;v=2&amp;key=YourKey" type="text/javascript"></script>

      <script type="text/javascript">
      function initialize()
      {
        if(GBrowserIsCompatible())
        {
          <!-- Create a base icon for all of our markers that specifies the shadow, icon dimensions, etc. -->
          var baseIcon = new GIcon();
          baseIcon.shadow = "http://www.google.com/mapfiles/shadow50.png";
          baseIcon.iconSize = new GSize(20, 34);
          baseIcon.shadowSize = new GSize(37, 34);
          baseIcon.iconAnchor = new GPoint(9, 34);
          baseIcon.infoWindowAnchor = new GPoint(9, 2);
          baseIcon.infoShadowAnchor = new GPoint(18, 25);

          <!-- Creates a marker whose info window displays the letter corresponding to the given index. -->
          function createMarker(point, index, tooltip, html)
          {
            <!-- Create a lettered icon for this point using our icon class -->
            var letter = String.fromCharCode("A".charCodeAt(0) + index);
            var letteredIcon = new GIcon(baseIcon);
            letteredIcon.image = "http://www.google.com/mapfiles/marker" + letter + ".png";

            <!-- Set up our GMarkerOptions object -->
            markerOptions = { icon:letteredIcon, title:tooltip};

            var marker = new GMarker(point, markerOptions);

            GEvent.addListener(marker, "click", function()
            {
              marker.openInfoWindowHtml(html);
            });

            return marker;
          }

          <!-- Creating the map and setting its essential properties -->
          var map = new GMap2(document.getElementById("map_canvas"));
          map.setCenter(new GLatLng(0,0),0);
          map.setMapType(G_HYBRID_MAP);
          map.addControl(new GLargeMapControl());
          map.addControl(new GMapTypeControl());

          var bounds = new GLatLngBounds();

          <!-- Download the data in data.xml and load it on the map. The format we expect is:
               <markers>
                 <marker lat="37.441" lng="-122.141" tooltip="Tooltip" html="HTML Code" />
                 <marker lat="37.322" lng="-121.213" tooltip="Tooltip" html="HTML Code" />
               </markers> -->
         GDownloadUrl("googlemap.xml", function(data)
         {
           var xml = GXml.parse(data);

           var markers = xml.documentElement.getElementsByTagName("marker");

           for(var i = 0; i < markers.length; i++)
           {
             var latlng = new GLatLng(parseFloat(markers[i].getAttribute("lat")), parseFloat(markers[i].getAttribute("lng")));

             var tooltip = markers[i].getAttribute("tooltip");

             var html = markers[i].getAttribute("html");

             map.addOverlay(createMarker(latlng, i, tooltip, html));

             bounds.extend(latlng);
           }

           map.setZoom(map.getBoundsZoomLevel(bounds));

           map.setCenter(bounds.getCenter());
         });
       }
     }

     </script>
  </head>

  <body onload="initialize()" onunload="GUnload()" style="width:265px; height:300px; margin:0px; padding:0px;">
<div id="map_canvas" style="float:left; width:265px; height:300px; margin:0px; padding:0px;"></div>
</body>
</html>

Let's see the first java script tag right beneath the title tag

<script src="http://maps.google.com/maps?file=api&amp;v=2&amp;key=YourKey" type="text/javascript"></script>

Note the YourKey value. Substitute this value with you own Google Maps API key. The JavaScript function initialize() is called when the page hosting the map is loaded. Look at the body tag:

<body onload="initialize()" ...

The initialize function firstly checks if the client browser is compatible with Google Maps with the GBrowserIsCompatible function:

if(GBrowserIsCompatible())
{
  ...
}

If this is the case, it's possible to go ahead and start the map construction. I won't comment the code I reuse. I'll just pass by it and brief explain what it does. Expect me explaining the other parts for sure. See the following lines:

<!-- Create a base icon for all of our markers that specifies the shadow, icon dimensions, etc. -->
var baseIcon = new GIcon();
baseIcon.shadow = "http://www.google.com/mapfiles/shadow50.png";
baseIcon.iconSize = new GSize(20, 34);
baseIcon.shadowSize = new GSize(37, 34);
baseIcon.iconAnchor = new GPoint(9, 34);
baseIcon.infoWindowAnchor = new GPoint(9, 2);
baseIcon.infoShadowAnchor = new GPoint(18, 25);

The above lines of code are defining a standard icon that'll be used to construct the markers on map.

The function createMarker does a really beautiful work. See it bellow:

<!-- Creates a marker whose info window displays the letter corresponding
to the given index. -->
function createMarker(point, index, tooltip, html)
{
  <!-- Create a lettered icon for this point using our icon class -->
  var letter = String.fromCharCode("A".charCodeAt(0) + index);
var letteredIcon = new GIcon(baseIcon);
letteredIcon.image = "http://www.google.com/mapfiles/marker" + letter + ".png";

  <!-- Set up our GMarkerOptions object -->
  markerOptions = { icon:letteredIcon, title:tooltip};

  var marker = new GMarker(point, markerOptions);

  GEvent.addListener(marker, "click", function()
  {
    marker.openInfoWindowHtml(html);
  });

  return marker;
}

What does it do? I receives a point, more specifically a GPoint, and index, a tooltip, and a html code. It then creates a GIcon using Google's letter images for each marker, based on its index. The markerOptions variable has a type of GMarkerOptions and stores the attributes that has do with the icon properties as for example the title that receives the tooltip parameter value. For each maker it's set up an event handler for the click event. When the marker is clicked its openInfoWindowHtml method is called with the html content passed as a parameter. The createMarker function then returns the new created marker that will be added to the map overlay.

What follows is the instantiation of the map:

var map = new GMap2(document.getElementById("map_canvas"));

A new object of type GMap2 is created. This object is instantiated in order to create a map. This is the central class in the API. Everything else is auxiliary. The object constructor accepts as argument an HTML container, which is typically a DIV element. In this case the id of the DIV element I use is map_canvas. If you look at the div tag that is inside the body tag you'll see the map_canvas id applied to the div.

<div id="map_canvas" ...

Next we center the map with zero values. I'll explain later why I do so. Then the map type is set:

map.setCenter(new GLatLng(0,0),0);
map.setMapType(G_HYBRID_MAP);

The function setMapType can accept the following list of values:

• G_NORMAL_MAP- the default view
• G_SATELLITE_MAP - showing Google Earth satellite images
• G_HYBRID_MAP - showing a mixture of normal and satellite views
• G_DEFAULT_MAP_TYPES - an array of these three types, useful for iterative processing

The next line of code uses a GSmallMapControl object to add to the map a control with buttons to pan in four directions, and zoom in and zoom out, and a zoom slider:

map.addControl(new GSmallMapControl());

The last line of code to mount the basic map framework uses a GMapTypeControl object to add a standard map type control for selecting and switching between supported map types via buttons:

map.addControl(new GMapTypeControl());

This line of code has to do with the zoom that will be applied to the map. A variable called bound is declared and its type is GLatLngBounds. It will be used afterwards to set the zoom level of the map. This variable represents a rectangle in geographical coordinates, including one that crosses the 180 degrees meridian:

var bounds = new GLatLngBounds();

After constructing the framework it's time to populate the map with the desired data. That's the exciting part. Let's get to it.

As the green commentary lines state there's a predefined data format to structure the bits relative to the markers (GMarker class) that will be shown on the map. In this post I'm using a XML file called googlemap.xml to store the markers' data. The data is composed of lat (latitude), lng (longitute), tooltip (title of the marker) and html (any text). What is really cool is that you can format the text inside the html value using HTML and CSS. The text will be displayed inside the marker's info window. Altough I don't use formating in my XML file you're being infored that this is possible. Bellow is the content of the file:

<markers>
<!-- Don't use copy and paste on this XML file, use "View Source" or "Save As"
What the browser displays is *interpreted* XML, not XML source. -->
  <marker lat="-22.522778" lng="-44.103889" tooltip="Hello World!" html='Hello World!"/>
  <marker lat="-23.209862" lng="-45.876168" tooltip="Jesus Message" html="I'm the way, the truth and the life. John 14:6" />
</markers>

To consume this data we must make a call to the GDownloadUrl function. This function provides a convenient way to asynchronously retrieve a resource identified by a URL. Notice that, since the XmlHttpRequest object is used to execute the request, it is subject to the same-origin restriction of cross-site scripting, i.e. the URL must refer to the same server as the URL of the current document that executes this code. This is known as the Same Origin Policy. Therefore, it is usually redundant to use an absolute URL for the url argument, and it is better to use an absolute or relative path only.

This explanation is really important. While implementing the map you see on the sidebar of this blog I tried to store the googlemap.xml file on a domain different from the one of this blog, that is, I placed the XML data file on leniel.googlepages.com and was trying to consume its content at lenielmacaferi.blogspot.com. It's not possible because of cross-domain scripting limitations. It's a security issue! So what I did? I thought about other way of implementing it. I created the map host page at leniel.googlepages.com and used an IFrame to show the page on the sidebar of this blog. Simple, isn't it? Doing so, there's no security issue since I'm running the above JavaScript and consuming the XML data on the same domain leniel.googlepages.com. An inconvenience if I can call it this way is that I had to get another Google Maps API key to use on the other domain. It's not a inconvenience at all! :)

That said, let's move on.

The GDownloadUrl function has the following signature:

GDownloadUrl(url, onload, postBody?, postContentType?)

As you can see I'm using just two of the parameters above when I call the function in the code:

GDownloadUrl("googlemap.xml", function(data)
{
  ...
});

It then retrieves the resource from the given URL and calls the onload function, in this case function with the text of the document as first argument.

Now what must be done is the parsing operation. We need to read each line of the markers' XML file and extract its individual components such as lat, lng, html and tooltip. To that end we declare a variable named xml that will store the GXml parsed content. Note the use of the parse static method that consumes the data we got from the googlemap.xml:

var xml = GXml.parse(data);

After parsing it's now created a variable named markers that will store the individual nodes (markers) of the XML file:

var markers = xml.documentElement.getElementsByTagName("marker");

As you can see the getElementByTagName function gets the marker elements from the XML file. Each marker has this form:

<marker lat="-23.209862" lng="-45.876168" tooltip="Jesus Message" html="I'm the way, the truth and the life. John 14:6" />

In the next step an iteration takes place over the collection of markers with a for loop:

for(var i = 0; i < markers.length; i++)
{
  ...
}

The next instruction instantiates a new object of type GLatLng so that we can get the lat and lng values of each marker and store the same in the latlng variable:

var latlng = new GLatLng(parseFloat(markers[i].getAttribute("lat")), parseFloat(markers[i].getAttribute("lng")));

It's time to retrieve the html code and tooltip values that will be shown on each mark. To that end are the following to lines:

var html = markers[i].getAttribute("html");

var tooltip = markers[i].getAttribute("tooltip");

A GMarker marks a position on the map. It implements the GOverlay interface and thus is added to the map using the GMap2.addOverlay() method. Each marker is created using its respective lat and lng values along with other relevant data you want as is the case of the following line of code. This is without doubt the trickiest part of the code :). I mean, after we call the createMarker function defined and explained above:

map.addOverlay(createMarker(latlng, i, tooltip, html));

For the purpose of setting a nice zoom on the map I use the bounds variable:

bounds.extend(latlng);

This variable is extended in conformity with the largest latitude and longitude. The above line is the last one pertaining to the loop and now we're almost done. We have two more lines of code to go through to finalize the map construction:

map.setZoom(map.getBoundsZoomLevel(bounds));
map.setCenter(bounds.getCenter());

The first line sets the zoom using the bounds variable and the second one center the focus on the map using the getCenter method from the bounds variable. That's it. The map is ready!

You can see this map running at this URL: http://leniel.googlepages.com/googlemap.html

Final notes
Pay close attention to the written code. If you change a letter in the name of a variable for example, your code won't function and you'll probably not see the map.

If loading the information from XML as is the case of this post, replace '<' and '>' characters with &lt; and &gt;. For example: &lt;img src="image.jpg" width=150 height=100&gt;

There are plenty of excellent material about the Google Maps API on the internet and the possibilities are uncountable. Just let your imagination flow and build amazing, astonishing maps that fit your will.

References
The code I present on this post is a mix from a variety of sources and some of them are listed bellow. I just adapted it so that I could get the result I wanted.

The following links are great sources of information. Particularly, take a look at Mike's Little Web Page. He has a bunch of great stuff about Google Maps API.

Mike Little's Web Page
http://www.econym.demon.co.uk/

Google Maps API Tutorial
http://econym.googlepages.com/index.htm

Fitting the map to the data
http://econym.googlepages.com/basic14.htm

Links and Images, etc.
http://econym.googlepages.com/basic6.htm http://econym.googlepages.com/example_map6b.htm

Services - Google Maps API - Google Code http://code.google.com/apis/maps/documentation/services.html

Google Maps JavaScript API Example: Asynchronous Data Retrieval http://code.google.com/apis/maps/documentation/examples/xhr-requests.html

Google Maps JavaScript API Example: Custom Icon http://code.google.com/apis/maps/documentation/examples/icon-custom.html

Batch file
In MS-DOS, OS/2, and Windows, a batch file is a text file containing a series of commands intended to be executed by the command interpreter. When a batch file is run, the shell program (usually COMMAND.COM or cmd.exe) reads the file and executes its commands, normally line-by-line. Batch files are useful for running a sequence of executables automatically and are often used by system administrators to automate tedious processes.

For more details, see the Batch file document at Wikipedia.

A sample batch file
In a recent post titled Syntactic Analyzer built with Flex and YACC I used a simple batch file in the compilers construction paper. Why I did that? To avoid boiler plate work while executing the commands necessary to generate the syntactic analyzer executable.

In this post I'll present and comment in more details the content of such batch file.

The following table shows the content of the batch file. I also include the command line number and its respective comment in the table, so that it's easier to visualize what's going on.

#	Code	Comment
1	@Echo Off	Turn off screen messages
2	::cls	A comment. Start with ::
3	:Start	Declare the label Start
4	Echo.	Print a blank line. See the dot after Echo.
5	Echo Batch file Menu	Print the string "Batch file Menu"
6	Echo.	Print a blank line
7	Echo 1 - MinGW	Print the string "1 - MinGW"
8	Echo.	Print a blank line
9	Echo 2 - SinAn	Print the string "2 - SinAn"
10	Echo.	Print a blank line
11	Echo 3 - Exit	Print the string "3 - Exit"
12	Echo.	Print a blank line
13	set choice=	Declare the choice variable
14	set /p choice=Choice:	See note 1.
15	if not '%choice%'=='' set choice=%choice:~0,1%	See note 2.
16	if '%choice%'=='1' goto MinGW	Go to label MinGW at line 22
17	if '%choice%'=='2' goto SinAn	Go to label SinAn at line 25
18	if '%choice%'=='3' goto Exit	Go to label Exit at line 37
19	Echo "%choice%" is not valid.	Prints error if choice isn't 1, 2 or 3
20	Echo.	Print a blank line
21	goto Start	Go to label Start at line #3
22	:MinGW	Declare the label MinGW
23	path=C:\MinGW\bin;%PATH%	Rewrite path with new value. See note 3.
24	goto end	Go to label end at line 39
25	:SinAn	Declare the label SinAn
26	@Echo On	Turn on screen messages
27	path=C:\MinGW\bin;%PATH%	Rewrite path with new value
28	cls	Clear the screen
29	CD CompCons	Navigate to CompCons directory
30	flex -i lexan.lex	Execute flex command
31	yacc sinan.yacc	Execute yacc command
32	gcc y.tab.c yyerror.c main.c -osinan -lfl	Execute gcc command
33	sinan <factorial.txt	Execute sinan command. See note 4.
34	cd..	Navigate one directory above
35	@Echo Off	Turn off screen messages
36	goto end	Go to label end at line 39
37	:Exit	Declare the label Exit
38	goto end	Go to label end at line 39
39	:end	Declare the label end. EOF :)

Notes
There are four notes that I think are worth commenting:

1. set /p choice=Choice:
   The /p switch tells the command interpreter that the value of the variable choice will be the input entered by the user. The interpreter will display the string "Choice:" before reading the line of input.
   This command has the following format: set /p variable=[promptString]
2. if not '%choice%'=='' set choice=%choice:~0,1%
   Every time you need to get the content of a variable it's necessary to enclose it with the percent sign %. Note the use of the quotation mark in both sides too. If a command contains two percent signs, the command interpreter will treat any characters between them as an environment variable to be expanded.
   The tilde sign ~ tells the interpreter that I want to slice a string in a variable.
   This command has the following format: %NAME:~s,n where s is the start position (zero-offset) and n is the number of characters. If s is negative, then the offset starts from the right side minus 1 (i.e. -1 refers to the rightmost character). If n is negative, then length -n characters, are extracted.
   If the variable choice isn't empty, get only the first character of the user input.
3. path=C:\MinGW\bin;%PATH%
   The path variable is already part of the operating system set of variables. In this case I'm just rewriting its value with the desired directory. Note that I also attribute to path the content of other defined variable called PATH.
4. sinan < factorial.txt
   Having no to do with the batch file explanation and just for the sake of clarification: the less angle bracket symbol < means that I'm redirecting the contents of the file factorial.txt to the executable file sinan. The sinan executable will consume the data stored in the factorial.txt file to do its computations.

To execute a batch file, just open a command prompt and type its name. You can even type the name without the .bat extension.

When a batch file is executed, the command interpreter will automatically execute each line of the batch file automating the whole process, that is, you won't need to type the same series of commands each time you want to execute a single work.

In this sample batch file what I want to accomplish is to run 4 executable files - see lines 30, 31, 32 and 33. By selecting option 2 at line 17, the interpreter goes to line 25 and so I'll have all the 4 executables running with a single command since the SinAn label at line 25 comprises these commands.

You can get the sample batch file at: http://leniel.googlepages.com/SampleBatchFile.bat