Welcome to GlobalLogic Blogs » Technology

JSMS Configuration on Various Platforms

farida.khan — Fri, 27 Jan 2012 12:13:48 +0000

Introduction

Its been a tough job configuring this API on various platforms for the project. There was no striaght and simple way I could get from even the Internet.
So writing down my own experience I have followed to configure this SMS API on Windows and Linux Platforms. Hope it would be useful for others who would
need this API to be configured in their projects.

JSMS is a Java API for sending and receiving Short Messages (SMS) and Multimedia Messages (MMS). The API supports a wide range of communication protocols.

1. Supported Protocols

Receiving and Sending of messages by using any GSM Device capable of sending SMS messages and also by using the most common SMSC communication protocols:

GSM (GSM devices)
UCP (Universal Computing Protocol)
CIMD2 (Computer Interface to Message Distribution)
SMPP (Short Message Peer-to-Peer)
TAP/IXO (Telocator Alphanumeric Protocol)
MM1 (MMS over GPRS)
MM7 (MMS exchange using SOAP messages over http(s))

2. Where to get jSMS?

You can download a copy of the jSMS-API from http:// www.objectxp.com /. The API shipped either as a gzipped tar-archive (UTechnix users) or as ZIP-file (Windows users).

Configuration on Windows Platform

Pre-assumption: Java is installed on the Windows machine and JAVA_HOME is set.

Follow the below steps:
1. Unzip the downloaded file to your target directory (using a tool like WinZIP)

2. Copy javax.comm.properties file in the directory jSMS-\lib to the following locations on windows:
JAVA_HOME\jre\lib
JAVA_HOME\jdk\jre\lib

3. Make the necessary changes in the jsms.conf file which is at path jSMS-\bin

4. Copy the license properties that you received via email into the jsms.conf file

5. Change the property connector.serial.port to contain the port that you have the GSM device connected to (e.g. COM1).

6. Copy the following DLL files:

win32com.dll from path jSMS-\lib to c:\WINDOWS\system32 folder
jdunxp.dll from path jSMS-\lib to c:\WINDOWS\system32 folder

Now you are ready to send the SMS from your machine through the connected GSM device.

Testing on Windows:

1. Change directory to jSMS-\bin and double click the sms.bat file

2. Give the recipient’s mobile number

3. Specify the message to be sent

4. The message should be sent to the recipient

If received you have done it!

Configuration on Linux Platform

Pre-assumption: Java is installed on the Linux machine and JAVA_HOME is set.

1. Download the java communications API for linux platform from the URL: http://www.oracle.com/technetwork/java/index-jsp-141752.html

2. unpack the download zip file using the command:

unzip comm3.0_linux.zip

3. Install the library using copy command:

cp commapi/lib/libLinuxSerialParallel.so

JAVA_HOME/jre/lib/ext/libLinuxSerialParallel.so

4. Install the comm.jar using the copy command:

cp commapi/jar/comm.jar

JAVA_HOME/jre/lib/ext/comm.jar

5. Install the javax.comm.properties using the copy command as below:

cp commapi/docs/javax.comm.properties

JAVA_HOME/jre/lib/javax.comm.properties

6. Make the necessary changes in the jsms.conf file which is at path jSMS-\bin

A. Copy the license properties that you received via email into the jsms.conf file.

B. Change the property connector.serial.port to contain the port that you have the GSM device connected to (e.g. dev/ttsy1).

Now you are ready to send the SMS from your machine through the connected GSM device.

Testing on Linux:

1. Open the terminal navigate to the folder jSMS-\bin

2. Execute the sms.sh file using the below command:

sh ./sms.sh

3. Give the recipient’s mobile number.

4. Specify the message to be sent.

5. The message should be sent to the recipient

If received you have done it!

C# Fundamentals - Commonly compared concepts (differences)

Bhala Ganpatye — Sun, 22 Jan 2012 17:21:47 +0000

I have been asked many time questions like

When should I use an abstract class and when I should use an interface?
What is difference between delegate and event?

Although people know few points of differences, it’s worth to consolidate as many as differences as we can. So I am trying to provide most of the points that can not only compares various concepts, but also helps developers understand concepts better way.

Override vs. Overload

Overriding	Overloading
The argument list must exactly match as that of the overridden method	Overloaded methods must change the argument list (type and/or numbers of arguments)
The return type must exactly match as that of the overridden method	Overloaded methods can change the return type
The access level can be same or less restrictive than that of the overridden method. (more restrictive not allowed)	Overloaded methods can change the access modifier. Methods can have difference access modifiers
The overriding method must not throw new or broader checked exceptions than those declared by the overridden method. But it can throw narrower or fewer exceptions. Just because an overridden method “takes risks” doesn’t mean that the overriding subclass’ exception takes the same risks. Bottom line: An overriding method doesn’t have to declare any exceptions that it will never throw, regardless of what the overridden method declares.	Overloaded methods can declare new or broader checked exceptions.
You cannot override a method marked as sealed	You cannot overload a method just by changing only return type
You can override method in derived class only	A method can be overloaded in the same class or in a subclass.
You can override only non-static method	You can overload both static and non-static method
Runtime polymorphism	Compile time polymorphism
Overriding also applies to property and event	Overloading also applies to operator

Interface vs. Abstract Class

Feature	Interface	Abstract class
Inheritance in class	A class may inherit several interfaces.	A class may inherit only one abstract class.
Inheritance in structure	An Interface can be inherited by structures.	An abstract class cannot be inherited by structures
Inheritance to self	Interface can inherit only interface(s)	An abstract class may inherit one abstract class and/or multiple interfaces
Default implementation	An interface cannot provide any code, just the signature. Implicit Abstract	An abstract class can provide complete, default code and/or just the details that have to be overridden.
Access Modifiers	An interface cannot have access modifiers for members. everything is assumed as public	An abstract class can contain access modifiers for the methods, properties
Adding functionality	Changing member or adding new member breaks the classes implementing interface. So all subclasses must change implementation	If we add a new method to an abstract class then we have the option of providing default implementation and therefore all the existing code might work properly.
Allowed Members	properties, methods, events	properties, methods, events, fields, constants, delegates
Constructors	An Interface cannot contain constructors or destructors.	An abstract class can contain constructors or destructors.
	Contract	Common behavior

Value Type vs. Reference Type

Value Type / Struct	Reference Type
Variables that are based on value types directly contain values. Assigning one value type variable to another copies the contained value.	The assignment of reference type variables, copies a reference to the object but not the object itself.
Value types derive from System.ValueType, which derives from System.Object	Reference types are derived from System.Object
Value types are sealed. you cannot derive a new type from a value type. However, like reference types, structs can implement interfaces.	You can derive a new type from another reference type or class
A value type cannot contain the null value. However, the nullable types feature does allow for values types to be assigned to null.	Reference types can be null
Each value type has an implicit default constructor that initializes the default value of that type.	Explicit constructor need to be called to hold data
Value type variables directly contain their values which means that the memory is allocated inline in whatever context the variable is declared.	The memory is allocated on the managed heap. the variable holds only a reference to the location of the object
There is no separate heap allocation or garbage collection overhead for value-type variables.	GC plays important role in memory clean up

Delegate vs. Interface

Delegate - Usage	Interface - Usage
An eventing design pattern is used.	The class using the interface will want to cast that interface to other interface or class types.
It is desirable to encapsulate a static method.	The method being implemented is linked to the type or identity of the class: for example, comparison methods.
The caller has no need to access other properties, methods, or interfaces on the object implementing the method.	There is a group of related methods that may be called.
Easy composition is desired.	The method being implemented is linked to the type or identity of the class: for example, comparison methods.
A class may need more than one implementation of the method.	A class only needs one implementation of the method.

Bringing Android Honeycomb features to lower Android Versions

Huma Shankar — Sun, 15 Jan 2012 10:16:24 +0000

Android not only working in a direction to launching newer android versions to support new features, It’s also showing the commitment to bring some of the new enhancement, features and functionality of newly released Android version to lower android versions.

Android is trying to achieve the above goal by providing the Android Compatibility libraries.

There are currently following variants are available of this.

· V4 http://developer.android.com/resources/samples/Support4Demos/index.html

· V13 http://developer.android.com/resources/samples/Support13Demos/index.html

· Action Bar Compatibility http://developer.android.com/resources/samples/ActionBarCompat/index.html

These libraries offer the following functionalities for the Application built on android version 1.6 and above.

1. Fragments

Which are introduced in Android 3.0. As per android documentation “A Fragment represents behaviour or a portion of user interface in an Activity. You can combine multiple fragments in a single activity to build a multi-pane UI and reuse a fragment in multiple activities. You can think of a fragment as a modular section of an activity, which has its own lifecycle, receives its own input events, and which you can add or remove while the activity is running (sort of like a “sub activity” that you can reuse in different activities)”.

This helps to write common code which can be used across Smart Phone and Tablets.

2. Loaders

Loaders are also introduced in Android 3.0. This makes it easy to asynchronously load data in an activity or fragment. Loaders have these characteristics:

· They are available to every Activity and Fragment.

· They provide asynchronous loading of data.

· They monitor the source of their data and deliver new results when the content changes.

· They automatically reconnect to the last loader’s cursor when being recreated after a configuration change. Thus, they don’t need to re-query their data.

3. View Pager

View Pager supports horizontal swiping of the pages and views.

You can have a look into the blog post for more details

http://android-developers.blogspot.com/2011/08/horizontal-view-swiping-with-viewpager.html

4. Action Bar

This library helps to use the action bar design pattern on Android devices having Android Versions 1.6 and above.

The above stated items are the major one; there are other functionality as well which can be achieved using these compatibility libraries like Fragments Transition, Fragments back stack management etc.

Troubleshooting merge replication — Mismatch between the replication metadata

sunil.singh — Tue, 10 Jan 2012 08:21:26 +0000

Error Message:

The merge process failed because it detected a mismatch between the replication metadata of the two replicas, such that some changes could be lost leading to non-convergence. This could be due to the subscriber not having synchronized within the retention period, or because of one of the replicas being restored to a backup older than retention period, or because of the publisher performing more aggressive cleanup on articles of type download-only and articles with partition_options = 3. (Source: MSSQL_REPL, Error number: MSSQL_REPL-2147199363)
Get help: http://help/MSSQL_REPL-2147199363

The common generation watermark is invalid at this replica since it does not exist or metadata for changes not yet propagated may have been cleaned up. (Source: MSSQLServer, Error number: 21800)
Get help: http://help/21800

———————–

Let us see how replication works: a subscriber connects to the publisher, submitting its knowledge about which generations have already been sent and received. If the generations sent and received do not match, then the replication will fails by saying non-convergence can happen.

If you look in the table, sysmergesubscriptions, you will see four columns: sentgen, sentguid, recgen, and recguid. These are the columns that tell the last generations synchronized. Depending on whether you are looking at the publisher or subscriber will determine what the columns actually mean as far as direction. If you are looking at the publisher, then sentgen and sentguid refer to the last generation sent to the subscriber. If you are looking at the subscriber, then sentgen and sentguid refer to the last generation sent to the publisher. If you get the above error message, then it may be that the values do not match between the publisher and subscriber.

We have to trust either publisher or subscriber for accuracy, So let’s say that we trust the publisher to be accurate on the sentgen and recgen. All you need to do is copy the values for sentgen and sentguid into the recgen and recguid columns respectively, and the recgen and recguid into the sentgen and sentguid columns respectively at the subscriber. Your update statement will look something like:

UPDATE sysmergesubscriptions SET sentgen = 8664, sentguid = ‘DD172177-E223-417C-8BFF-9F72561280EA ‘, recgen = 13842769, recguid = 193C40B5-7A23-4A7A-B97E-885EC2A1FFD3′ where subid = pubid and pubid = F6646824-BCCC-443C-875B-0D700F63D075′

In the update statement we have “where subid = pubid.” That’s because there are two records for every publication at the subscriber, and only the one where the subid equals the pubid is used to track generations.

If synchronization is being taken care by RMO programming then you can also take care of this issue in RMO programming as well.

Reclaim Your Inbox

Peter Harrison — Mon, 09 Jan 2012 19:36:04 +0000

Manage your inbox before it manages you…

Today I had the distinct pleasure of speaking to a group of brilliant local leaders on how to Reclaim Your Inbox presented at the Young Presidents’ Organization Washington DC/Baltimore Chapter Retreat in Maryland on January 9, 2012.

View the full presentation: Reclaim Your Inbox by GlobalLogic CEO Peter Harrison

- - - - -

Below is a list of GlobalLogic’s Communications Guidelines for Email. If you have a good email tip or two that’s missing from this list, I encourage you to share them here by adding your comments below.

GlobalLogic’s Corporate Communications Guidelines - EMAIL:

Only send mail TO someone when action is requested or when responding (otherwise CC).
If information is simply FYI then send using CC, not TO which makes it clear no response is required
If you use REPLY ALL, always check that only relevant people remain in TO and CC.
If you send TO more than one person, make sure you clearly define who is expected to do what.
Consider creating a filter and applying a label to separate incoming CC mail.
Do not store processed mail in your Inbox - once you’ve responded/completed a mail move it to another label so you know it is complete.
Try to always respond to or acknowledge all TO mail within 24 hrs.
If you are not getting a response within the timeframe you need, pick up the phone. Not getting an email response from another person is not a reason to miss your own deadlines.
Do not use email for potentially emotional content; use the phone or a meeting instead.
If mail is confidential and not to be forwarded include CONFIDENTIAL in the subject line.
When you need to share attachments with a group:
For completed documents: upload to confluence and include the link in your mail
For working documents: use Google docs and share with the group
Always use the standard e-signature for all emails. Consider adding the PR boilerplate when sending emails for the first time to any person/prospect/partner - standard signature
Please use only the default background provided by Google for all emails. Backgrounds full of color and graphics can make emails difficult to read on mobile devices.
Please consider using HTML for emails as opposed to RTF. RTF makes it difficult to find embedded attachments.
As of now DELETED emails in Gmail are automatically erased from your mailbox’s memory after 3 weeks. Consider using ARCHIVE instead in order to locate your old emails.

Simplifying Agile - The art of writing User Stories

Sachin Gupta — Sun, 08 Jan 2012 13:30:13 +0000

When I started my current project as a Functional Analyst last year, I was advised to write user stories in the form of “As a , I want so that ”. It is a unique way to document the stories but definitely simplifies various challenges of the requirements documentation.

By learning how to gather requirements as user stories, I realized how agile plans are always kept up-to-date, contain only the latest and greatest information, and avoid one of the greatest wastes our industry has ever known—premature up-front analysis.

The key challenges that teams run into when they heavily rely on documentation for their software requirements are that:

They can’t handle changes effectively
They build according to specs instead of what the customer wants
They make bad guess and false assumptions
They waste a lot of time

So, Is a requirement really a requirement? If I put it in words of Kent Beck, one of the 17 original signatories of the Agile Manifesto, then the term ‘Requirement’ is just plain wrong.

“Software development has been steered wrong by the term requirement, defined in the dictionary as something that is mandatory or obligatory. The word carries a connotation of absolutism and permanence, inhibitors for embracing change. And the word “requirement” is just plain wrong.

Out of the thousands of pages used to describe requirements, if you deliver the right 5, 10 or 20 percent, you will likely realize all of the business benefit envisioned for the whole system. So what were the other 80 percent? Not requirements—they weren’t mandatory or obligatory.”

The problem with gathering requirements as documentation isn’t one of volume—it’s one of communication.

First, you can’t have a conversation with a document
Second, it’s just really easy to misinterpret what someone wrote

This leads us to one of the most important principles of agile:

The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.

So, what we need is something that enables us to have a conversation about a requirement, captures the essence of what our customer wants, and is small enough for planning yet descriptive enough to remind us what we are talking about …ENTER A USER STORY

Agile user story is a short description of a promise of a conversation. Agile encourages the user stories on index cards to remind teams that the initial goal of the requirements-gathering exercise isn’t to get into all the details. It’s to write down a few key words to capture the spirit of the feature and file it away for a later date.

Why just few key words? To save us the time and energy of going all in it now and having to redo it all later, we defer diving into the low-level details until later.

User stories have to make sense to business. That’s why we always try to write them in simple terms and try to stay away from any technical jargon. It is better if we put the information in terms that business understands.

A really good user story is one that goes from end to end - slicing through all the layers of the architecture and delivers something of value. The good user stories are Independent, Negotiable, Testable, and Concise that can be Estimated easily.

A few short, well-chosen words are usually enough to remind the team about what a particular user story is about: that brings up our User Story Template in existence

AS A I WANT SO THAT

The nice thing about this template is it answers three important questions about the user story: the who, the what, and the why. It gives a little more context and really emphasizes and focuses on the business, which is a good thing.

Maven Integration with PMD & FindBugs

Rajender Aggarwal — Wed, 04 Jan 2012 14:49:19 +0000

Apache Maven is a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a project’s build, reporting and documentation from a central piece of information.

In this blog, we will look at integration of Maven with PMD and FindBugs. Apart from PMS and FindBugs, there are various other tools such as Surefire and Corbetura that can be integrated with Maven. Lets look at them …

Maven Surefire Report Plugin : Generates the test results reports (TEST-*.xml) into HTML format.
Maven Corbetura Report Plugin : The Cobertura tool is a free and easy to use source code test coverage analyser. It helps you to discover where your source-code lacks in test coverage.
Maven PMD Plugin : Runs the PMD code analysis tool on your project’s source code and generate a site report with its results.
Maven FindBugs Report Plugin : FindBugs uses static analysis to inspect Java bytecode for occurrences of bug patterns. FindBugs is better in finding Threading issues than PMD.

Configuring PMD with Maven

At the PMD site there is comprehensive documentation available on what PMD will report about. In PMD there are rules and rulesets. Rulesets are groups of rules and other rulesets. By default PMD provides a ruleset that is packaged with the plugin. To customize this you need to create your own ruleset like described on the PMD site.

org.apache.maven.plugins
maven-pmd-plugin

{Location of PMD Rulse Set File};/ruleset>

package

pmd

Configuring FindBugs with Maven

FindBugs looks for bugs in Java programs. It is based on the concept of bug patterns. A bug pattern is a code idiom that is often an error. Bug patterns arise for a variety of reasons:

Difficult language features
Misunderstood API methods
Misunderstood invariants when code is modified during maintenance
Garden variety mistakes: typos, use of the wrong boolean operator

org.codehaus.mojo
findbugs-maven-plugin
1.2

true

target/site
High

To conclude, integrating and generating reports with Maven is a great way to monitor the quality of the code. However, to get the real value, one must think about which reports to choose and how to use them. Adding too many reports will lead to information overload and may create confusion over what to fix.

Robotium – Part I

deepa.gupta — Mon, 02 Jan 2012 12:56:40 +0000

An Automation Testing Framework for Android Applications

“Automated tests may reduce the amount of effort required in agile software development teams, provided they are used in the right way” - by Daniel Knott

Android applications are usually build for various Android devices. Testing the same build on different devices is a tedious job. An automation tool can help us to speed up testing process and catch the bugs immediately.

The Robotium is a framework that is used to develop powerful and robust black box test cases for Android application. Robotium is freely available online at http://code.google.com/p/robotium/. It is titled as “It’s like Selenium, but for Android”. Robotium framework supports Android Activities, Dialogs, Toasts and Menus, Context menus that are able to simulate user interaction such as touching, clicking, text entry and any other action that is possible on a touch device.

What Environment Required?

· Eclipse for building Test project.

· ADT (Android Development Tools)

· SDK (Software Development Kit)

· JDK (Java Development Kit)

· Robotium-solo jar file

· Android apk or Source code to create Test project.

Note: Install ADT, SDK and JDK to your system and give a proper path in environment variable.

How it works?

Robotium is a plugin for eclipse, which is built in Java program and the JUnit test framework. JUnit with Robotium gives us more additional ways of asserting response on device, which makes these tests even more powerful. Following is the workflow for testing am Android application using Robotium.

1. Set up environment.

2. Create an Android Test Project by referencing it with the actual project APK or Source code.

3. Add Robotium.jar file in the Test Project build path.

4. Create a java class file (Test Suite) and write all test methods (Test Cases) inside using Robotium solo API.

5. For executing Robotium tests, Run the Test project as ‘Android JUnit Test’ and view Test results in the JUnit explorer window.

Robotium follows TDD (Test Driven Development) methodology, where Test Cases are written first and actual source code is developed later which enables the Test Cases to pass.

Robotium test cases (Java class) can also be written prior to starting actual project development, if the UI/layout and flow is finalized, and these test cases can be used any time for testing multiple project releases. For each release we just need to create a Test Project using step 1-4 and add all test cases inside java class file.

To develop stable and reliable tests, Robotium Solo API is used, which provides various methods that are used to record different graphical elements within Android application, Such as:

clickOnButton(“Register”);
searchText(“Main Menu”);
goBack();
waitForText(“Registration Successful.”);

For more information about Solo APIs, refer to the following URL: http://www.jarvana.com/jarvana/view/com/jayway/android/robotium/robotium-solo/1.3.1/robotium-solo-1.3.1-javadoc.jar!/index-all.html

Why Robotium?

· Powerful Test Cases can be developed, without knowing source code of the application.

· The framework provides various easy methods to simulate multiple Android activities.

· Writing Test cases is easy and takes minimal time to complete.

· Readability of test cases is greatly improved, compared to standard instrumentation tests.

· Test cases are more robust due to the run-time binding to GUI components.

· The framework handles multiple Android activities automatically like finds current views, follows current activities.

· Test execution is very fast.

· Integrates smoothly with Maven or Ant to run tests as part of continuous integration.

Limitations

Robotium has few limitations, which should be kept in mind while selecting a test application.

· The scope of test cases in Robotium is limited to a single application and does not support for more than one application. Test project is always locked with a target package, which need to be tested and going outside of the package is not allowed.

· Android native API’s (Contacts, Widgets etc.) used in the Android application cannot be tested using Robotium. While executing test, if focus is switched to Native application, it will not come back to the Test application and Test will fail.

· Robotium is not able to handle the flash or web components; it only works with android components. You could send in clicks by using clickOnScreen() or assert that a certain Activity is shown but that is all. You will not be able to write tests where you verify or work with the web or flash components.

In the Part II I will through more light on creating test projects.

Runtime Memory Management Basics

Manish.Rathi1 — Sat, 31 Dec 2011 16:55:25 +0000

Memory – One of the most valuable resources of digital world; always remains in high demand just like the Gold in real world. Every active application visible or invisible, certainly require memory for its operations. Due to its nature of limited and high demand, runtime environment has to be very cautious in allocating memory space for program’s objects. Runtime employee various techniques/algorithms in order to fulfil the memory demand of various running applications, considering making all of them mutually happy.

It’s probably hard to imagine and directly going the way these runtime manages, better remain in real world and get conceptual understanding.

Let’s take a simple use case -

Place – Community hall

Capacity – 1000 persons

Objective – Provide the place for each person entering in hall with most convenient way. Convenience can be subjective so let be specific with following–

Minimize the allocation time
Minimize the disturbance for other existing
Smooth capture of empty seats happen due to exit of persons

We have to design a master idea, a virtual program as a solution to above defined use case. Let’s start with simplest one.

Idea 1: Random Allocation.

Person entering can occupy any available location in the community hall. No specific seat allocation rule.

Each time a person enters, he will looks for comfortable place of his choice and occupy. Comfortable location is relative and differs for person to person. Some take front seat, some prefer back, some in center and some might look for seats close to their friends.

As there are no rules Think Time before occupying seat is relatively higher. Each has to think, spend some time his own way.

Idea 2: Sequencing – Force them to sit only next available seat in sequential order.

The moment we apply this rule, Think Time reduced drastically, close to zero. Now places are predetermined, person doesn’t have to spend his time in deciding the place. This idea makes things move faster but it leads into another problem.

Problem - We only considered allocation, and completely ignored the facts of people leaving the hall from any random location. This will create random free seats available, which could be allocated to new person. Our rule does not allow person to sit in empty locations even if they are more preferable/near compare to what next available defined by our rule. Clearly this rule fails to provide the space in least possible time considering empty random locations available.

Idea 3: Re-arrange

Now to address problem with idea 2 we add another rule, Every time seat freed, we move existing persons, such that vacant locations merged into free location available at the end. Of course we haven’t solved the problem of Idea 2, we just avoided the scenario where problem arising.

At first, things look fine. No empty location remains since every time we move that to end.

Few time later we found ourselves in front of Lion just to avoid barking dogs. We just fall into bigger problem. Doing re-arrangement every time whenever seat gets vacant is overkilling, creating lots of disturbance for the existing mass.

To handle this we have added few sub-idea rules –

Do not rearrange every time, do it in interval. Like for every 5^th vacant seat.
Do this rearrangement in free time, break hours etc.

Doing all these does not gain much advantage and we have to move away from this rule.

We can have hundreds of these rules defined and analysed but it will create blogs virtually impossible to read. I might discover few more rules in next blog, but bigger question to be asked why this all discussion is all about.

Now try to map following entities

Community hall = Available Memory Area

Capacity 1000 persons = 1000 memory location, allocation units

Now re-read the Idea’s with mapped memory entities. You will understand the very basics essence of memory allocation.

All platform or programming language has their own strategy for memory management having their own set of benefits and drawbacks. At very broader level they are built around following

– Allocating memory in least possible time with most optimized way
– Freeing memory (Memory Recycling / Reclaiming Free memory)
– Arranging memory (Remove memory fragments)

As we go through community hall use case, though these activities might look simple but there is lot to be discussed. Hope to write more soon …

Singleton Design Pattern using C sharp

pradip.pathrikar — Sat, 31 Dec 2011 07:21:26 +0000

Design Patterns are recurring solutions to the software design problems you find again and again in real world application development. These patterns are about design and interaction of objects and also serves as the communication platform concerning reusable solutions to commonly faced programming challenges. This post focuses on the main categories of design patterns and the implementation for the Singleton design pattern using C sharp.

Mainly design patterns are categorized in three parts

1) Creational Patterns

These patterns deals with the creation mechanism of objects, trying to create objects in a manner suitable to the situation. This type of design patterns solve the complexity of creating objects by controlling its object creations.

2) Structural Patterns

Structural Patterns are used to identify and implement the relationships between the entities in easy way.

3) Behavioral Patterns

Behavioral Patterns are self explanatory, behavior means the object methods or functions. Hence these types of patterns identifies the common ways of communications between the objects and thus increase flexibility in carrying out the communication.

Singleton Design Pattern - Creational Pattern

Singleton : Singleton design pattern is one of the Creational Patterns which controls the object creation. The main objective of the Singleton design pattern is that it creates and ensures only ONE object will be created during the life time of the application. Ex. Singleton pattern can be used for maintaining only one database connection object through out the application, maintaining the static information and the reference count of the object accessed or used by the application.

Structure

CSingleton Class Diagram

Implementation: Singleton class using C#

namespace DesignPatterns
{
    public sealed class CSingleton
    {
        private static volatile CSingleton instance;
        private static volatile int counter = 0 ;
        private static object syncRoot = new object();
        private CSingleton()
        {
        }
        public static int Counter
        {
            get
            {
                return counter;
            }
        }
        public static void Release()
        {
            counter--;
        }
        public static CSingleton Instance
        {
            get
            {
                if (instance == null)
                {
                    lock (syncRoot)
                    {
                        if (instance == null)
                            instance = new CSingleton();
                    }
                }
                counter++;
                return instance;
            }
        }

    }
}

In above example the the class CSingleton is marked as sealed so as to restrict the derivation of this class which could odd instances of this class.
The variable “instance” will hold the object to the CSingleton class itself, volatile keyword ensures that the assignment to the instance variable completes before instance variable can be accessed.
Constructor is made as private to prevent creation of the object of CSingleton class by other parts of application.
Counter data member holds count of the references accessed by the client/other part of the application. This member is used to to know how many clients are using this object.
Above approach uses the thread safe implementation using the syncRoot data member, double - check locking is implemented to avoid the thread concurrency problems.
Release method will just decrements the counter by one. Clients should call this method once they are done using CSingleton object. Usually when they don’t require services of this class anymore.