GSM, GPRS, EDGE, 3G, WCDMA and HSDPA

It's a very basic and non-technical comparison.
GSM

GSM, stands for Global Systems for Mobile Communications, is basic standard bearer of 2G technologies. It is mainly used in mobile communication. Short Messaging System (SMS) was introduced into GSM networks along with capability to download content from various service providers. The content could ring tone, logos and picture messages.

It can support Voice telephony and Data however the Data rate is only 9.6Kb/s, that is very low bit rate for date communication.
GPRS

GPRS, stands for General Packet Radio Service, is used to give higher data speed over GSM. It is not the replacement of GSM. It is just a extension to the older GSM technology to gain faster speed.

Multimedia Messaging System or MMS is the feature of GPRS. It allowed subscribers to send videos, pictures, or sound clips to each other just like text messages. GPRS also provided mobile handset the ability to surf the Internet at dial-up speeds through WAP enabled sites.

GPRS offered higer bit rate ( Up to 171kb/s) by usage of A packet-linked technology over GSM.

EDGE

• EDGE stands for Enhanced Data Rates for GSM Evolution. This technology, also termed as Enhanced GPRS.
• This is a technology that uses the same equipment as GSM with only a few minor modifications to provide faster data speeds and is often regarded as a stepping stone towards 3G thus it is called 2.5G.
• EDGE gives the users the inimitable chance to increase the throughput capacity and the data speed at least 3 to 4 times higher to what GPRS offers.
• EDGE is a digital mobile phone technology but GPRS is a mobile data service.
• It is a 3G Radio technology and GPRS or General Packet Radio Service is essentially packet oriented.
  

3G

• The introduction of 3G changed a lot of the accepted standards in the mobile phone industry. It allows the use of a greater bandwidth that allows more features to be implemented on it.
• 3G gives many features like video calls and TV applications because of the speed of 3G which began at 384kbps; well within DSL speeds. Further development on 3G technologies have also created even faster data rate reaching 3.6 and even 7.2Mbps.
• Existing GSM networks are not compatible with the 3G networks. To keep it, requires a new infrastructure.
• According to popularity and demand Telecom Operators place 3G towers in those areas.They have to operate 2 radios in particular areas; one for GSM and one for 3G.
• Mobile phone Users are also required to switch mobile phones in order to take advantage of the new features of 3G.
  

WCDMA

3G Networks are based on WCDMA i.e. Wideband Code Division Multiple Access, a mobile technology that improves upon the capabilities of current GSM networks.

HSDPA
HSDPA (High Speed Downlink Packet Access) is what is also known as 3.5G, as it offers no substantial upgrade to the feature set of WCDMA, but improves the speed of data transmission to enhance those services.
WCDMA networks provides max 384kbps speed whileHSDPA allowed speeds above 384kbps, the most notable of which is 3.6Mbps and 7.2Mbps.

HSDPA has lower latency times and Fast Packet Scheduling compared to WCDMA.

How to write Binary data in XML

Binary data in XML

Sometimes It is required that we need to send content / binary data in xml itself instead of urls / path along with the meta data of the content.

Here is the code to write an Image File in XML : (I used here Base64 encoding)

-----------------------------------------------------------------------------------

import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

import javax.imageio.ImageIO;

import org.apache.commons.codec.binary.Base64;


public class WriteBinaryXML {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            BufferedImage img = ImageIO.read(new File("/pathofsourceimage/image.jpg"));
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ImageIO.write(img, "jpg", baos);
            baos.flush();
            String encodedImage = new Base64().encodeToString(baos.toByteArray());
            baos.close();
            System.out.println("encodedImage -----  " + encodedImage);
 

    // Write this String (encodedImage)  to the tag using any xml api.

          }

    }

}

Start working with hibernate

There are few steps to start working with hibernate

1) pre-requisite for hibernate
2) Creation of Database / tables
3) Creation of POJO for tables
4) Mapping POJO to Database table
5) Configuration
6) Log4j configurations
7) Execute the example

1) Pre-requisite for hibernate 

a) The jdk1.5.x/1.6.x should be installed, JAVA_HOME and PATH should be set correctly.
b) Download and extract/install zip/tar file of Eclipse IDE (I used Galileo).
c) Download the following jars files from http://hibernate.org

ant-1.6.2.jar
ant-antlr-1.6.2.jar
ant-junit-1.6.2.jar
ant-launcher-1.6.2.jar
antlr-2.7.4.jar
ant-swing-1.6.2.jar
asm-3.3.jar
c3p0-0.8.5.jar
cglib-2.2.jar
cleanimports.jar
commons-collections-2.1.1.jar
commons-logging-1.0.4.jar
concurrent-1.3.2.jar
connector.jar
dom4j-1.5.2.jar
ehcache-1.1.jar
ejb3-persistence-3.3.2.Beta1.jar
hibernate-3.2.6.ga.jar
hibernate3.jar
hibernate-annotations-3.4.0.GA.jar
hibernate-commons-annotations-3.1.0.GA.jar
hibernate-core-3.3.0.SP1.jar
hibernate-entitymanager-3.4.0.GA.jar
hibernate-search-3.0.1.GA.jar
hibernate-validator-3.0.0.ga.jar
jaas.jar
jacc-1_0-fr.jar
jaxen-1.1-beta-4.jar
jboss-cache.jar
jboss-common.jar
jboss-jmx.jar
jboss-remoting.jar
jboss-system.jar
jdbc2_0-stdext.jar
jgroups-2.2.7.jar
jta.jar
junit-3.8.1.jar
log4j-1.2.9.jar
mysql-connector-java-3.0.16-ga-bin.jar
mysql-connector-java-3.1.6-bin.jar
oscache-2.1.jar
postgresql-8.2-504.jdbc3.jar
proxool-0.8.3.jar
swarmcache-1.0rc2.jar
versioncheck.jar
xerces-2.6.2.jar
xml-apis.jar

*some are not required e.g. if you are using mysql as your database then postgresql-8.2-504.jdbc3.jar is not required.

2) Creation of Database / tables  (Postgres SQL) :

|--------------------------------------------------------------------|
CREATE TABLE "public"."emp" (

id SERIAL,
name text,
dob date
PRIMARY KEY(id)
);

|--------------------------------------------------------------------|

3) Creation of POJO for tables  (Employee )

package net.vs.example; public class Employee { private Integer id; private String name; private Date dob; public Employee(){ } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Date Dob() { return dob; } public void Dob(Date dob) { this.date = date; }

4) Mapping POJO to Database table

You can use XML or annotations to define, how to map your class attributes to a database table.
Create the Employee.hbm.xml in the package net.vs.example and change it to the following
PostgreSQL Version:

xml version="1.0" encoding="UTF-8"?>

DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD

3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping>

<class name=net.vs.example.Employee table=emp>

<id name="id" column="id">

<generator class="sequence">

<param name="sequence"> emp_id_seq param>

generator>

id>

<property name="name" column = "name"/>

<property name="dob" column="dob" />

class>

hibernate-mapping>

5) Configuration

Create a file named “hibernate.cfg.xml” in your root directory
Insert the following in your hibernate file.

PostgreSQL Version:

xml version='1.0' encoding='UTF-8'?>

DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<property name="connection.url">

jdbc:postgresql://localhost:5432/myDB

property>

<property name="connection.username"> myuser property>

<property name="connection.driver_class">org.postgresql.Driverproperty>

<property name="dialect">org.hibernate.dialect.PostgreSQLDialectproperty>

<property name="connection.password">mypwdproperty>

<property name="hibernate.show_sql">trueproperty>

<mapping resource="employee.hbm.xmll" />

session-factory>

hibernate-configuration>

6) Log4j configurations

As you can see above we added the log4j library. This library does like a configuration file in thesource directory or it welcomes you with the following error.

log4j:WARN No appenders could be found for logger (TestClient).
log4j:WARN Please initialize the log4j system properly.

Create a file named log4j.properties in the root directory and insert the following:

### direct log messages to stdout ###

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.Target=System.out

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=debug, stdout

log4j.logger.org.hibernate=info

#log4j.logger.org.hibernate=debug

### log HQL query parser activity

#log4j.logger.org.hibernate.hql.ast.AST=debug

### log just the SQL

log4j.logger.org.hibernate.SQL=debug

### log JDBC bind parameters ###

log4j.logger.org.hibernate.type=info

### log schema export/update ###

log4j.logger.org.hibernate.tool.hbm2ddl=info

### log HQL parse trees

#log4j.logger.org.hibernate.hql=debug

### log cache activity ###

log4j.logger.org.hibernate.cache=info

### log transaction activity

#log4j.logger.org.hibernate.transaction=debug

### log JDBC resource acquisition

#log4j.logger.org.hibernate.jdbc=debug

### enable the following line if you want to track down connection ###

### leakages when using DriverManagerConnectionProvider ###

#log4j.logger.org.hibernate.connection.DriverManagerConnectionProvider=trace

7) Execute the example


TestHibernate.java

public class TestHibernate{

public static void main(String agrs[]) {

Session session = null;
try {

SessionFactory factory = new Configuration().configure().buildSessionFactory();
session = factory.openSession();

Employee emp = new Employee();
emp.setName("John");
emp.setDob(new Date());

session.save(emp);

} catch(Exception be){
be.printStackTrace();
}
finally {
// Actual contact insertion will happen at this step
if (null!=session){
session.flush();
session.close();
}

}

}

Cheers !

Why Hibernate ?

Hibernate, is Open Source Persistence technology and an Object-Relational Mapping (ORM) solution for JAVA. It is powerful, high performance O/R persistence and query engine. Working with Relational Database is complicated task with JDBC because there is mismatch between how data is represented in objects versus relational
database. So with JDBC, developer has to write code to map an object model's data representation to a relational data model and its corresponding database schema. At the other end Hibernate is flexible and powerful ORM solution to map Java classes to database tables.

Hibernate key features:

1) Hibernate 3.0 provides three type of facilities to query in database, via Hibernate Query Language(HQL), via Criteria Query and native SQL.
2) It also provides full support for projection/aggregation and subselects.
3) Hibernate can be used to develop/package and distribute the applications for free as it is under LGPL(GNU Lesser General Public License).
4) Mapping of Java objects with database tables and vice versa is called Transparent Persistence. It provides transparent persistence and developer does not need to write code explicitly to map database tables rows to application objects during communicating with Relational Databases. Using JDBC this need to be write manually with some lines of code.
5) Using JDBC, if there is any table / column / datbase change then developer need to write / modify the code many places. As table changed or database changed then it’s essential to change object structure as well as to change code written to map table-to-object/object-to-table.
Hibernate provides this mapping itself. The actual mapping between tables and application objects is done in XML files. If there is change in Database or in any table then the only need to change XML file properties.
6) Hibernate supports Automatic Versioning and Time Stamping, By database versioning one can be assured that the changes done by one person is not being roll
backed by another one unintentionally. Hibernate enables developer to define version type field to application, due to this defined field Hibernate updates version field of database table every time relational tuple is updated in form of Java class object to that table. So if two users retrieve same tuple and then modify it and one user save this modified tuple to database, version is automatically updated for this tuple by Hibernate. When other user tries to save updated tuple to database then it does not allow to save it because this user does not has updated data. In JDBC there is no check that always every user has updated data. This check has to be added by the developer.
7) Maintenance Cost reduses with Hibernate, With JDBC, it is developer’s responsibility to handle JDBC result set and convert it to Java objects
through code to use this persistent data in application. So with JDBC, mapping between Java objects and database tables is done manually. Hibernate reduces lines of code by maintaining object-table mapping itself and returns result to application in form of Java objects. It relieves programmer from manual handling of persistent data, hence reducing the development time and maintenance cost.


Main Disadvantages of Hibernate:

1) There will be a learning curve.
2) Hibernate is not for Data centric applications. For Instance if there is an application which used to use DB procedures and business logic at DB level not at Java object level then Its better not to choose hibernate, use JDBC instead.