KaZeitgeist

Yet another win for Agile

2012-02-02T01:19:00.000-08:00

We've been talking about how to help our community at Kaz for a long time. Being a bunch of "techies" that’s no easy goal!

We thought, we'll use our experiences of software process to achieve this goal. That immediately led us to some brainstorming sessions, which led to chaos (as usual) and minor ideological war (even more usual), this led to a wiki page for idea submission. But hey that’s the PROCESS!

We got a lot of ideas, some of them phenomenally good and some borderline crazy. We thought we will pick up some of them and start. But that’s where things stopped.

After cycling through this several times we realized that we are really running things classic Waterfall with big design upfront and all of its smelly friends (sorry, you have to forgive me for these weak allusions, but this blog is consumed mostly by software guys). Anyway, we realized we need to go agile and take some baby steps to get something done.

As luck would have it, pretty much around same time of this ground breaking, earth shattering realization that agile is good, a dodgy looking guy dropped in at Kaz. He came as friend of a Kaz guy but it turned out he is a super secret philanthropist who runs a teaching program for street children pretty close to us. This was our chance! We went agile with him.

So the success of this baby step is that we are now proudly providing snacks for every child that turn up for the class - and that acts as very good magnet to keep the children coming. The next baby step is that we do some basic computer skill training to the children (I know, somewhere someplace that machine had to come in). Sadly the secret philanthropist tells us that teaching them C++ (which we feel is a must for anyone touching that machine) won't be very helpful for the kids so we are sticking to the "how to click the start button" path. But we hope that this is a start of bigger and better things - maybe even some of our ideas in the wiki too.

If you feel like making a baby step too, feel free to drop in at the street class at around 4pm on the street that leads from Aziz Super market to Paribag:

So yet another karma point for Agile - this thing is definitely making it to the Nirvana.

Extending WCF Part I

2009-11-25T21:39:00.000-08:00

by Mosfiqur Rahman

Senior Software Engineer @Kaz

Introduction

Microsoft WCF Framework (System.ServiceModel) provides several extension points
from where developer can extend the framework when it requires. In this Part I article
I'm going to cover two perspective of extending WCF framework:

1. Lets think about a WPF desktop application or a WPf browser application or a
windows desktop application or a .net web application, built on service oriented
architecture and all the back end services are WCF services. Now for several reasons
you may need to change the server for your service which in turn changes your service
URL or you may need to change the configuration of service bindings/behaviors. If
you change any WCF configuration at the server you need to provide the same bindings/behaviors
configuration to the clients also to work the client-service interaction properly.
And this is very difficult in typical clients like XBAP (WPF Browser application)
clients. My ExtendingWCFPartI.WcfExtentions.dll component provides a solution to
this. You can have an external configuration file (e.g. by downloading it from server
before client application starts up) where service endpoints are configured properly
and use that external configuration file to create the WCF service proxy instances.

2. In many cases we want to get exactly the same exception thrown from WCF service
at WCF client. ExtendingWCFPartI.WcfExtentions.dll component also provides this.

Background

Extending ChannelFactory<T>

This extension is to serve the first introduction item.
In general System.ServiceModel.ChannelFactory<T> provides us the option to
get a proxy instance programmatically instead of using the proxy generated through
svcutil.exe (.NET Framework tool). I've extended this class to write my own ExtendingWCFPartI.WcfExtentions.ExtendedChannelFactory<T>
class to provide the external configuration file functionality.
The constructor argument "configurationPath" should contain the full path of the
external configuration file. Then I override the ChannelFactory<T>.CreateDescription()
method to apply the external configuration file. The external configuration file
looks exactly the same as conventional client's app.config or web.config file. For
sample external configuration, you can look at the ExtendingWCFPartI.Client.WcfClientConfiguration.xml
file.

Extending WCF Service and WCF client behavior

To provide the second introduction item, we need to
extend behavior of service, endpoint and contract.


public class ExtendedServiceErrorHandler:IErrorHandler
{
    #region IErrorHandler Members

    bool IErrorHandler.HandleError(Exception error)
    {
        if (error is FaultException)
        {
            return false; // Let WCF do normal processing
        }
        else
        {
            return true; // Fault message is already generated
        }
    }

    void IErrorHandler.ProvideFault(Exception error,
        MessageVersion version,
        ref Message fault)
    {
        if (error is FaultException)
        {
            // Let WCF do normal processing
        }
        else
        {
            // Generate fault message manually
            MessageFault messageFault = MessageFault.CreateFault(
                new FaultCode("Sender"),
                new FaultReason(error.Message),
                error,
                new NetDataContractSerializer());
            fault = Message.CreateMessage(version, messageFault, null);
        }
    }

    #endregion
}// end of class

ExtendedServiceErrorHandler should be injected into

ChannelDispatcher's error handler list. Then WCF Framework will use our
implemented IErrorHandler.ProvideFault method when any exception is thrown from
service. Inside the method implementation I used the NetDataContractSerializer to
serialize the MessageFault which will be trasmitted to client.


public class ExtendedClientMessageInspector:IClientMessageInspector
{
    #region Methods

    /// Reads the soap message to find the
    /// node. If found than deserialize it using the 
    /// NetDataContractSerializer to construct the exception.
    private static object ReadFaultDetail(Message reply)
    {
        const string detailElementName = "Detail";

        using (var reader = reply.GetReaderAtBodyContents())
        {
            // Find

            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element && reader.LocalName == detailElementName)
                {
                    break;
                }
            }

            // Did we find it?
            if (reader.NodeType != XmlNodeType.Element || reader.LocalName != detailElementName)
            {
                return null;
            }

            // Move to the contents of 
            if (!reader.Read())
            {
                return null;
            }

            // Deserialize the fault
            var serializer = new NetDataContractSerializer();
            try
            {
                return serializer.ReadObject(reader);
            }
            catch (FileNotFoundException)
            {
                // Serializer was unable to find assembly where exception is defined 
                return null;
            }
        }
    }

    #endregion


    #region IClientMessageInspector Members

    /// Create a copy of the original reply to allow 
    /// default processing of the message. Then its reads 
    /// the copied reply to find Fault Detail using the ReadFaultDetail method
    void IClientMessageInspector.AfterReceiveReply(ref Message reply, object correlationState)
    {
        if (reply.IsFault)
        {
            // Create a copy of the original reply to allow default processing of the message
            var buffer = reply.CreateBufferedCopy(Int32.MaxValue);
            var copy = buffer.CreateMessage();  // Create a copy to work with
            reply = buffer.CreateMessage();         // Restore the original message

            var faultDetail = ReadFaultDetail(copy);
            var exception = faultDetail as Exception;
            if (exception != null)
            {
                throw exception;
            }
        }
    }

    object IClientMessageInspector.BeforeSendRequest(ref System.ServiceModel.Channels.Message request, System.ServiceModel.IClientChannel channel)
    {
        return null;
    }

    #endregion
}// end of class

Now we need to extend the IClientMessageInspector to get back the same exception
at client end. At IClientMessageInspector.AfterReceiveReply method implementation,
NetDataContractSerializer has been used to get desrialize the fault exception and
get the actual exception back again.



public class ExtendedServiceBehavior:Attribute, IServiceBehavior, IEndpointBehavior, IContractBehavior
{
    private void ApplyDispatchBehavior(ChannelDispatcher dispatcher)
    {
        // Don't add an error handler if it already exists
        foreach (IErrorHandler errorHandler in dispatcher.ErrorHandlers)
        {
            if (errorHandler is ExtendedServiceErrorHandler)
            {
                return;
            }
        }
        dispatcher.ErrorHandlers.Add(new ExtendedServiceErrorHandler());
    }


    private void ApplyClientBehavior(ClientRuntime runtime)
    {
        // Don't add a message inspector if it already exists
        foreach (IClientMessageInspector messageInspector in runtime.MessageInspectors)
        {
            if (messageInspector is ExtendedClientMessageInspector)
            {
                return;
            }
        }

        runtime.MessageInspectors.Add(new ExtendedClientMessageInspector());
    }
}

To tell the .NET runtime to use my ExtendedServiceErrorHandler at Service end error
handling and ExtendedClientMessageInspector at client error halding we need this
ExtendedServiceBehavior class which implemented service, endpoint and contract behavior.
All behaviors have an AddBindingParameters method, an ApplyDispatchBehavior method,
a Validate method, and an ApplyClientBehavior method with one exception: Because
IServiceBehavior cannot execute in a client, it does not implement ApplyClientBehavior.
For more details you can read the
msdn documentation.

Using the Code

For simplicity, I've hosted the WCF service at console. To run the sample code and
see it working, follow the steps below:

1. After opening the "ExtendingWCFPartI" application with VS, right click on the
ExtendingWCFPartI.Service project then click Debug -- > Start new instance. Doing
so, you have ensured that the service is running at console host.

2. Then run the ExtendingWCFPartI.Client project under debug mode.

ExtendingWCFPartI.WcfExtentions.dll is the reusable component which is going to
be used at both WCF client and WCF service. Also make sure that you wrote the custom
exceptions in a common assembly which will be used at both WCF client and WCF service.

Using the code at WCF Service

At first let me show you how we can use this component to host our WCF services. You
can host the WCF services at IIS or at Windows Service or at console, no matter
where you host it, add the following section at your app.config or web.config ServiceModel
section. Add a reference the ExtendingWCFPartI.WcfExtentions.dll to your service
host application


<system.serviceModel>
    <extensions>
      <behaviorExtensions>
        <add name="ExtendedServiceBehavior" type="ExtendingWCFPartI.WcfExtentions.ServiceBehaviorExtension, ExtendingWCFPartI.WcfExtentions, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/>

      </behaviorExtensions>
    </extensions>
</system.serviceModel>

ExtendingWCFPartI.WcfExtentions.ServiceBehaviorExtension has been used to tell WCF
framework to use ExtendedServiceBehavior at its CreateBehavior() method.


<system.serviceModel>
    <behaviors>

      <serviceBehaviors>
        <behavior name="CustomServiceBehavior">
          <serviceMetadata httpGetEnabled="true" />
          <serviceDebug includeExceptionDetailInFaults="true" />
          <serviceThrottling maxConcurrentCalls="16" maxConcurrentSessions="16" />
          <ExtendedServiceBehavior />

        </behavior>
      </serviceBehaviors>
    </behaviors>
</system.serviceModel>

Now create a service behavior like the example above. <ExtendedServiceBehavior
/> ensures that this behavior configuration will use the ExtendedServiceBehavior.



<system.serviceModel>
    <services>
      <service behaviorConfiguration="CustomServiceBehavior" name="ExtendingWCFPartI.Service.CustomerService">
        ... 
        ... 
        Your service endpoint's configuration goes here.
      </service>
    </services>
</system.serviceModel>

Thats all you need to do to host your WCF service which will have the two functionalities
explained at introduction.

Using the code at WCF Client

Add a reference to the ExtendingWCFPartI.WcfExtentions.dll at your client application.
Now create the external configuration file. It may look like following:



<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <extensions>
      <behaviorExtensions>
        <add name="ExtendedServiceEndpointBehavior" type="ExtendingWCFPartI.WcfExtentions.ServiceBehaviorExtension, ExtendingWCFPartI.WcfExtentions, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/>
      </behaviorExtensions>

    </extensions>
    <bindings>
        .. tips: provide the same binding which has been used at service
    </bindings>
    <behaviors>
      <endpointBehaviors>
        <behavior name="CustomServiceEndpointBehavior">

          <ExtendedServiceEndpointBehavior />
        </behavior>
      </endpointBehaviors>
    </behaviors>
    <client>
      <endpoint address="http://localhost:8036/Services/CustomerService"
          binding="wsHttpBinding" bindingConfiguration="CustomWSHttpBinding" 
          behaviorConfiguration="CustomServiceEndpointBehavior" 
          contract="ExtendingWCFPartI.Common.Services.ICustomerService" name="CustomerServiceEndPoint" />

    </client>
  </system.serviceModel>
</configuration>

Now save this external configuration file at any location of your hard drive with
.xml or .config extension. e.g. "C:\Temp\MyAppServices.xml".
I've provided a very simple inerface ExtendingWCFPartI.WcfExtentions.WcfClientHelper
to get the instance of proxy.


public static T GetProxy<T>(string externalConfigPath)
{
    var channelFactory = new ExtendedChannelFactory<T>(externalConfigPath);
    channelFactory.Open();
    return channelFactory.CreateChannel();
}

At client code use this interface to call your service method:


var externalConfigPath = @"C:\Temp\MyAppServices.xml";
var proxy = WcfClientHelper.GetProxy<IMyWCFService>(externalConfigPath);
proxy.CallServiceMethod();

Points of Interest

There are many more extension points at WCF framework which are very interesting
and usefull. I'll try my best to cover few more examples later in my next article.
In brief, I found the WCF framework so well designed that programmers have almost
all the options to do whatever he wants.

Designer = can do XAML !!!

2009-11-04T02:29:00.000-08:00

Sunday, October 25, 2009

It means a combination of “Creativity and Coding”. Yes now a Designer can be a coder as well. Perhaps you are thinking that it’s a crap :-). Nope it is real. I never wanted to go to the programming world. I think it is a bit boring and monotonous for a designer. Some couple of month back our CTO comes and requested me to learn XAML. He explained all the prospects of XAML in a positive mode. At that time I was thinking that what my CTO is saying is truly a fantasy web world. One question was hitting repeatedly in my mind and that is “CAN I DO THAT?”.

Yes XAML is truly a fantasy playground for a designer. After getting 2 months successful training (Thanks to our CTO and special thanks to Taufiq for being an excellent XAML teacher) on XAML I got the confident and started doing coding immediately with the other developers :-). Ok cut off the story of mine and let discuss the prospect of XAML.

XAML is a new descriptive programming language developed by Microsoft to write user interfaces for next generation managed applications. Extensible Application Markup Language or is a new declarative language that is used in Windows Framework and Windows Presentation Foundation. Introduced with .NET Framework 3.0, XAML is harbinger of declarative (in contrast with imperative using coding) programming model. In Workflow Foundation, workflows can be created using code as well as XAML. Even fully XAML-based solutions are possible with no code at all! This not only gives flexibility of no-compilation-needed to applications, it also opens up a window of possibility for entirely non-technical persons (like business analysts) to design workflows. (Though Workflow Foundation is targeted for programmers, experiments are underway around the globe for making it feasible for business analysts to model processes in it).

Let me ask a simple question. Can you build a Combo box on a button? Or can you customize a button for a Combo box? Very difficult or even not possible in other programming languages but it can be done in XAML with a few lines of code. So a Designer can play around wherever he/she wants to. So the bottom line is Designer can now think out of the box, can do outstanding mockups for web or desktop application.

For XAML, we need to have a basic knowledge on XML, CSS. You will get lot of tutorials for XAML on the net. So learn XAML and discover the future.

Enjoy!

Shadows of Sinensis

2009-03-12T05:22:00.000-07:00

- Md. Ferdous Bhuiyan

Shadows of Sinensis, a memorable trip to Srimongol, will remain afresh in the mind of Kaz family. Fun-loving Kaz Family went on rampage to obtain unlimited ‘Furti’ and relaxation during our 3-day tour to Srimongol from 15 to 17 February, 2009. Eventful Srimongol trip offered us relaxation, fun and most importantly the joy to share with our colleagues and family members. The team of Srimongol trip encompasses each and every one of Kaz Family. Young stars of the team aged 3-month to 3-year provided the team with pure and refreshing entertainment in the lap of nature. All of us along with our spouses and kids looted the unlimited joy by swimming in the pool, climbing the mountains, wandering in the wilderness and having delicious foods.

Powered by 41-member, Kaz team reveals the sportive frenzy of Kaz family. Many of our enthusiastic players as well as cheering audiences enjoyed watching and playing Cricket, Badminton, Football and Table Tennis at daylight and even at night using light. Frenzied bedding accompanied by enthusiastic cheering gave the events a special glow.
Silence of the evenings was shattered with the sound of laughter provoked by lively ‘Adda’ and the melody of harmonica and songs sung by us ruled the isolation of night. Monotony or tiered is something that failed to touch the mind even for a second. Luxurious and well-furnished bungalows became the place to spend last few hours of night to start a new day with more enthusiasm.

A spur-of-the-moment decision fixed the day scheduled. Going to ‘Lawachara’ or finding out the tea-stall named ‘Nilkantha’ to have multilayered tea was decided within a few minutes with the urge to know the unknown. Such whimsical decisions to visit outside of the Tea Resort made the trip more attractive and gave us the chance to experience something new and adventurous. Those who were more attracted to water of appealing swimming pool were busy with swimming and diving throughout the whole noon.
Delicious Food must be there to color a memorable time. We the KAZ people vowed not to get hungry and have delicious good food with every single chance of celebrating party. There is no exception of this oath even at Srimongol trip. Being the fan of delicious food we grilled chicken and included delicious dishes for a sensational dinner and enjoyed the last night having spicy food and dessert.

Sensible traditional ethos of our firm revives with this lovely trip. And it would be no rhetoric to reiterate the truth that ‘Shadows of Sinensis’ is a great step forward for the neatly tied Kaz family to enhance its fellow-feelings and team spirit as ever.

Emperors on the move

2008-07-31T05:15:00.000-07:00

At last August his here!

August at Kaz is the long awaited month of the anniversary party! (Kaz actually started in June, but we do the anniversary party in August because it fits with the software world's tendency of taking it easy in August worldwide!)

This year we are off to the great triangle trip of Delhi - Agra and Jaipur. The trip is code named "Emperors on the move!"

Ten days of non-stop furti!

Home Made Java Virtual Machine

2008-03-29T06:25:00.000-07:00

by Maruf Maniruzzaman

Download JVM Source Code kjvm.zip - 39.65 KB

Download seminar presentation - 229.95 KB

Introduction

Back in year 2004 I had to choose a thesis topic as a prerequisite of completion of my undergraduate course in
Computer Science and Engineering. I had choosen Process Migration. And our teacher Mahmud Shahriar Hossain agreed to
supervise my work. My partner was Md. Helal Uddin. As part of the thesis I had to implement a Java Virtual Machine.
I wanted to write an article since then. But it never actually happened. Today (March 2) is my birth day and
I want to start it. The virtual machine is also used in my new
project Morpheus - a prototype of Silverlight 1.1.
The seminar presentation downloadable from above link shows how a JVM works. You may also look at the JVM
source code from above link. Please note that most the implementation decision taken may not match with other
commercially available JVM implementation. Whenever JVM Spec is found to say nothing, the most easiest approach
is taken to save time.

Java Virtual Machine Parts

Class File Structure

The java virtual machine needs an application that is made up of collection of java classes. At the beginning of any
class there is a defined structure like JavaClassFileFormat.



     struct  JavaClassFileFormat
     {
         u4 magic;
         u2 minor_version;
         u2 major_version;
         u2 constant_pool_count;
         cp_info **constant_pool; //[constant_pool_count-1];
         u2 access_flags;
         u2 this_class;
         u2 super_class;
         u2 interfaces_count;
         u2* interfaces; //[interfaces_count];
         u2 fields_count;
         field_info_ex *fields; //[fields_count];
         u2 methods_count;
         method_info_ex* methods; //[methods_count];
         u2 attributes_count;
         attribute_info** attributes; //[attributes_count];
     };

Following are the structures used in the format. They represents constant pool (constant values used in class files), fields,
methods and attributes in a class file. I'll describe them in details later.



     struct cp_info
     {
         u1 tag;
         u1* info;
     }; 

     struct field_info
     {
         u2 access_flags;
         u2 name_index;
         u2 descriptor_index;
         u2 attributes_count;
         attribute_info* attributes; //[attributes_count];
     }; 

     struct method_info
     {
         u2 access_flags;
         u2 name_index;
         u2 descriptor_index;
         u2 attributes_count;
         attribute_info* attributes; //[attributes_count];
     }; 

     struct attribute_info
     {
         u2 attribute_name_index;
         u4 attribute_length;
         u1* info;//[attribute_length];
     };

We first load the class file in memory as raw byte and then use JavaClass object to parse the raw bytes
and identify the fields, methods, exception table etc. The JavaClass class represent a class in memory in
structured form. It holds a pointer to the raw byte stream that was loaded from class file.

Java Class in Memory

Here we just inherit the JavaClassFileFormat for simplicity of storing the values in in memory class
representation. We must parse the raw class file in memory to get the values for JavaClassFileFormat fields.



	class JavaClass: public JavaClassFileFormat
	{
	public:
		JavaClass(void);
		virtual ~JavaClass(void);

	public:
		virtual BOOL LoadClassFromFile(CString lpszFilePath);
		void SetByteCode(void* pByteCode);

		BOOL ParseClass(void);
		BOOL ParseInterfaces(char* &p);
		BOOL ParseFields(char* &p);
		BOOL ParseMethods(char* &p);
		BOOL ParseAttributes(char* &p);
		BOOL GetConstantPool(u2 nIndex, cp_info& const_pool);

		BOOL GetStringFromConstPool(int nIndex,CString& strValue);
		CString GetName(void);
		CString GetSuperClassName(void);
		BOOL ParseMethodCodeAttribute(int nMethodIndex, Code_attribute* pCode_attr);
		int GetMethodIndex(CString strMethodName, CString strMethodDesc,JavaClass* &pClass);
		int GetFieldIndex(CString strName, CString& strDesc);
		void SetClassHeap(ClassHeap *pClassHeap){this->m_pClassHeap=pClassHeap;}
		virtual u4 GetObjectSize(void);
		virtual u4 GetObjectFieldCount(void);
		JavaClass* GetSuperClass(void);
		BOOL CreateObject(u2 index, ObjectHeap *pObjectHeap, Object& object);
		BOOL CreateObjectArray(u2 index, u4 count, ObjectHeap *pObjectHeap, Object& object);
	private:
		size_t m_nByteCodeLength;
		void *m_pByteCode;
		u2	m_nObjectFieldsCount;
		BOOL ParseConstantPool(char* &p);
		int GetConstantPoolSize(char* p);
		ClassHeap *m_pClassHeap;
	};

To do that we first load the file in memory and then call the ParseClass method which is shown
in the next section.

Class Loader

As there are some variable length fields it is not possible to directly load the structure. So we load the
values one by one. First we load the value of magic which is an unsigned integer (u4) value. It must be value
of 0xCafeBabe. If it is not the class file may be either corrupted or not a java class file at all. Then we
load other values and structures. To load structures we first load the count and then load the structure.
For example first we load short (u2) value constant_pool_count and then load that number of constant pool.
To parse I used definitions getu4(p) or similar which just picks 4 bytes starting at p and returns the unsigned
int value. To parse structures hare use sepaate methods like ParseConstantPool.
It takes the reference of the byte stream pointer and increments in that class. I did this only for simplicity.
It would be more readable if I'd return the total length and increent in ParseClass method but that would me less managable.



	BOOL JavaClass::ParseClass(void )
	{
		//just to be safe
		if (m_pByteCode==NULL ||
				m_nByteCodeLength < sizeof (JavaClassFileFormat)+20)
			return FALSE;
		char *p=( char *)m_pByteCode;
		magic = getu4(p); p+=4;
		ASSERT(magic == 0xCAFEBABE); 

		if(magic != 0xCAFEBABE)
			return FALSE;

		minor_version=getu2(p); p+=2;
		major_version=getu2(p); p+=2;
		constant_pool_count=getu2(p); p+=2; 

		if (constant_pool_count>0)
			ParseConstantPool(p); 

		access_flags=getu2(p); p+=2;
		this_class=getu2(p); p+=2;
		super_class=getu2(p); p+=2;
		interfaces_count=getu2(p); p+=2; 

		if (interfaces_count>0)
			ParseInterfaces(p); 

		fields_count=getu2(p); p+=2; 

		if (fields_count > 0)
			ParseFields(p); 

		methods_count = getu2(p);p+=2; 

		if (methods_count > 0)
		{
			ParseMethods(p);
		}
		attributes_count = getu2(p);p+=2; 

		if (attributes_count > 0)
			ParseAttributes(p); 

		return 0;
	}

Constant Pool

In a java class several constant value is stored. It stores numeric, string and reference values
in a pool and those are used in machine codes known as 'Java Byte Code'. Constant pool contains
constant_pool_count items in a sequential list of following structure.



    struct cp_info
    {
	    u1 tag;
        u1* info;
    };

Constant pool information structure starts with one byte of tag information that
indicates the type of the constant pool. Constant pool structure length is variable
depending on the type of constant. Constant pool tag value can be one of the
following values depending on the type of constant.



    #define CONSTANT_Integer  3
    #define CONSTANT_Float  4
    #define CONSTANT_Long  5
    #define CONSTANT_Double  6
    #define CONSTANT_Utf8  1
    #define CONSTANT_String  8  

    #define CONSTANT_Class  7
    #define CONSTANT_Fieldref  9
    #define CONSTANT_Methodref  10
    #define CONSTANT_InterfaceMethodref  11
    #define CONSTANT_NameAndType  12

Depending on the value of tag we can cast the cp_info structure in more precise
structures listed here.

CONSTANT_Integer_info

If tag value equals CONSTANT_Integer in cp_info structure then it is an integer
constant. We can cast the cp_info structure in following structure.



    struct CONSTANT_Integer_info {
        u1 tag;
        u4 bytes;
    };

This structure does not have any reference to any other constant. It represents
direct 4 byte integer value.

CONSTANT_Float_info

If tag value equals CONSTANT_Float in cp_info structure then it is a float
constant. We can cast the cp_info structure in following structure.



    struct CONSTANT_Float_info {
        u1 tag;
        u4 bytes;
    };

It is a direct value constant without any reference.

CONSTANT_Long_info

If tag value equals CONSTANT_Long in cp_info structure then it is a long
constant. We can cast the cp_info structure in following structure.



    struct CONSTANT_Long_info {
        u1 tag;
        u4 high_bytes;
        u4 low_bytes;
    };

It is a direct value constant without any reference. It uses two four bute values
to construct the 8 byte long value.

CONSTANT_Long_info

If tag value equals CONSTANT_Double in cp_info structure then it is a double
constant. We can cast the cp_info structure in following structure.



    struct CONSTANT_Double_info {
        u1 tag;
        u4 high_bytes;
        u4 low_bytes;
    };

It is a direct value constant without any reference. It uses two four bute values
to construct the 8 byte double value.

CONSTANT_Utf8_info

If tag value equals CONSTANT_Utf8 in cp_info structure then it is a utf8 string
constant. We can cast the cp_info structure in following structure.



    struct CONSTANT_Utf8_info {
        u1 tag;
        u2 length;
        u1* bytes;//[length];
    };

It is a direct value constant without any reference. The short value length defines
the length of the byte array followed by length number of bytes.

CONSTANT_String_info

If tag value equals CONSTANT_String in cp_info structure then it is a string reference
constant. We can cast the cp_info structure in following structure.



    struct CONSTANT_String_info {
        u1 tag;
        u2 string_index;
    };

It is a reference value constant. The short value string_index refers
to a CONSTANT_Utf8_info index in the constant pool.

CONSTANT_Class_info

If tag value equals CONSTANT_Class in cp_info structure then it is a class reference
constant. We can cast the cp_info structure in following structure.



    struct CONSTANT_Class_info {
 	    u1 tag;
   	    u2 name_index;
    };

It is a reference value constant. The short value name_index refers
to a CONSTANT_Utf8_info index in the constant pool that is the fully
qualified name (ie java/lang/String) of the class- dot replaced by
slash.

CONSTANT_Fieldref_info

If tag value equals CONSTANT_Fieldref in cp_info structure then
it is a field reference constant. We can cast the cp_info structure
in following structure.



    struct CONSTANT_Fieldref_info {
        u1 tag;
        u2 class_index;
        u2 name_and_type_index;
    };

It is a reference value constant. The short value class_index refers
to a CONSTANT_Class_info index in the constant pool and
name_and_type_index refers to a string index in the constant pool that
is the fully qualified name (ie java/lang/String@valueOf(F)Ljava/lang/String;)
of the class- dot replaced by slash.

CONSTANT_Methodref_info

If tag value equals CONSTANT_Methodref in cp_info structure then
it is a method reference constant. We can cast the cp_info structure
in following structure.



    struct CONSTANT_Methodref_info {
        u1 tag;
        u2 class_index;
        u2 name_and_type_index;
    };

CONSTANT_InterfaceMethodref_info

If tag value equals CONSTANT_InterfaceMethodref in cp_info structure then
it is an interface method reference constant. We can cast the cp_info structure
in following structure.



    struct CONSTANT_InterfaceMethodref_info {
        u1 tag;
        u2 class_index;
        u2 name_and_type_index;
    };

CONSTANT_NameAndType_info

If tag value equals CONSTANT_NameAndType in cp_info structure then
it is an interface method reference constant. We can cast the cp_info structure
in following structure.



    struct CONSTANT_NameAndType_info {
        u1 tag;
        u2 name_index;
        u2 descriptor_index;
    };

It is a reference value constant. The short value name_index refers
to a string index in the constant pool and descriptor_index refers to another
string index in the constant pool.

Parsing constant pool

Here we set the values of constant pool list pointers. When we need to retrieve the
actual value we look at the tag and pick the value directly.



    BOOL JavaClass::ParseConstantPool(char* &p)
    {
        constant_pool = new cp_info*[constant_pool_count-1];
        if(constant_pool == NULL) return FALSE;
        for(int i=1;i<constant_pool_count;i++)
        {
            //We set the constant pointer here
            constant_pool[i]=(cp_info*)p;

            //We now calculate constant size. If it is an integer we get size = 5
            int size = GetConstantPoolSize(p);
            p+= size;

            // If constant type is long or double constant pool takes two entries. Second entry
            // is not used by virtual machine but kept NULL to walk constant pool correctly.
            if(constant_pool[i]->tag == CONSTANT_Long || constant_pool[i]->tag == CONSTANT_Double)
            {
                constant_pool[i+1]=NULL;
                i++;
            }
        }
        return TRUE;
    }

Interfaces

In the interfaces field of a class there are interfaces_count
number of short (u2) values. Each value is a reference to a constant pool entry
of type CONSTANT_Class. We parse them and store in our in-memory object-



    BOOL JavaClass::ParseInterfaces(char* &p)
    {
        interfaces = new u2[interfaces_count];
        for(int i=0;i<interfaces_count;i++)
        {
            interfaces[i] = getu2(p); p+=2;
        }

        return TRUE;
    }

Fields

A class may contain zero, one or more fields. The actual number is stored in the
fields_count field. A list of field_info structure followes
this value.



    struct field_info
    {
	    u2 access_flags;
        u2 name_index;
        u2 descriptor_index;
        u2 attributes_count;
        attribute_info* attributes;//[attributes_count];
    };

The short value access_flags describes the allowed field access. Here is
the possible access flags values which is shared also by methods and classes-



    #define ACC_PUBLIC  0x0001
    /*Declared public; may be accessed from outside its package.  */

    #define ACC_PRIVATE  0x0002
    /*Declared private; accessible only within the defining class.  */

    #define ACC_PROTECTED  0x0004
    /*Declared protected; may be accessed within subclasses.  */

    #define ACC_STATIC  0x0008  /*Declared static.  */

    #define ACC_FINAL  0x0010
    /*Declared final; may not be overridden.  */

    #define ACC_SYNCHRONIZED  0x0020
    /*Declared synchronized; invocation is wrapped in a monitor lock.  */

    #define ACC_NATIVE  0x0100
    /*Declared native; implemented in a language other than Java.  */

    #define ACC_ABSTRACT  0x0400
    /*Declared abstract; no implementation is provided.  */

    #define ACC_STRICT  0x0800
    /*Declared strictfp; floating-point mode is FP-strict  */

The name_index and descriptor_index are reference to two
constant pool of type utf8 string. The attributes field defined the
attributes of the field. Attributes are described later. Here is how we parse fields
in a class's raw bytes-



    BOOL JavaClass::ParseFields(char* &p)
    {
        fields = new field_info_ex[fields_count];
        if(fields == NULL) return FALSE;

        for(int i=0;i<fields_count;i++)
        {
            fields[i].pFieldInfoBase = (field_info*)p;

            fields[i].access_flags= getu2(p); p+=2; //access_flags
            fields[i].name_index= getu2(p);p+=2; //
            fields[i].descriptor_index= getu2(p);p+=2; //
            fields[i].attributes_count=getu2(p); p+=2;

            if(fields[i].attributes_count>0)
            {
                //skip attributes - we do not need in simple cases
                for(int a=0;a<fields[i].attributes_count;a++)
                {
	                u2 name_index=getu2(p); p+=2;
	                //printf("Attribute name index = %dn", name_index);
	                u4 len=getu4(p);p+=4;
	                p+=len;
                }
            }
        }
        return TRUE;
    }

Methods

A java class file may contain arbitrary number of methods. The count is stored in
methods_count member of class file structure. As it is a two byte field
the theoritical upper limit is essentially 2^16. Like fields info, method info structure
contains access flags, name index, descriptor index, and attributes.



    struct method_info
    {
	    u2 access_flags;
        u2 name_index;
        u2 descriptor_index;
        u2 attributes_count;
        attribute_info* attributes;//[attributes_count];
    };

Method body (if any) is stored in an attribute named Code- which contains the actual
'Java Byte Code'. Here is how we parse methods in out virtual machine-



    //TODO: Cashe the findings here
    BOOL JavaClass::ParseMethods(char* &p)
    {
	    methods = new method_info_ex[methods_count];

	    if(methods == NULL) return FALSE;

	    for(int i=0;i<methods_count;i++)
	    {
		    //methods[i] = new method_info_ex;
		    methods[i].pMethodInfoBase=(method_info*)p;
		    methods[i].access_flags= getu2(p);	p+=2; //access_flags
		    methods[i].name_index = getu2(p); p+=2; //name_index
		    methods[i].descriptor_index= getu2(p); p+=2; //descriptor_index
		    methods[i].attributes_count=getu2(p); p+=2;

		    CString strName, strDesc;
		    GetStringFromConstPool(methods[i].name_index, strName);
		    GetStringFromConstPool(methods[i].descriptor_index, strDesc);

		    TRACE(_T("Method = %s%sn"),strName, strDesc);

		    TRACE("Method has total %d attributesn",methods[i].attributes_count);

		    methods[i].pCode_attr=NULL;
		    if(methods[i].attributes_count>0)
		    {
			    //skip attributes
			    for(int a=0;a<methods[i].attributes_count;a++)
			    {
				    u2 name_index=getu2(p); p+=2;

				    TRACE("Attribute name index = %dn", name_index);
				    u4 len=getu4(p);p+=4;
				    p+=len;
			    }

			    methods[i].pCode_attr = new Code_attribute;
			    ParseMethodCodeAttribute(i, methods[i].pCode_attr);
		    }
	    }

	    return TRUE;
    }

In case of method structure ( and also same in fields structure) I have used method_info_ex instead
of method_info structure. This extended structure on pointer to pint to raw
method info in the in-memory bytestream of class file. Here with other fields we parse the Code attribute.
The details id given later in attributes section.

Attributes

In most classes attributes takes most of the space in file. Class has attributes, method has attributes,
field has attributes. The raw definition of attribute is like this-



    struct attribute_info
    {
	    u2 attribute_name_index;
        u4 attribute_length;
        u1* info;//[attribute_length];
    };

The attribute_name_index field is the reference index in the constant pool
for string type constant. The attribute_length field is the length of info field-
which is another structure depending on the type/ name of the attribute. An arrtibute can be
a constant value, exception table or code type.

Constant value attribute



    struct ConstantValue_attribute {
	    u2 attribute_name_index;
	    u4 attribute_length;
	    u2 constantvalue_index;
    };

Code Attribute

It is also a method specific attribute. The name of the attribute is hardcoded as 'Code'.
This attribute has maximum stack and maximum local values of the method. The code
field is variable length defined by code_length and it contains the actual
'Java Byte Code'.



    struct Code_attribute {
        u2 attribute_name_index;
        u4 attribute_length;
        u2 max_stack;
        u2 max_locals;
        u4 code_length;
        u1* code;//[code_length];
        u2 exception_table_length;
        Exception_table* exception_table;//[exception_table_length];
        u2 attributes_count;
        attribute_info* attributes;//[attributes_count];
    };

Exception table structure

This structure is used to define the exception table for methods. The exception
table describes the exception handler depending on the program counter value or
offset of byte code. The handler code is also an offset in the byte code.



    struct Exception_table
    {
        u2 start_pc;
        u2 end_pc;
        u2  handler_pc;
        u2  catch_type;
    };

The field catch_type is a reference to a constant pool entry that describes the type
of the exception- for example reference to a class named 'java/lang/Exception'.

Java Instruction Set

Java has more than 200 instructions. The java language file, when compiled, is converted
to a class file that contains intrtuctions as byte codes. If we have a method like this-



	public int mul(int a, int b)
	{
		return a * b;
	}

we will get this method in byte code attribute like this- (java has also assembly like
representation for instructions to represent byte codes in human readable format)



  Code Attribute:
    Stack=2, Locals=3, Args_size=3,  Code Length = 4
    Code:
    0:   iload_1
    1:   iload_2
    2:   imul
    3:   ireturn

Here if we follow the instructions we go like this:



    0: Push (load) the local variable 1 on stack
    1: Push the local variable 2 on stack
    3: Pop two values from stack, do an integer multipucation and push the result
    4: Return the integer value from stack top.

What we need to do in our virtual machine is load classes and follow the instructions
in methods. There are methods to create new objects, to call methods of object. It is also
possible to call native methods from a java method. Please refer to source code
for most other codes (opcodes.h) or Java Virtual Machine Specification for a complete list.

Class heap

In the virtual machine we must maintain a heap where the class definition objects
can be stored. I have implemented it as a separate heap for simplity. In this heap
we load classes from files and store it in the heap. The ClassHeap class
is responsible for maintaining the class heap in meory.



    class ClassHeap
    {
	    CMapStringToPtr m_ClassMap;
	    FilePathManager *pFilePathManager;
    public:
	    ClassHeap(void);
    public:
	    virtual ~ClassHeap(void);
    public:
	    BOOL AddClass(JavaClass* pJavaClass);
	    JavaClass* GetClass(CString strClassName);
	    BOOL LoadClass(CString strClassName, JavaClass *pClass);

    };

We store JavaClass objects pointer in the m_ClassMap member
using the class name as key.

Object heap

Object heap is virtual machine's RAM. All objects are created on object heap and its
reference can be stored in another object or on the stack. Any reference is stored in
an union type storage named Variable. Any field of a class can be
represented using variable object. Anything can be stored in a Variable
object.



    union Variable
    {
        u1 charValue;
        u2 shortValue;
        u4 intValue;
        f4 floatValue;
        LONG_PTR ptrValue;
        Object object;
    };

Object creation on heap is described later in detail.

Virtual Machine Stack

Java instruction set is designed in such a way that it can work with very limited set
of registers. Instead it uses its stack very extensively. The JVM stack element is one item
regardless of - it may be primitive ype or object type. Only long and double
type takes two stack spaces. The 'Execution Engine' maintains the JVM stack. For example when the execution
engine executes iadd instruction it pops two numeric values from the stack and
add the values and pushes the result on the stack. The virtual machine has empty stack initially and
the stack is populated after the initial thread and the initial method is started for execution. Each
method instruction is allowed to operate on stack within a limited boundary of the stack. The compiler
sets the upper limit (top) as max_stack field of each methods Code attribute. The
lower limit is the top+1 stack position of previous method. This boundary of stack is named as Stack Frame
of that method.

The Stack Frame

As we mentioned each methods boundary in the JVM stack is known as 'Stack Frame'. Each stack frame reserves
positions for the parameters and local variables of that method. If it is not a static method the first parameter
is the object reference ( the this parameter) of type of the class of the method. The Execution Engine
operates between the frame and when the method returns a value it pops every element from the current frame including
this reference and pushes the return value (if method is not void return type) value
on the frame of previous frames top. To keep the implementation simple I used slightly different methodology. I used
stack of stack. Each frame is stack type and it is pushed on the JVM stack. The stack grows on method invocation
and shrinks on method return.

Local Variables

In a stack frame local variables takes positions from zero to max_locals - 1
positions or less. If the method is not static the object takes the position zero and other
locals follow it. Local variables are accessed using putfield and getfield
instructions.

Native method stack

Unlike virtual machine stack, native methods stack is not maintained by JVM. It is
maintained by the native system. Actually while a native method is being executed the
virtual machine component that was managing the java thread waits until the native
method completes and returns.

Runtime Environment

Each java thread has its own frame stack. All java threads in a process share common class heap
and object heap. This things are bundled together in a RuntimeEnvironment object and
carried among the execution engine components.



 class RuntimeEnvironment
 {
	public:
		Frame *pFrameStack;
		ClassHeap *pClassHeap;
		ObjectHeap *pObjectHeap;
 };

Execution Unit

This is the main module of the JVM. It interprates the instructons. Advanced JVMs may
use JIT compiler to convert java instructions into native instruction. But I did not do
that because of the complexity of the JIT compiler.
When a JVM starts it usually takes initial class name as parameter. Our JVM also takes
class name as a parameter. The class heap is then requested to load that class. Then the
JVM finds its main method (it can be any name like Entry in case of my first implementation),
creates the initial stack frame and requests the execution engine to start execution. The
heart of the Execution Unit is the Execute method. Here is the skeleton:



	u4 ExecutionEngine::Execute(Frame* pFrameStack)
	{
		ASSERT(pFrameStack);
		ASSERT(pFrame);

		Frame* pFrame=&pFrameStack[0];

		DbgPrint(_T("Current Frame %ld Stack start at %ldn"),
				pFrame-Frame::pBaseFrame, 	pFrame->stack-Frame::pOpStack );

		if(pFrame->pMethod->access_flags & ACC_NATIVE)
		{
			ExecuteNativeMethod(pFrame);
			return 0;
		}

		u1 *bc=pFrame->pMethod->pCode_attr->code + pFrame->pc;	

		i4 error=0;
		JavaClass *pClass = pFrame->pClass;

		CString strMethod;
		pClass->GetStringFromConstPool(pFrame->pMethod->name_index, strMethod);

		DbgPrint(_T("Execute At Class %s Method %s n"), pClass->GetName(), strMethod);
		i4 index=0;
		i8 longVal;
		while(1)
		{
			switch(bc[pFrame->pc])
			{
			case nop: //Do nothing
				pFrame->pc++;
				break;

			//Integer Arithmetic
			case iadd: //96 : Pop two int values from stack add them and push result
				pFrame->stack[pFrame->sp-1].intValue=pFrame->stack[pFrame->sp-1].intValue
						+ pFrame->stack[pFrame->sp].intValue;
				pFrame->sp--;
				pFrame->pc++;
				break;

			//Method return instructions
			case ireturn: //172 (0xac) : Pop everything from stack and push return value (int)
				pFrame->stack[0].intValue=pFrame->stack[pFrame->sp].intValue;
				return ireturn; // here we break the while loop
				break;

			// Method invokation Instructions

			// Here actually we do a recursive call to Execute
			// to keep things simple- after the java method return we
			// also return from Execute- some memory waste for simplicity
			case invokevirtual: //182: Invoke a virtual method.
				// The object reference and parameters are on stack by java instructions
				ExecuteInvoke(pFrame, invokevirtual);
				pFrame->pc+=3;
				break;
			}

			//Instructions that deal with objects

			case _new:// 187 (0xbb)
				ExecuteNew(pFrame);
				pFrame->pc+=3;
				break;
			case putfield: //181 (0xb5): Set field in object from stack top
				PutField(pFrame);
				pFrame->sp-=2;
				pFrame->pc+=3;
				break;

			case getfield: //180 (0xb4) Fetch field from object and push on stack
				GetField(pFrame);
				pFrame->pc+=3;
				break;
		}
		return 0;
	}

Creating object on Object Heap

An object is usually created by JVM when a new or newarray or
multinewarray instruction is executed. When a virtual machine creates an object it
first calculate the size of the object. To calculate the object size we we first take the
fields_count value in the class structure then we add its super classes
fields_count value with it then we add super classes super classes fields_count
and so on recursively until we reach the final base class java.lang.Object. This way we
calculate total fields of the object and add one with it that holds the class pointer
in the ClassHeap. Now we multiply the sizeof(Variable) to the count and
get number of bytes required for the object. We now allocate the required bytes and
return the pointer to that memory in a Variable object on the stack top. Here is
the implementation.



	int ExecutionEngine::ExecuteNew(Frame* pFrame)
	{
		pFrame->sp++;
		u1 *bc=pFrame->pMethod->pCode_attr->code;
		u2 index=getu2(&bc[pFrame->pc+1]);
		if(!pFrame->pClass->CreateObject(index, this->pObjectHeap, pFrame->stack[pFrame->sp].object))
			return -1;
		return 0;
	}

	BOOL JavaClass::CreateObject(u2 index, ObjectHeap *pObjectHeap, Object& object)
	{
		char *cp=(char*)this->constant_pool[index];
		ASSERT(cp[0] == CONSTANT_Class);
		ASSERT(pObjectHeap);
		if(cp[0] != CONSTANT_Class)
			return FALSE;

		u2 name_index=getu2(&cp[1]);
		CString strClassName;
		if(!this->GetStringFromConstPool(name_index, strClassName))
			return FALSE;				

		JavaClass *pNewClass=this->m_pClassHeap->GetClass(strClassName);
		if(pNewClass == NULL) return FALSE;
		object=pObjectHeap->CreateObject(pNewClass);
		return TRUE;
	}

Setting or getting value in object

The putfield instruction is used to set a value (from stack) of a field and
the getfield instruction is used to load a variables value on the
stack. When the execution engine needs to execute a getfield
instruction it pops two values from the stack. One value is the object pointer
another is field position (zero based index). Here is my implementation:



	// Gets value or reference from stack and set in object
	void ExecutionEngine::PutField(Frame* pFrameStack)
	{
		u2 nIndex = getu2(&pFrameStack[0].pMethod->pCode_attr->code[pFrameStack[0].pc+1]);
		Variable obj=pFrameStack[0].stack[pFrameStack[0].sp-1];
		Variable value=pFrameStack[0].stack[pFrameStack[0].sp];
		Variable *pVarList=this->pObjectHeap->GetObjectPointer(obj.object);
		pVarList[nIndex+1]=value;
	}

	//Gets the value from variable and push on stack
	void ExecutionEngine::GetField(Frame* pFrame)
	{
		//TODO: Bug check for long and double
		u2 nIndex = getu2(&pFrame->pMethod->pCode_attr->code[pFrame->pc+1]);
		Variable obj=pFrame->stack[pFrame->sp];
		Variable *pVarList=this->pObjectHeap->GetObjectPointer(obj.object);
		pFrame->stack[pFrame->sp]=pVarList[nIndex+1];
	}

Invoking method

When execution engine requires a method invocation it needs to creates a new 'Stack Frame' and
the pc or Program Counter is set to the first byte of the methods byte code. Before that,
the execution engine must save the current methods pc so that it can come back to
resume method execution after the callee method returns. Here is our implementation. Please note how
we handle static method invocation - simply we do not have the this reference on our stack.



	void ExecutionEngine::ExecuteInvoke(Frame* pFrameStack, u2 type)
	{
		u2 mi=getu2(&pFrameStack[0].pMethod->pCode_attr->code[pFrameStack[0].pc+1]);
		Variable objectRef = pFrameStack[0].stack[pFrameStack[0].sp];
		char *pConstPool = (char *)pFrameStack[0].pClass->constant_pool[mi];

		ASSERT(pConstPool[0] == CONSTANT_Methodref);

		u2 classIndex = getu2(&pConstPool[1]);
		u2 nameAndTypeIndex = getu2(&pConstPool[3]);

		//get class at pool index
		pConstPool = (char *)pFrameStack[0].pClass->constant_pool[classIndex];

		ASSERT(pConstPool[0] == CONSTANT_Class);

		u2 ni=getu2(&pConstPool[1]);

		CString strClassName;
		pFrameStack[0].pClass->GetStringFromConstPool(ni, strClassName);

		JavaClass *pClass=pClassHeap->GetClass(strClassName);
		pConstPool = (char *)pFrameStack[0].pClass->constant_pool[nameAndTypeIndex];

		ASSERT(pConstPool[0] == CONSTANT_NameAndType);

		method_info_ex method;
		method.name_index = getu2(&pConstPool[1]);
		method.descriptor_index = getu2(&pConstPool[3]);
		method.access_flags = 0; // set later

		CString strName, strDesc;
		pFrameStack[0].pClass->GetStringFromConstPool(method.name_index, strName);
		pFrameStack[0].pClass->GetStringFromConstPool(method.descriptor_index, strDesc);

		JavaClass *pVirtualClass=pClass;
		int nIndex=pClass->GetMethodIndex(strName, strDesc, pVirtualClass);

		memset(&pFrameStack[1],0,sizeof(pFrameStack[1]));
		pFrameStack[1].pMethod = &pClass->methods[nIndex];

		method.access_flags = getu2((char *)pFrameStack[1].pMethod);
		if( ACC_SUPER & method.access_flags)
		{
			pFrameStack[1].pClass = pVirtualClass->GetSuperClass();
		}
		else
		{
			pFrameStack[1].pClass=pVirtualClass;
		}

		int params=GetMethodParametersStackCount(strDesc)+1;

		//invokestatic - there is no this pointer
		if(type==invokestatic) params--;
		// else invokevirtual has this pointer

		int nDiscardStack =params;
		if(pFrameStack[1].pMethod->access_flags & ACC_NATIVE)
		{
		}
		else
		{
			nDiscardStack+=pFrameStack[1].pMethod->pCode_attr->max_locals;
		}

		pFrameStack[1].stack =
			&Frame::pOpStack[pFrameStack->stack-Frame::pOpStack+pFrameStack[0].sp-params+1];
		pFrameStack[1].sp=nDiscardStack-1;

		this->Execute(&pFrameStack[1]);

		//if returns then get on stack
		if(strDesc.Find(_T(")V")) < 0)
		{
			nDiscardStack--;
		}
		//Before we return to caller make the stack of caller right
		pFrameStack[0].sp-=nDiscardStack;
	}

Invoking native method

In a java class a method may be marked as native-



	public class Test
	{
		public native void Print(string message);
	}

In byte code ACC_NATIVE is set in the access_flags field of the
method_info structure. We decide here like this:



	if(pFrame->pMethod->access_flags & ACC_NATIVE)
	{
		ExecuteNativeMethod(pFrame);
		return 0;
	}

Each native method usually has a fixed predefined prototype. Here is the type definitation for our
JVM:



	typedef Variable (*pNativeMethod)(RuntimeEnvironment* pRuntimeEnvironment);

Here is how we handle native methods in the JVM:



	u4 ExecutionEngine::ExecuteNativeMethod(Frame* pFrameStack)
	{
		ASSERT(pFrameStack);

		ASSERT(pFrame->pMethod->access_flags & ACC_NATIVE);
		Frame* pFrame=&pFrameStack[0];

		JavaClass *pClass = pFrame->pClass;
		CString strClassName, strMethod, strDesc, strSignature;
		strClassName=pClass->GetName();
		pClass->GetStringFromConstPool(pFrame->pMethod->name_index, strMethod);
		pClass->GetStringFromConstPool(pFrame->pMethod->descriptor_index, strDesc);
		DbgPrint(_T("Execute At Class %s Method %s%s  n"),strClassName , strMethod, strDesc);
		strSignature=strClassName+_T("@")+strMethod+strDesc;
		pNativeMethod pNativeMethod=GetNativeMethod(strSignature);
		RuntimeEnvironment rte;
		rte.pFrameStack=pFrameStack;
		rte.pClassHeap= pClassHeap;
		rte.pObjectHeap= pObjectHeap;

		if(pNativeMethod == NULL)
		{
			// what should I do here??
			// System Panic??
			ASSERT(FALSE);
			return -1;
		}
		else
		{
			//Here we go native
			Variable retVal = pNativeMethod(&rte);

			//if returns then get on stack
			if(strDesc.Find(_T(")V")) < 0)
			{
				pFrame->stack[0]=retVal;
			}
		}
		return 0;
	}

Here is the implementation of Print method of Test class:



	//Signature: _T("Test@Print(Ljava/lang/String;)V")
 	Variable Print(RuntimeEnvironment* pRuntimeEnvironment)
	{
		Variable returnVal;
		Frame *pFrame=&pRuntimeEnvironment->pFrameStack[0];
		Object object=pFrame->stack[pFrame->sp].object;
		Variable *pVar=pRuntimeEnvironment->pObjectHeap->GetObjectPointer(object);
		if(pVar)
		{
			CString *pString = (CString *)pVar[1].ptrValue;
			if(pString)	wprintf(_T("%s"),*pString);
		}

		returnVal.intValue=0;
		return returnVal;
	}

It is the native methods responsibility to correctly operate on stack. The java instruction is
here out of scope. Everything is running on real machine here.
So, here we pop the string type object reference from stack, convert it to CString
object and do our native printing to console. This way we can handle any native operation like
creating new window, drawing or do network operation. All these things are done in the
implementation of Morpheus project.

The Garbage Collector

Java language does not have memory release mechanism. So the JVM must take the responsibility to release
memory when some objects are out of scope no longer required or referenced by the application. To do this
the JVM may take a number of strategy like reference count, mark and sweep etc. I used mark and sweep method
because of its simplicily and accuracy. We start from the stack. We mark each object that is being referenced
from the stack references. Then we mark all the objects that is being referenced by the marked objects and so
on recursively. After the mark operation we know which objects are connected and which are out of scope. Then
we take each object one by one and release its memory from heap. Before that we must call the finalize
method of that object to do any cleanup required by the object itself programetically.

Conclusion

Thats all about to say for now about how we can implement a simple JVM. The JVM I present here is very
limited implementation - though most of the java instructions are supported. It lacks heavily
for library and native interface. Please look at the seminar
presentation downloadable above for a visual description of JVM and how instructions are executed in
a JVM. Full screen view of the presentation is best viewed with spacebar to go to next slide.
I am busy with the
implementation of Morpheus project at my free time
and wish to come with that as well as with a new JVM with a new Window subsystem implementation having
Windows Vista and Office 2007 look and feel (ok, ok, thats not technically a big deal but good to have
for user interface degign) and oh yes also with a .NET Virtual Execution System with Morpheus for .NET
support also. The .NET VES is similar except the complex onfile structure is really painfull when I
decode them. All these things I do because I love to do- so I do not try to make a zero bug system.
I leave when it seems to work for 'Hello World ++' applications.

This article is also published in Codeproject. Click here to view.

Kaza Coralina

2008-03-29T06:20:00.000-07:00

We had our annual picnic (codenamed "kaza coralina") this year at the St. Martin island. A huge surge of techies in a coral island must have distorted local space time structure. But whatever distortion it was, it must have been positive for humans. We had a grand time!

Kaza Coralina

2008-01-22T04:38:00.000-08:00

Coral hunt in the St. Martin Island for all the long "party-less work, work and work" suffering Kazites. At last the fun is back! Big decisions have to be made (should we have bbq by the sea or take a cook with us to cook us biriyani?) and big sacrifices have to be made (should I miss the beautiful traffic jams in Dhaka?).

Lets go, lets go, lets goa!

2007-09-22T04:21:00.000-07:00

With our anniversary party “Odyssey” over we are having a post party depression. Life should have been just an endless stream of back to back parties!

Anyway, Odyssey was a supreme success. Tweleve days of non-stop furti! Check out some the places we’ve been to on the google map here. But before you do that here are a few interesting but random trivia about Goa:

1. Goa became independent from Portugal in 1961! So Goa has been a part of Portugal from 1510 to 1961!

2. 40,000 Indian troops walked in to Goa on "Operation Vijay" to make Goa independent.

3. Goa became a full blown state as late as 1987. It was a "union territory" before that, since it never wanted to part of Maha Rashtra.

4. Mangoes of Goa can rival that of Bangladesh and goans have passions about mango almost on the same level as ours.

Go Goa

2007-07-06T05:11:00.000-07:00

There is one high priority thread running at KAZ now. Dev rooms to hallways to rec room - just a single thread. The thread hangs once in a while to stop everything. Not a masterpiece in design but none of the superstar developers seems to mind!

The thread has just one constant “Goa”!

This year’s anniversary party at KAZ will be at Goa. The party is codenamed “Odyssey”. A lot of planning is going on to make odyssey a success. There must be something for everyone (since anniversary party also means friends and families) and there must be enough fun to talk about for a whole year (until the next party at least!). A lot of pressure on the odyssey team.

Oscar Wilde’s last words were reputedly: “This wallpaper is terrible – one of us have to go”. I know there is not even the thinnest of relevance for this quote with this post, but somehow I feel it captures the feeling of this trip very much!

So Go Goa …

Switching on Silverlight

2007-07-03T08:30:00.000-07:00

“Web is approaching the desktop” – Wahid Bhai said while demonstrating the new Flex project at KAZ. Flex is Flash but on steroids... well to be truthful Flex is Flash with libraries and an easy programming model and the nicest of all - a good eclipse based IDE.

Microsoft has of course an answer to Flex - The Silverlight which used to be known as WPF/e for a while. In Microsoft's wording:

"Silverlight is Microsoft’s latest technology to design interactive web client with truly object oriented language C# with full support of VB .NET and other .NET citizens. Microsoft® Silverlight™ is a cross-browser, cross-platform plug-in for delivering the next generation of .NET based media experiences and rich interactive applications for the Web ... Silverlight offers a flexible programming model that supports AJAX, VB, C#, Python, and Ruby, and integrates with existing Web applications. Silverlight supports video to all major browsers running on the Mac OS or Windows.... " (the babble continues promising cure for cancer, food for Sudan and even the impossible - patriotism for the Bangladeshi middle class!)

Back on Earth, we the "Psycho group" at KAZ had a week of free time in between projects. So in the time honored way at KAZ we decided to do a spacer project to try out silverlight in all its Alpha glory and MS’s super hype! We decided to make a webtop with silverlight that would show an abstracted backend filesystem exposed by WCF.

This post is about our pains and joys during the project. Not gifted with great writing skills (apart from the coding kind) I will try putting down disperate items that we learnt or I felt like telling about our project.

First principle
Starting from Silverlight 1.1 the managed code is supported at client side. We decided to be very strict in this project to use only managed code for programming- no JavaScript. Like all principles this soon turned out to be a pain in a not so polite place :)

Installing Silverlight
To develop with Silverlight 1.1 you need Visual Studio 2008 (code name Orcas). While writing this downloadable beta version is available from Microsoft site. You also need Silverlight 1.1 plug-in distribution – alpha is available while writing this. Though not necessary the Silverlight 1.1 SDK is highly recommended. The SDK includes controls, samples, documents which may be useful to start. Please note that the Silverlight plug-in is required on any client from where the site is viewed.

Controls that comes from Boss

None!

Well not exactly true, but close enough. Silverlight 1.1 alpha distribution comes with a very limited set of controls. It has controls like rectangle, ellipse and label, canvas. It does not include button, edit box, scroll bar or any other advanced control. The SDK includes some controls like scrollbars.

Our Architecture

With no major controls available and no infrastructure for a shell, we soon realized that we need a petzold like approach to the project. We actually need to create a windowing system and the bare basics of message management.

Our final designe came out with 3 layers. Top layer is the application layer where user applications run. Middle layer is kernel which controls the events and communication between applications. It also provides a set of API for application developers. The lowest layer is an abstraction layer to communicate with the web server.

The system provides API’s for application developers for the platform while hiding the http calls – making the application development similar to desktop application development. Web call abstraction layer does that for user application.

The Kernel

The controller behind the scene controls form events, focus of controls, controls and windows to common file operations. The kernel has four main parts:
•          Messaging System and Focus Manager
•          Window Manager
•          Process Manager
•          File system Driver
•          Resource Manager

Messaging System and Focus Manager

An event first comes to this manager and depending on the type routed to controls. If the user clicks on a control the focus manager updates the focus of controls. It keeps track of current on focus control. If it finds a change in focus it send OnLostFocus call to old control and OnSetFocus call to new focused control. With this exception most messages are routed to the focused control on arrival.

Window Manager

The window manager keeps track of each window that is created on the system. At any time window manager provides the list of windows currently available in the system. A utility application like TaskManager or TaskBar can use the list for display and control the windows. In our case the TaskBar buttons are created from the list and user can control minimize or restore operation from the TaskBar application. To keep track of the windows the window manager uses an internal generic Window list. When a new window is created the window is registered with window manager and when a window is disposed the window is unregistered.

Process Manager

The SilverlightDesktop applications that are created by implementing the IApplication interface in the main class are managed by the process manager. The process manager exposes a service to create a new process. It accepts class name as its first parameter and other parameters are passed through a Parameter object that can contain strings. On success the process manager returns a Instance object that can identify the process. Simplified version of Instance class is like this –

public class Instance
{
      public int Handle;
      public int ParentHandle;
      public string Name;
}

The returned interface object can uniquely identify the process and it is required to handle the process.

Designing a new control

ControlBase class can be extended to design a custom control. The control may have a xaml also. The ControlBase getter ResourceName of type string should be overirden to specify the name of the xaml resource in the assembly. It is also possible to set the assembly of the control. The constructor of ControlBase class iterates through each resource and look for the specified resource to get the right xaml resource. Same technique is used in the Silverlight SDK. For example we want to have a icon control that has a image and text. Our xampl file would be similar to this:

<Canvas xmlns="http://schemas.microsoft.com/client/2007"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Width="32"
        Height="50" x:Name="_container"
        >
<Canvas x:Name="_icon" Width="32" Height="32" Canvas.Left="0" Canvas.Top="0"/>
<TextBlock x:Name="_name" Width="80" Height="15" Canvas.Left="-24" Canvas.Top="32" />
</Canvas>

We used a Canvas for icon, a TextBlock for label and a container canvas to hold them both.
And our code back for the control would be:

public class Icon : ControlBase
{
        Canvas icon;
        TextBlock text;
        Canvas container;
        protected override void OnInitialized()
        {
            icon = actualControl.FindName("_icon") as Canvas;
            text = actualControl.FindName("_name") as TextBlock;
            container = actualControl.FindName("_container") as Canvas;
        }
        protected override string ResourceName
        {
            get { return "Icon.xaml"; }
        }
}

Now if we add some getter/setter we get the icon control ready to be used.

The Window

Window is a customized control- but is different from others. It uses mouse events to implement feature like drag/ drop, has a title bar and sizing buttons for minimize to system taskbar, maximize to cover full user desktop area or close button to close and dispose the control from the system.

The pilgrimage to the land of mangoes

2007-06-17T04:20:00.000-07:00

I belong here. I was designed for this. This was my intended use. This was supposed to be my platform. This is my OS.

This is of course the land of mangoes – the great Chapai Nawabgonj.

Last Friday few of the mango crazed KAZ members (I among them) went out for the ultimate trip to Chapai. Nothing was strong enough to stop us - the hardship of waking up at the ungodly hour of five in the morning (a personal record for one guy at least), the unthinkable scenario of being away from a computer for two whole days… nothing! We were unstoppable, we were out to win and we were out to meet our love.

Why are mangoes so good? Why do even the most timid of the human race – the techies - become the gladiators when it comes to mangoes? Is there any answer to these questions?

Some things in this world are just without equations – this I am sure is one of them.

Patterns in workspace design

2007-06-12T04:53:00.000-07:00

With the designer workspace project in progress at KAZ, I was revisiting the principles for achieving the perfect design of workspaces. These patterns as they are formally called were the guiding light when we were planning the Nirvana (our office space).

Software has patterns. Patterns are tried and tested ways of architecting systems that just work perfectly for a broad set of similar problems. Made famous by the gang of four (GOF) in the early 90s when they published their book Desgin patterns

Interestingly the idea of patterns comes not from software but from architecture. We all have felt that some buildings or houses just feels more comfortable from others. There are some places where an adda is always a good adda. The person who put this into concrete form was Christopher Alexander in his book The Timeless Way of Building.

Since I can’t possibly describe this better than the great guy himself, let me quote from the book itself:

“There is one timeless way of building. It is a thousand years old, and the same today as it has ever been. The great traditional buildings of the past, the villages and tents and temples in which man feels at home, have always been made by people who were very close to the center of this way. It is not possible to make great buildings, or great towns, beautiful places, places where you feel yourself, places where you feel alive, except by following this way. And, as you will see, this way will lead anyone who looks for it to buildings which are themselves as ancient in their form, as the trees and hills, and as our faces are. ”

As the quote sort of hints, the book was more philosophy than practical hints about the patterns. The next book was the practitioners handbook for the patterns – the analogy of the GOF book in architecture: A Pattern Language: Towns, Buildings, Construction. One of my all time favorites, this book is worth reading just for your soul.

Before being carried away let me pin down a few patterns that is very relevant to workspaces and that we are definitely consulting during the planning. All of the following are stolen from the great book.

Note that the numbers represent the pattern number used in the book (there were 253 catalogued). You can get a whole list of patterns here.

134 Zen View

If there is a beautiful view, don't spoil it by building huge windows that gape incessantly at it. Instead, put the windows which look onto the view at places of transition- along paths, in hallways, in entry ways, on stairs, between rooms.

135 Tapestry of Light and Dark

Create alternating areas of light and dark throughout the building, in such a way that people naturally walk towards the light, whenever they are going to important places: seats, entrances, stairs, passages, places of special beauty, and make other areas darker, to increase the contrast.

146. Flexible Office Space

Lay out the office space as wings of open space, with free standing columns around their edges, so they define half-private and common spaces opening into one another. Set down enough columns so that people can fill them in over the years, in many different ways- but always in a semipermanent fashion.

152 Half-Private Office

Avoid closed off, separate, or private offices. make every workroom, whether it is for a group of two or three people or for one person, half-open to the other workgroups and the world immediately beyond it. At the front, just inside the door, make comfortable sitting space, with the actual workspace(s) away from the door, and further back.

183 Workspace Enclosures

Build each workspace an area of at least 60 square feet. Build walls and windows round each workspace to such an extent that their total area (counting windows at one-half) is 50 to 75 per cent of the total enclosure that would be there if all four walls around the 60 square feet were solid. Let the front of the workspace be open for at least 8 feet in front, always into a larger space. Place the desk so that the person working at it has a view out either to the front or to the side. If there are other people working nearby, arrange the enclosure so that the person has a sense of connection to two or three others; but never put more than eighth workspaces with view or earshot of one another.

185 Sitting Circle

Place each sitting space in a position which is protected not cut by paths or movement, roughly circular, made so that the room itself helps to suggest the circle- not too strongly- with paths and activities around it, so that people naturally gravitate toward the chairs and cushions loosely in the circle, and have a few too many.

250 Warm Colours

Choose surface colours which, together with the colour of the natural light, reflected light, and artificial lights, create a warm light in the rooms.

252 Pools of Light

Place the lights low, and apart, to form individual pools of light which encompass chairs and tables like bubbles to reinforce the social character of the spaces which they form. Remember that you can't have pools of light without the darker places in between.

A designer’s work space

2007-06-10T06:35:00.000-07:00

working as a graphics designer for quite a long time now but when Wahid (CTO of KAZ software) told me and Maq (my designer buddy) to do an interior design for the new design team room, the exact sound came through my through was “Glip’. I have some rough idea about interior designers but no clue about their actual work. But Wahid was pretty serious about this project. His exact words were “You designers act like you are from a different planet. Like you are some different species. A better one you claim. Well … prove it. I want people to walk into your room and say … WOW”. So, after spending some quality time in our recreation room, me and Maq decided that we really should start planning.

The theme

We were given an 11.3 by 10 feet room. Now all we need to do is visualize the WOW part. The rooms should imply that it’s the designer’s room. Only the dumbest should walk into the room and wonder if this is the designing section. We want the room as comfy as possible. To us, that means a lot of free space. Which is our challenge number two as the room is not big enough to fit all our ideas that are yet to come. Challenge number one is to decorate without giving it a cheep Chinese restaurant look.

The budget

Wahid said don’t think of the budget. Just visualize whatever you want to do with the room. I don’t mind. I have scissors.

So what dose a designer needs to do his things

On my first day at work in here, Wahid asked what I need to setup my workstation. Before I can answer that, Jewel from Java team jumped in and said “That’s easy. All a designer need is a big fat TV set”. I guess he was referring to my 19 inch monitor. Yes what would we do without it? Plus a sketch table would be nice. Through in a couch and two Bose speakers and .. well this list will never end so let just stick with the desktop and the sketch board for now.

The visual presentations

After some struggle we came up with some visual presentations. The very first sketch looks like this

And the layout diagram-

With a little help of Adobe Photoshop -

Here is a dimmed version -

Ok we do agree it looks pretty common so where is the struggling part? First let us explain our ideas and restrains.

The room has couple of windows that really don’t go with our theme. Plus Maq and I decided to have a rather dimmed room. So we decided to put a shade on those windows. But not with those dull, boring ones. We want something visually more pleasant. So we though it would be great to find a shade with a great painting on it. Wahid said this would be almost impossible. Let’s see.

We want a double plated glass frame for a wall painting. This should have an irregular shape and an easy mechanism to install the painting. We want to change it frequently. A light source mounted on top will illuminate the artwork. One of our shelves will be made out of a tree with its original shape preserved. An aquarium for out pet turtles will be placed in the other triangular shelf. Originally, Maq wants to have some snakes but that might be too disturbing for some people so we settle with turtles. Well these are our startup ideas.

So where is the struggling part again? Well I guess that's hidden in the implementation phase.

Oh … another great idea is to blog about this project on step by step progress so you can expect to see more updates on this soon.