Various technologies have evolved under the umbrella of RIA and have different features and capabilities to offer. The most prominent ones being Flex (from Adobe) and Silverlight (from Microsoft)

These technologies are being used extensively for incorporating interactivity in applications but their true potential is yet to be realized.

Verve Systems has understood the importance of understanding and keeping in mind that technology is to be utilized and not overused for functionality. Verve’s approach is to work upon the Cost vs. Usability trade-off. These problems can be solved by following initiatives and changes in approach:

• Give equal weightage to usability as to functionally. It’s crucial to consider aspects like target users, usability of the solution, non-functional needs, available infrastructure etc.
• Plan usability and user interface in proportion to functionality. Too much of interactivity with very less functionality may irritate the user
• Plan participatory designs to ensure that the users participate equally to share their views on usability of the application. If users are pleased, objective is met.
• Technical design and architecture should be made very carefully to ensure right mix of content, richness and performance. E.g. New architecture styles like MV-VM aid significantly in achieving rich user experience with considerably higher performance.

Also to note that RIA is being used more as a tool for Rich UI in smaller applications and Websites to demonstrate creativity in terms of look and feel. Very few companies have actually utilized RIA with the right mix of technologies to leverage the interactivity and usability factor of it.

Using RIA in BI and other business Solutions is rarely thought of because of various myths. Verve has addressed these myths by utilizing their expertise in RIA and experience of developing business solutions for medium and large enterprises. Here are a few of them:
1. RIA will make the application slow: Of course RIA needs more resource, and with right mix of technology and supporting architecture, there is no question of slowness. Architecture practices like MV-VM and usage of appropriate frameworks while integrating RIA with other Business Logic technologies ensures the right mix of interactivity and performance.
2. How will RIA help in BI and business apps: Business applications help in critical decision making, which needs multiple levels and types of projections, data sampling, arrangement of models etc. RIA promises availability of ample data in presentation layer itself thus offering fast manipulation and sampling of data into various models followed by their immediate visualization. This helps in quickly analysing and comparing numerous scenarios, which is not possible in conventional methods.
3. There are stability issues with RIA technologies: This is now a thing of past. Any new technology will have issues unless it settles down by getting a feel of its practical usage. Major RIA technologies like Flex and Silverlight are quite stable and consistent in their practical usage and offer even more ease of implementation compared to other conventional methods.

With its experience of delivering numerous business solutions, Verve has realized that any solution cannot be perfect in first shot; it evolves over a period of time with progressive iterations based on users’ feedback. It’s extremely important to understand the solution from users’ point of view because ultimately, they are the ones who decide whether the solution is success or failure. So going with this philosophy may at times demand to keep aside our intelligence to provide ease of access and understand what users actually want.

Install & Configure Database Software {Berkeley DB}

Issued the below commands from the folder /ldap/
CPPFLAGS=”-I /ldap/db-4.8.26/build_unix”
export CPPFLAGS
LDFLAGS=”-L /ldap/db-4.8.26/build_unix -R/usr/local/db-4.8.26/lib”
export LDFLAGS
LD_LIBRARY_PATH=”/usr/local/db-4.8.26/lib” {default path will be}
export LD_LIBRARY_PATH
Now issue this command from /ldap/db-4.8.26/
cd build_unix &&
../dist/configure –prefix=/usr \
–enable-compat185 \
–enable-cxx &&

The next step is to build the software. This step we compile the software:
Command : make
You are now ready to install the software; this usually requires super-user privileges.
make docdir=/ldap/db-4.8.26 install &&
chown -v -R root:root \
/usr/bin/berkeley_db42_svc \
/usr/bin/db42_* \
/usr/include/db{,_185,_cxx}.h \
/usr/lib/libdb{{,_cxx}.a,{,_cxx,_java,_tcl}-4.8.{so,a}} \
/mnt/apps/ldap/db-4.8.26/build_unix
Now we are done with Installation of Database.

Install & Configure Open LDAP

• Run configure
You will need to run the provided configure script to configure the distribution for building on your system. The configure script accepts many command line options that enable or disable optional software features. Usually the defaults are okay, but you may want to change them. To get a complete list of options that configure accepts, use the –help option: ./configure –help

• Build the software
The next step is to build the software. This step has two parts, first we construct dependencies and then we compile the software:
1) make depend 2) make

• Test the build
To ensure a correct build, you should run the test suite (it only takes a few minutes):
make test
Note : Tests which apply to your configuration will run and they should pass. Some tests, such as the replication test, may be skipped.

• Install the software
You are now ready to install the software; this usually requires super-user privileges:
su root -c make install
Everything should now be installed under /usr/local (or whatever installation prefix was used by configure).

• Edit the configuration file
Use your favorite editor to edit the provided SLAPD.CONF example (usually installed as /usr/local/etc/openldap/slapd.conf) to contain a BDB database definition of the form.
database bdb
suffix “dc=,dc=”
rootdn “cn=Manager,dc=,dc=”
rootpw secret
directory /usr/local/var/openldap-data
Be sure to replace and with the appropriate domain components of your domain name. For example, for example.com, use:
database bdb
suffix “dc=example,dc=com”
rootdn “cn=Manager,dc=example,dc=com”
rootpw secret
directory /usr/local/var/openldap-data
If your domain contains additional components, such as eng.uni.edu.eu, use:
database bdb
suffix “dc=eng,dc=uni,dc=edu,dc=eu”
rootdn “cn=Manager,dc=eng,dc=uni,dc=edu,dc=eu”
rootpw secret
directory /usr/local/var/openldap-data

Also Include the below mentioned schema to activate various objectClasses.

include /usr/local/etc/openldap/schema/core.schema
include /usr/local/etc/openldap/schema/nis.schema
include /usr/local/etc/openldap/schema/misc.schema
include /usr/local/etc/openldap/schema/duaconf.schema
include /usr/local/etc/openldap/schema/java.schema
include /usr/local/etc/openldap/schema/dyngroup.schema
include /usr/local/etc/openldap/schema/cosine.schema
include /usr/local/etc/openldap/schema/inetorgperson.schema

Add the following lines to the sldap.conf

access to attrs=userPassword,shadowlastchange
by dn=”cn=Manager,dc=example,dc=corp,dc=test,dc=local” write
by anonymous auth
by users read
by * none
access to *
by dn=”cn=admin,dc=example,dc=corp,dc=test,dc=local” write
by * read
access to dn.base=”" by * read
access to dn.base=”cn=Subschema” by * read
access to *
by self write
by users read
by anonymous auth
# ACL1
access to *
by self write
by group.exact=”cn=Admin,ou=roles,dc=example,dc=corp,dc=test,dc=local” write
by users read
by * none
# ACL2
access to *
by self read
by group.exact=”cn=Executive,ou=roles,dc=example,dc=corp,dc=test,dc=local” read
by * none

• Start SLAPD

You are now ready to start the Standalone LDAP Daemon, slapd(8), by running the command: su root -c /usr/local/libexec/slapd
To check to see if the server is running and configured correctly, you can run a search against it with ldapsearch(1). By default, ldapsearch is installed as /usr/local/bin/ldapsearch:
ldapsearch -x -b -s base ‘(objectclass=*)’ namingContexts
Note the use of single quotes around command parameters to prevent special characters from being interpreted by the shell. This should return:
dn: namingContexts: dc=example,dc=com

• Add initial entries to your directory
You can use LDAPADD to add entries to your LDAP directory. LDAPADD expects input in LDIF form. We’ll do it in two steps:
1) create an LDIF file 2) run ldapadd
Use your favorite editor and create an LDIF file that contains:
dn: dc=,dc=
objectclass: dcObject
objectclass: organization
o:
dc:

dn: cn=Manager,dc=,dc=
objectclass: organizationalRole
cn: Manager
Be sure to replace and with the appropriate domain components of your domain name. should be replaced with the name of your organization. When you cut and paste, be sure to trim any leading and trailing whitespace from the example
dn: dc=example,dc=com
objectclass: dcObject
objectclass: organization
o: Example Company
dc: example

dn: cn=Manager,dc=example,dc=com
objectclass: organizationalRole
cn: Manager
Now, you may run LDAPADD to insert these entries into your directory.
ldapadd -x -D “cn=Manager,dc=<MY-DOMAIN>,dc=<COM>” -W -f example.ldif
Be sure to replace and with the appropriate domain components of your domain name. You will be prompted for the “secret” specified in slapd.conf.
For example, for example.com, use:
ldapadd -x -D “cn=Manager,dc=example,dc=com” -W -f example.ldif
Note: example.ldif is the file you created above.

• See if it works

Now we’re ready to verify the added entries are in your directory. You can use any LDAP client to do this, but our example uses the ldapsearch(1) tool. Remember to replace dc=example,dc=com with the correct values for your site:
ldapsearch -x -b ‘dc=example,dc=com’ ‘(objectclass=*)’
This command will search for and retrieve every entry in the database.

• Create Node Roles and Users under the Base DN

1) Create a file in your favorite text editor and save it as example.ldif.
dn: ou=users,dc=example,dc=com
ou: users
objectclass: top
objectclass: organizationalUnit

2) Create a file in your favorite text editor and save it as example.ldif.
dn: ou=roles,dc=example,dc=com
ou: roles
objectclass: top
objectclass: organizationalUnit
Issue the below command to create Node Roles
ldapadd -x -D “cn=Admin,dc=example,dc=com” -W -f example.ldif

• Adding Roles to the LDAP Tree

3) Create a file in your favorite text editor and save it as example.ldif
dn: cn=Admin,ou=roles,dc=example,dc=com
objectclass: groupOfNames
cn: Admin
description: Administrator
member: cn=,ou=users,dc=example,dc=com

dn: cn=Executive, ou=roles,dc=example,dc=com
objectclass: groupOfNames
cn: Executive
description:Executive
member: cn=,ou=users,dc=example,dc=com
member: cn=,ou=users,dc=example,dc=com
Issue the below command to Add Roles
ldapadd -x -D “cn=Admin,dc=example,dc=com” -W -f example.ldif

• Other useful commands

ldapmodify -x -D “cn=Manager,dc=example,dc=com” -W -f temp.ldif
you need to create a ldif file which carries the following set of details
dn: cn=,ou=users,dc=example,dc=com
changetype: modify
replace: sn
sn:
replace: cn
cn: (old username)
cn: (New username)
ldapdelete -r -D “cn=Manager,dc=example,dc=com” –W << Entry to Delete>>
ldapsearch -x -b dc=Manager,dc=example,dc=com objectclass=*
ldapadd -x -D “cn=Admin,dc=example,dc=com” -W -f example.ldif

For any queries please contact verve@vervesys.com

Outsourcing means out-sourcing, i.e. giving a part of the organizational activity to another company, organization, or even sub-organization (a department within the organization) with mutual interest, so as to concentrate on core organizational activity (in which the organization has expertise) than working on auxiliary activities.

Onsite means the site where the activity is performed, for instance, “onsite” for a banking software is the back office where that software is actually being (or is being deployed for use).

Onshore means the same shore where the activity is performed. Same shore usually refers to the same continent.

Offsite means away from the site of activity.

Offshore means away from the shore of activity and not only site, so, offsite can either be onshore or offshore.

With endurance and experience, Verve Systems has evolved with appropriate combinations of onsite, onshore, offsite and offshore mechanisms to add optimum value to the outsourced activity in various industries and size of businesses.

Verve Systems has realised the importance of being onsite for crucial activities to minimize hassles and operating from offshore for man power dependent activities to maximize savings; and has helped its clients to ensure well managed execution of outsourced activities and significant savings thus leading to quantitative as well as qualitative results of outsourcing.

To overcome this distrust, the concept of Activity Partnership is emerging like anything. A company, with a need for software development activity will partner with a similar scale or lower scale software development company to become their software development partners instead of following conventional outsourcing mechanism. This model like any other model brings a few challenges along, which, if not addressed may lead to bitter relations between partners. These challenges include:
1) Retaining the trust: Either of partners when tries to leverage the trust, it may result into the other partner realizing it and feeling cheated in the relationship
2) Consistent Quality: As the engagement goes on, supplier is bound to feel relaxed in maintaining the relation resulting into lesser drive and commitment hence lesser quality of delivery
3) Fear of losing business: When the client asks for a work which is not a part of supplier’s offering, supplier usually tends to say yes due to fear of losing the engagement, which may result into failure of projects.

Sense of ownership, shared benefits of success and responsibility for failure are the only ways (all together) of sustaining such engagements. In short we can call it absolute transparency. Well, but this is about sustenance, and should be kept in mind while choosing a partner. Still in the inception phase, things that matter the most are:
1) Processes
2) Capacity / Scalability
3) Capability (Skillset and experience and exposure)
4) Appropriate quality (Product / service need not be perfect, but acceptable)
5) Cost effectivity and Value Addition
Verve Systems, with their approach of “appropriateness than perfection” has ensured that such partnerships (especially offshore product development) are sustainable, value adding, and transparent, thus enabling their partners to trust them consistently and concentrate on their core activities than worrying about offshore relations.

For any queries please contact verve@vervesys.com

For any queries please contact verve@vervesys.com

With growing economy costs are increasing and prices are reducing. In this situation, to have sustainable margins is getting more and more difficult. Offshoring or outsourced offshoring is catching a lot of attention these days because of its cost effectiveness. However, managing an onsite-offshore engagement involves a lot of hassles which keep growing due to increasing competition in offshore markets. With countries like India, China and Ukraine leading in the list it’s difficult for the clients to decide which supplier to choose. Almost all of them offer lucrative cost savings and flexible business models when they sell but almost all of them fail to meet the expectations at various levels.
Verve Systems has invested its expertise and efforts in identifying the pain areas for such engagements and has evolved with mutually beneficial “Value Added Transparency” models. These engagement models not only ensure that transparency is maintained throughout the engagement but also utilize this transparency for overall value addition to the engagement by learning lessons and incorporating learning at every level of transparency.
Important aspect to understand in these engagements is that problems do happen and they will keep happening, but the idea is to take right measures to ensure that these problems do not repeat. Most of the clients or suppliers run out of a relationship after problems and these problems keep coming in all new relationships. This is becoming a major showstopper for SMEs in offshoring locations for growing beyond certain limits.

For any queries please contact verve@vervesys.com

What’s JAXB?
The Extensible Markup Language and Java technology are natural partners in helping developers exchange data and programs across the Internet. That’s because XML has emerged as the standard for exchanging data across disparate systems, and Java technology provides a platform for building portable applications.
A new Java API called Java Architecture for XML Binding(JAXB) can make it easier to access XML documents from application written in Java Programming Language.
It provides an efficient and standard way of mapping between XML and Java code.
Accessing an XML Document using JAXB

→ Bind the Schema for the XML document.
→ Unmarshall the document into Java content.The Java content objects represents the content and organization of the XML document, and are directly available to your program.
Bind the Schema

JAXB simplifies access to an XML document from a java program by presenting the XML document to the program into java format. The first step in this process is to bind the schema for the XML document into a set of java classes that represents the schema.

Schema
A schema is an XML specification that governs the allowable components of an XML document and the relationship between the components.
JAXB requires that the XML document you want to access has a schema, and that schema is written in the W3C XML Schema Language.

Binding
Binding a schema means generating a set of java classes that represents the schema. All JAXB implementations provide a tool called a binding compiler to bind a schema.

For solaris enviornment here is the command to run the script that binds the schema.
xjc.sh -p test.jaxb books.xsd -d work

books.xsd is a XML schema. -p option identifies a package for the generated classes and the -d option identifies a target directory. So for this command, the classes are packaged in test.jaxb within the work directory.
You then compile the generated interfaces and classes.For example,
javac test/jaxb/*.java test/jaxb/impl/*.java
This compiles all of the interfaces and classes in the test.jaxb package generated by the binding compiler.

Unmarshal the Document

Unmarshalling an XML document means creating a tree of content objects that represents the content and organization of the document. The content tree is not a DOM-based tree. In fact, content trees produced through JAXB can be more efficient in terms of memory use than DOM-based trees.
The content objects are instances of the classes produced by the binding compiler. In addition to providing a binding compiler, a JAXB implementation must provide runtime APIs for JAXB-related operations such as marshalling.
The APIs are provided as part of a binding framework. The binding framework comprises three packages. The primary package, javax.xml.bind, contains classes and interfaces for performing operations such as unmarshalling, marshalling, and validation (marshalling and validation will be covered later). A second package, javax.xml.bind.util, contains a number of utility classes. The third package, javax.xml.bind.helper, is designed for JAXB implementation providers.

To unmarshal an XML document, you:

→ Create a JAXBContext object. This object provides the entry point to the JAXB API. When you create the object, you need to specify a context path. This is a list of one or more package names that contain interfaces generated by the binding compiler. By allowing multiple package names in the context path, JAXB allows you to unmarshal a combination of XML data elements that correspond to different schemas.

For example, the following code snippet creates a JAXBContext object whose context path is test.jaxb, the package that contains the interfaces generated for the books.xsd schema:

import javax.xml.bind.JAXBContext;

JAXBContext jc = JAXBContext.newInstance(“test.jaxb”);
→ Create an Unmarshaller object. This object controls the process of unmarshalling. In particular, it contains methods that perform the actual unmarshalling operation. For example, the following code snippet creates an Unmarshaller object:
import javax.xml.bind.Unmarshaller;
Unmarshaller unmarshaller = jc.createUnmarshaller();

→ Call the unmarshal method. This method does the actual unmarshalling of the XML document. For example, the following statement unmarshals the XML data in the books.xml file:
Collection collection= (Collection) unmarshaller.unmarshal(new File( “books.xml”));
Note : Collection here is a test.jaxb.Collection, not a java.util.Collection.

→ Use the get methods in the schema-derived classes to access the XML data. Recall that the classes that a JAXB compiler generates for a schema include get and set methods you can use to respectively obtain and specify data for each type of element and attribute in the schema.

CollectionType.BooksType booksType = collection.getBooks();

List bookList = booksType.getBook();
Benefit of JAXB

1. JAXB simplifies access to an XML document from a Java program.
2. JAXB allows you to access and process XML data without having to know XML or XML processing.
3. JAXB allows you to accessdata in non-sequential order. It doesn’t force you to navigate through a tree to access the data.
4. JAXB uses memory efficiently.
5. By unmarshalling XML data through JAXB, java content objects that represent the content and organizaton of the data are directly available to your program.
6. You can unmarshal XML data from a variety of input sources like File, Inputstream object, Url.

How to invoke Java methods from Flex application?
1.Add an mapping to the Java class to services-config.xml
2.Map your RemoteObject (provided with Flex SDK) on the client side to the destination configured in services-config.xml
3.Invoke the method in your Java class using the RemoteObject instance
What do you need to invoke a Java method from the client side application?
1.Flex Builder
2.Blaze DS
Isn’t that simple? Let’s get into details of implementing this.

Set up Blaze DS

Step 1:
Download release build of BlazeDS. BlazeDS release builds are available at this URL http://opensource.adobe.com/wiki/display/blazeds/Release+Builds Click on “Download the BlazeDS binary distribution” to download the binary distribution. Binary distribution has just jar files and other configuration files required.
Step 2:
Go to folder where you saved the downloaded file in Step 1. You would have downloaded a file named blazeds-bin-3.2.0.3978.zip. Extract the content in this file to a folder named blazeds-bin-3.2.0.3978
Step 3:
In the blazeds-bin-3.2.0.3978 folder you will find a file named blazeds.war and blazeds-bin-readme.htm. blazeds-bin-readme.htm contains terms and conditions and license details. blazeds.war contains required jar files and configuration files for setting up BlazeDS.
Extract the content in blazeds.war file into a folder called blazeds. You can extract the content using tools like winzip.
Now we have downloaded and have the required files extracted to setup BlazeDS for a web application. Let’s create a web application.
Creating web application
If you don’t have Tomcat installed, install Tomcat from http://tomcat.apache.org/
Step 4:
In your Tomcat installation directory, you will find a folder named webapps. Usually it is at this location on Windows Operating System “C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps”
Create a web application named samplewebapp. You do this by just creating folder named samplewebapp under webapps folder.
Setting up BlazeDS

We will setup BlazeDS for the web application created in the previous step.
blazeds – this is the folder in which we have blazeds.war content extracted into  in Step 3
samplewebapp – this is the folder created in Step 4
Step 5:
Copy all .jar files from blazeds/WEB-INF/lib to samplewebapp/WEB-INF/lib
Step 6:
Copy blazeds/WEB-INF/flex folder to samplewebapp/WEB-INF
This folder (blazeds/WEB-INF/flex) contains BlazeDS configuration files. Use these files to configure Remoting/Messaging/Proxy services.
Step 7:
Now we will add Servlet mapping for BlazeDS Servlet named MessageBrokerServlet, so that BlazeDS is invoked when you send request for a Remoting/Messaging/Proxy destination using any of the channels supported.
Copy blazeds/WEB-INF/web.xml to samplewebapp/WEB-INF
If you already have a web.xml configured, then you can just copy the Servlet mapping for MessageBrokerServlet and the session listener. You can either copy the content below or copy it from the blazeds/WEB-INF/web.xml

flex.messaging.HttpFlexSession

MessageBrokerServlet
MessageBrokerServlet
flex.messaging.MessageBrokerServlet
services.configuration.file /WEB-INF/flex/services-config.xml
1

MessageBrokerServlet
/messagebroker/*

That’s it you have BlazeDS setup for your web application.

Creating Java class
Create the Java class with the code below and compile it. We should deploy this class in a location, where Blaze DS can find and instantiate this class. Under the folder where the Blaze DS zip file was extracted, navigate to tomcat/webapps/blazeds/WEB-INF/classes and then copy the Java class in appropriate directory structure.

RemoteServiceHandler.java
package com.adobe.remoteobjects;
import java.util.Date;
public class RemoteServiceHandler {
public RemoteServiceHandler()
{
//This is required for the Blaze DS to instantiate the class
}
public String getResults(String name)
{
String result = null;
result = “Hi ” + name + “, this is a service and the time now is : ” + new Date();
return result;
}
}

Creating Flex application
Using the Flex Builder select File -> New -> Flex Project. Create new Flex project window will be displayed. Give your application name and other details. Select the Application Server type to J2EE. Please find the screen shot of the window I filled while developing.

Click Next and then Server Configuration window will be displayed. Modify the values in this window to reflect the paths in your system. Please find the sample values in the image below. Select the output folder properly so that the Flex application is compiled directly into the Tomcat web application directory.

Once this is done continue with the project creation setup and complete it.
Code to be included in the MXML file to invoke the Java class on the server is available below.
In the RemoteObject, the value of the destination property should be set to the ID of the destination, which will be added to the configuration file (Explained below).

MyApplication.mxml

destination=”CreatingRpc”
result=”Alert.show(event.result.toString());”
fault=”Alert.show(event.fault.faultString);”
/>

This application has been configured to compile the output to the tomcat web application folder. Now that we have done developing the files required on both the client and the server. We need to configure Blaze DS.

Configuring Blaze DS
Navigate to tomcat/webapps/blazeds/WEB-INF/flex and open the file remote-config.xml. Replace the XML file content with the content below. The ID of the destination added below will be used by the components at the client side. Destination added will be map the destination name to the Java class, which has to be invoked.
remote-config.xml

class=”flex.messaging.services.RemotingService”>

com.adobe.remoteobjects.RemoteServiceHandler

Executing the application
Start the Tomcat server. Navigate to http://localhost:8400/blazeds/MyApplication-debug/MyApplication.html in your browser. Click on the Remote Service button and then you can see the message from the Java class.