Pages

Web Site Temple Gerator Software

http://www.artisteer.com/

Artisteer is the first and only Web design automation product that instantly creates fantastic looking, unique website templates and blog themes.

Chapter 2 [Hibernate]

Chapter 2

In previous chapter we presented hibernate philosophy, in this chapter we discuss implementation technique.

Starting a Hibernate project
: In some projects, the development of an application is driven by developers analyzing the business domain in object-oriented terms. In others, it’s heavily influenced by an existing relational data model: either a legacy database or a brandnew schema designed by a professional data modeler. There are many choices to be made, and the following questions need to be answered before you can start:
  • Can you start from scratch with a clean design of a new business requirement, or is legacy data and/or legacy application code present?
  • Can some of the necessary pieces be automatically generated from an existing artifact (for example, Java source from an existing database schema)? Can the database schema be generated from Java code and Hibernate mappingmetadata?
  • What kind of tool is available to support this work? What about other tools to support the full development cycle?
The following development scenarios are common:
  • Top down—In top-down development, you start with an existing domain model, its implementation in Java, and (ideally) complete freedom with respect to the database schema. You must create mapping metadata— either with XML files or by annotating the Java source—and then optionally let Hibernate’s hbm2ddl tool generate the database schema. In the absence of an existing database schema, this is the most comfortable development style for most Java developers. You may even use the Hibernate Tools to automatically refresh the database schema on every application restart in development.
  • Bottom up—Conversely, bottom-up development begins with an existing database schema and data model. In this case, the easiest way to proceed is to use the reverse-engineering tools to extract metadata from the database. This metadata can be used to generate XML mapping files, with hbm2hbmxml for example. With hbm2java, the Hibernate mapping metadata is used to generate Java persistent classes, and even data access objects—in other words, a skeleton for a Java persistence layer. Or, instead of writing to XML mapping files, annotated Java source code (EJB 3.0 entity classes) can be produced directly by the tools. However, not all class association details and Java-specific metainformation can be automatically generated from an SQL database schema with this strategy, so expect some manual work.
  • Middle out—The Hibernate XML mapping metadata provides sufficient information to completely deduce the database schema and to generate the Java source code for the persistence layer of the application. Furthermore, the XML mapping document isn’t too verbose. Hence, some architects and developers prefer middle-out development, where they begin with handwritten Hibernate XML mapping files, and then generate the database schema using hbm2ddl and Java classes using hbm2java. The Hibernate XML mapping files are constantly updated during development, and other artifacts are generated from this master definition. Additional business logic or database objects are added through subclassing and auxiliary DDL. This developmentstyle can be recommended only for the seasoned Hibernate expert.
  • Meet in the middle—The most difficult scenario is combining existing Java classes and an existing database schema. In this case, there is little that the Hibernate toolset can do to help. It is, of course, not possible to map arbitrary Java domain models to a given schema, so this scenario usually requires at least some refactoring of the Java classes, database schema, or both. The mapping metadata will almost certainly need to be written by hand and in XML files (though it might be possible to use annotations if there is a close match). This can be an incredibly painful scenario, and it is,fortunately, exceedingly rare.
We will use bottom up approach to make a example project and describe different aspects of hibernate.
Reverse engineering a legacy database: Your first step when mapping a legacy database likely involves an automatic reverse-engineering procedure. After all, an entity schema already exists in your database system. To make this easier, Hibernate has a set of tools that can read a
schema and produce various artifacts from this metadata, including XML mapping files and Java source code. All of this is template-based, so many customizations are possible. You can control the reverse-engineering process with tools and tasks.

The HibernateToolTask has many more options related to reverse engineering as to how XML mapping files, Java code, or even whole application skeletons can be generated automatically from an existing database schema.

Creating a database configuration: Let’s assume that you have a new WORKDIR with nothing but the lib directory (and its usual contents) and an empty src directory. To generate mappings and code from an existing database, you first need to create a configuration file that contains your database connection settings:


Hibernate Tutorial

http://docs.jboss.org/hibernate/stable/core.old/reference/en/html/tutorial.html
http://www.jboss.org/file-access/default/members/jbossclustering/freezone/docs/hibernate-jbosscache-guide-3.pdf

This article is dedicated for learning Hibernate in a very short time and quick way. Important topics and summary of Hibernate technology are presented here.

----------------------------------------------------------------------------------------------------
Abstract
Working with object-oriented software and a relational database can be cumbersome and time consuming in today's enterprise environments. Hibernate is an object/relational mapping tool for Java environments. The term object/relational mapping (ORM) refers to the technique of mapping a data representation from an object model to a relational data model with a SQL-based schema.

Hibernate not only takes care of the mapping from Java classes to database tables (and from Java data types to SQL data types), but also provides data query and retrieval facilities and can significantly reduce development time otherwise spent with manual data handling in SQL and JDBC.

Hibernates goal is to relieve the developer from 95 percent of common data persistence related programming tasks. Hibernate may not be the best solution for data-centric applications that only use stored-procedures to implement the business logic in the database, it is most useful with object-oriented domain models and business logic in the Java-based middle-tier. However, Hibernate can certainly help you to remove or encapsulate vendor-specific SQL code and will help with the common task of result set translation from a tabular representation to a graph of objects.

Modern relational databases provide a structured representation of persistent data, enabling the manipulating, sorting, searching, and aggregating of data. Database management systems are responsible for managing concurrency and data integrity; they’re responsible for sharing data between multiple users and multiple applications. They guarantee the integrity of the data through integrity rules that have been implemented with constraints. A database management system provides data-level security.

Chapter 1.
The paradigm mismatch:
The object/relational paradigm mismatch can be broken into several parts, we will discuss each of them. Let’s start our exploration with a simple example that is problem free Suppose you have to design and implement an online e-commerce application. In this application, you need a class to represent information about a user of the system, and another class to represent information about the user’s billing details. You can realize that a User has many BillingDetails. You can navigate the relationship between the classes in both directions.


public class User {
private String username;
private String name;
private String address;
private Set billingDetails;
// Accessor methods (getter/setter), business methods, etc.
...
}


public class BillingDetails {
private String accountNumber;
private String accountName;
private String accountType;
private User user;
// Accessor methods (getter/setter), business methods, etc.
...
}

It’s easy to come up with a good SQL schema design for this case:
create table USERS (
USERNAME varchar(15) not null primary key,
NAME varchar(50) not null,
ADDRESS varchar(100)
)

create table BILLING_DETAILS (
ACCOUNT_NUMBER varchar(10) not null primary key,
ACCOUNT_NAME varchar(50) not null,
ACCOUNT_TYPE varchar(2) not null,
USERNAME varchar(15) foreign key references USERS
)

The relationship between the two entities is represented as the foreign key, USERNAME, in BILLING_DETAILS. For this simple domain model, the object/relational mismatch is barely in evidence; it’s straightforward to write JDBC code to insert, update, and delete information about users and billing details.

The most glaringly obvious problem with our current implementation is that we’ve designed an address as a simple String value. In most systems, it’s necessary to store street, city, state, country, and ZIP code information separately. Of course, we could add these properties directly to the User class, but because it’s highly likely that other classes in the system will also carry address information, it makes more sense to create a separate Address class.

Should we also add an ADDRESS table? Not necessarily. It’s common to keep address information in the USERS table, in individual columns. This design is likely to perform better, because a table join isn’t needed if you want to retrieve the user and address in a single query. The nicest solution may even be to create a user-defined SQL datatype to represent addresses, and to use a single column of that new type in the USERS table instead of several new columns.
Basically, we have the choice of adding either several columns or a single column (of a new SQL datatype). This is clearly a problem of granularity.

  1. The problem of granularity: Granularity refers to the relative size of the types you’re working with.

    Let’s return to our example. Adding a new datatype to our database catalog,
    to store Address Java instances in a single column, sounds like the best
    approach. A new Address type (class) in Java and a new ADDRESS SQL datatype
    should guarantee interoperability. However, you’ll find various problems if you
    check the support for user-defined datatypes (UDT) in today’s SQL database
    management systems.

    Let’s return to our example. Adding a new datatype to our database catalog, to store Address Java instances in a single column, sounds like the best approach. A new Address type (class) in Java and a new ADDRESS SQL datatype should guarantee interoperability. However, you’ll find various problems if you check the support for user-defined datatypes (UDT) in today’s SQL database management systems.

    UDT support is one of a number of so-called object-relational extensions to traditional SQL. This term alone is confusing, because it means that the database management system has (or is supposed to support) a sophisticated datatype system— something you take for granted if somebody sells you a system that can handle data in a relational fashion. Unfortunately, UDT support is a somewhat obscure feature of most SQL database management systems and certainly isn’t portable between different systems. Furthermore, the SQL standard supports user-defined datatypes, but poorly.

    This limitation isn’t the fault of the relational data model. You can consider the failure to standardize such an important piece of functionality as fallout from the object-relational database wars between vendors in the mid-1990s. Today, most developers accept that SQL products have limited type systems—no questions asked. However, even with a sophisticated UDT system in our SQL database management system, we would likely still duplicate the type declarations, writing the new type in Java and again in SQL. Attempts to find a solution for the Java space, such as SQLJ, unfortunately, have not had much success.

    For these and whatever other reasons, use of UDTs or Java types inside an SQL database isn’t common practice in the industry at this time, and it’s unlikely that you’ll encounter a legacy schema that makes extensive use of UDTs. We therefore can’t and won’t store instances of our new Address class in a single new column that has the same datatype as the Java layer.

    Our pragmatic solution for this problem has several columns of built-in vendor-defined SQL types (such as boolean, numeric, and string datatypes). The USERS table is usually defined as follows:

    create table USERS (
    USERNAME varchar(15) not null primary key,
    NAME varchar(50) not null,
    ADDRESS_STREET varchar(50),
    ADDRESS_CITY varchar(15),
    ADDRESS_STATE varchar(15),
    ADDRESS_ZIPCODE varchar(5),
    ADDRESS_COUNTRY varchar(15)
    )
  2. The problem of subtypes:The result of this mismatch of subtypes is that the inheritance structure in your model must be persisted in an SQL database that doesn’t offer an inheritance strategy.
  3. The problem of identity: It occurs when we need to check whether two objects are identical. There are three ways to tackle this problem: two in the Java world and one in our SQL database. As expected, they work together only with some help.
    Java objects define two different notions of sameness:
    • Object identity (roughly equivalent to memory location, checked with a==b)
    • Equality as determined by the implementation of the equals() method(also called equality by value)
    On the other hand, the identity of a database row is expressed as the primary key
    value.
    Neither equals() nor == is naturally equivalent to the primary key value. It’s common for several nonidentical objects to simultaneously represent the same row of the database, for example, in concurrently running application threads. Furthermore, some subtle difficulties are involved in implementing equals() correctly for a persistent class. Let’s discuss another problem related to database identity with an example. In our table definition for USERS, we used USERNAME as a primary key. Unfortunately, this decision makes it difficult to change a username; we need to update not only the USERNAME column in USERS, but also the foreign key column in BILLING_DETAILS.
  4. Problems relating to associations: Object-oriented languages represent associations using object references; but in the relational world, an association is represented as a foreign key column, with copies of key values (and a constraint to guarantee integrity). There are substantial differences between the two representations. Object references are inherently directional; the association is from one object to the other. They’re pointers. If an association between objects should be navigable in both directions, you must define the association twice, once in each of the associated classes.
    On the other hand, foreign key associations aren’t by nature directional. Navigation has no meaning for a relational data model because you can create arbitrary data associations with table joins and projection. The challenge is to bridge a completely open data model, which is independent of the application that works with the data, to an application-dependent navigational model, a constrained view of the associations needed by this particular application.

    It isn’t possible to determine the multiplicity of a unidirectional association by looking only at the Java classes. Java associations can have many-to-many multiplicity. For example, the classes could look like this:
    public class User {
    private Set billingDetails;
    ...
    }

    public class BillingDetails {
    private Set users;
    ...
    }Table associations, on the other hand, are always one-to-many or one-to-one. You can
    see the multiplicity immediately by looking at the foreign key definition.
    If you wish to represent a many-to-many association in a relational database, you must introduce a new table, called a link table. This table doesn’t appear anywhere in the domain model.
  5. The problem of data navigation: There is a fundamental difference in the way you access data in Java and in a relational database. In Java, when you access a user’s billing information, you call aUser.getBillingDetails().getAccountNumber() or something similar. This is the most natural way to access object-oriented data, and it’s often described as walking the object network. You navigate from one object to another, following pointers between instances. Unfortunately, this isn’t an efficient way to retrieve data from an SQL database.
    The single most important thing you can do to improve the performance of data access code is to minimize the number of requests to the database. The most obvious way to do this is to minimize the number of SQL queries. (Of course, there are other more sophisticated ways that follow as a second step.)
    Therefore, efficient access to relational data with SQL usually requires joins between the tables of interest. The number of tables included in the join when retrieving data determines the depth of the object network you can navigate in memory. For example, if you need to retrieve a User and aren’t interested in the user’s billing information, you can write this simple query:
    select * from USERS u where u.USER_ID = 123

    On the other hand, if you need to retrieve a User and then subsequently visit each of the associated BillingDetails instances (let’s say, to list all the user’s credit cards), you write a different query:

    select *
    from USERS u
    left outer join BILLING_DETAILS bd on bd.USER_ID = u.USER_ID
    where u.USER_ID = 123

    As you can see, to efficiently use joins you need to know what portion of the object network you plan to access when you retrieve the initial User—this is before you start navigating the object network!
    On the other hand, any object persistence solution provides functionality for fetching the data of associated objects only when the object is first accessed. However, this piecemeal style of data access is fundamentally inefficient in the context of a relational database, because it requires executing one statement for each node or collection of the object network that is accessed. This is the dreaded n+1 selects problem.
    This mismatch in the way you access objects in Java and in a relational database is perhaps the single most common source of performance problems in Java applications. There is a natural tension between too many selects and too big selects, which retrieve unnecessary information into memory. Yet, although we’ve been blessed with innumerable books and magazine articles advising us to use StringBuffer for string concatenation, it seems impossible to find any advice about strategies for avoiding the n+1 selects problem. Fortunately, Hibernate provides sophisticated features for efficiently and transparently fetching networks of objects from the database to the application accessing them.
  6. The cost of the mismatch: We now have quite a list of object/relational mismatch problems, and it will be costly (in time and effort) to find solutions, as you may know from experience.
    This cost is often underestimated, and we think this is a major reason for many failed software projects. In our experience (regularly confirmed by developers we talk to), the main purpose of up to 30 percent of the Java application code written is to handle the tedious SQL/JDBC and manual bridging of the object/relational paradigm mismatch. Despite all this effort, the end result still doesn’t feel quite right. We’ve seen projects nearly sink due to the complexity and inflexibility of their database abstraction layers. We also see Java developers (and DBAs) quickly lose their confidence when design decisions about the persistence strategy for a project have to be made.
    One of the major costs is in the area of modeling. The relational and domain models must both encompass the same business entities, but an object-oriented purist will model these entities in a different way than an experienced relational data modeler would. The usual solution to this problem is to bend and twist the domain model and the implemented classes until they match the SQL database schema. (Which, following the principle of data independence, is certainly a safe long-term choice.)
    This can be done successfully, but only at the cost of losing some of the advantages of object orientation. Keep in mind that relational modeling is underpinned by relational theory. Object orientation has no such rigorous mathematical definition or body of theoretical work, so we can’t look to mathematics to explain how we should bridge the gap between the two paradigms—there is no elegant transformation waiting to be discovered. (Doing away with Java and SQL, and starting from scratch isn’t considered elegant.)
    The domain modeling mismatch isn’t the only source of the inflexibility and the lost productivity that lead to higher costs. A further cause is the JDBC API itself. JDBC and SQL provide a statement-oriented (that is, command-oriented) approach to moving data to and from an SQL database. If you want to query or manipulate data, the tables and columns involved must be specified at least three times (insert, update, select), adding to the time required for design and implementation. The distinct dialects for every SQL database management system don’t improve the situation.

Object/relational mapping:If we looked at the alternative techniques for object persistence the solution which is the best is ORM and we use it with Hibernate. Despite its long history (the first research papers were published in the late 1980s), the terms for ORM used by developers vary. Some call it object relational mapping, others prefer the simple object mapping; we exclusively usethe term object/relational mapping and its acronym, ORM. The slash stresses the mismatch problem that occurs when the two worlds collide.

  • What is ORM? In a nutshell, object/relational mapping is the automated (and transparent) persistence of objects in a Java application to the tables in a relational database, using metadata that describes the mapping between the objects and the database.

    ORM, in essence, works by (reversibly) transforming data from one representation to another. This implies certain performance penalties. However, if ORM is implemented as middleware, there are many opportunities for optimization that wouldn’t exist for a hand-coded persistence layer. The provision and management of metadata that governs the transformation adds to the overhead at development time, but the cost is less than equivalent costs involved in maintaining a hand-coded solution. (And even object databases require significant amounts of metadata.)

    An ORM solution consists of the following four pieces:

    • An API for performing basic CRUD operations on objects of persistent classes
    • A language or API for specifying queries that refer to classes and properties of classes
    • A facility for specifying mapping metadata
    • A technique for the ORM implementation to interact with transactional objects to perform dirty checking, lazy association fetching, and other optimization functions

    We’re using the term full ORM to include any persistence layer where SQL is automatically generated from a metadata-based description. We aren’t including persistence layers where the object/relational mapping problem is solved manually by developers hand-coding SQL with JDBC. With ORM, the application interacts with the ORM APIs and the domain model classes and is abstracted from the underlying SQL/JDBC. Depending on the features or the particular implementation, the ORM engine may also take on responsibility for issues such as optimistic locking and caching, relieving the application of these concerns entirely.

    Let’s look at the various ways ORM can be implemented. Mark Fussel (Fussel, 1997), a developer in the field of ORM, defined the following four levels of ORM quality. We have slightly rewritten his descriptions and put them in the context of today’s Java application development.
    • Pure relational:The whole application, including the user interface, is designed around the relational model and SQL-based relational operations. This approach, despite its deficiencies for large systems, can be an excellent solution for simple applications where a low level of code reuse is tolerable. Direct SQL can be fine-tuned in every aspect, but the drawbacks, such as lack of portability and maintainability, are significant, especially in the long run. Applications in this category often make heavy use of stored procedures, shifting some of the work out of the business layer and into the database.
    • Light object mapping: Entities are represented as classes that are mapped manually to the relational tables. Hand-coded SQL/JDBC is hidden from the business logic using wellknown design patterns. This approach is extremely widespread and is successful for applications with a small number of entities, or applications with generic, metadata-driven data models. Stored procedures may have a place in this kind of application.
    • Medium object mapping: The application is designed around an object model. SQL is generated at build time using a code-generation tool, or at runtime by framework code. Associations between objects are supported by the persistence mechanism, and queries may be specified using an object-oriented expression language. Objects are cached by the persistence layer. A great many ORM products and homegrown persistence layers support at least this level of functionality. It’s well suited to medium-sized applications with some complex transactions, particularly when portability between different database products is important. These applications usually don’t use stored procedures.
    • Full object mapping: Full object mapping supports sophisticated object modeling: composition, inheritance, polymorphism, and persistence by reachability. The persistence layer implements transparent persistence; persistent classes do not inherit from anyspecial base class or have to implement a special interface. Efficient fetching strategies (lazy, eager, and prefetching) and caching strategies are implemented transparently to the application. This level of functionality can hardly be achieved by a homegrown persistence layer—it’s equivalent to years of development time. A number of commercial and open source Java ORM tools have achieved this level of quality.

Now let us look at the problems we expect to be solved by a tool that achieves full object mapping:
The following list of issues, which we’ll call the ORM problems, identifies the fundamental questions resolved by a full object/relational mapping tool in a Java environment. Particular ORM tools may provide extra functionality (for example, aggressive caching), but this is a reasonably exhaustive list of the conceptual issues and questions that are specific to object/relational mapping.
  1. What do persistent classes look like? How transparent is the persistence tool?Do we have to adopt a programming model and conventions for classes ofthe business domain?
  2. How is mapping metadata defined? Because the object/relational transformation is governed entirely by metadata, the format and definition of this metadata is important. Should an ORM tool provide a GUI interface to manipulate the metadata graphically? Or are there better approaches to metadata definition?
  3. How do object identity and equality relate to database (primary key) identity? How do we map instances of particular classes to particular table rows?
  4. How should we map class inheritance hierarchies? There are several standard strategies. What about polymorphic associations, abstract classes, and interfaces?
  5. How does the persistence logic interact at runtime with the objects of the business domain? This is a problem of generic programming, and there are a number of solutions including source generation, runtime reflection, runtime bytecode generation, and build-time bytecode enhancement. The solution to this problem may affect your build process (but, preferably, shouldn’t otherwise affect you as a user).
  6. What is the lifecycle of a persistent object? Does the lifecycle of some objects depend upon the lifecycle of other associated objects? How do we translate the lifecycle of an object to the lifecycle of a database row?
  7. What facilities are provided for sorting, searching, and aggregating? The application could do some of these things in memory, but efficient use of relational technology requires that this work often be performed by the database.
  8. How do we efficiently retrieve data with associations? Efficient access to relational data is usually accomplished via table joins. Object-oriented applications usually access data by navigating an object network. Two data access patterns should be avoided when possible: the n+1 selects problem, and its complement, the Cartesian product problem (fetching too much data in a single select).
Two additional issues
that impose fundamental constraints on the design and architecture of an ORM tool are common to any data access technology:
  • Transactions and concurrency
  • Cache management (and concurrency)

Why ORM: A supposed advantage of ORM is that it shields developers from messy SQL. This view holds that object-oriented developers can’t be expected to understand SQL or relational databases well, and that they find SQL somehow offensive. On the contrary, we believe that Java developers must have a sufficient level of familiarity with—and appreciation of—relational modeling and SQL in order to work with ORM. ORM is an advanced technique to be used by developers who have already done it the hard way. To use Hibernate effectively, you must be able to view and interpret the SQL statements it issues and understand the implications for performance.

Now, let’s look at some of the benefits of ORM and Hibernate-
  1. Productivity: Persistence-related code can be perhaps the most tedious code in a Java application. Hibernate eliminates much of the grunt work (more than you’d expect) and lets you concentrate on the business problem.

    No matter which application-development strategy you prefer—top-down, starting with a domain model, or bottom-up, starting with an existing database schema—Hibernate, used together with the appropriate tools, will significantly reduce development time.
  2. Maintainability: Fewer lines of code (LOC) make the system more understandable, because it emphasizes business logic rather than plumbing. Most important, a system with less code is easier to refactor. Automated object/relational persistence substantially reduces LOC. Of course, counting lines of code is a debatable way of measuring application complexity.

    However, there are other reasons that a Hibernate application is more maintainable. In systems with hand-coded persistence, an inevitable tension exists between the relational representation and the object model implementing the domain. Changes to one almost always involve changes to the other, and often the design of one representation is compromised to accommodate the existence of the other. (What almost always happens in practice is that the object model of the domain is compromised.) ORM provides a buffer between the two models, allowing more elegant use of object orientation on the Java side, and insulating each model from minor changes to the other.
  3. Performance: A common claim is that hand-coded persistence can always be at least as fast, and can often be faster, than automated persistence. This is true in the same sense that it’s true that assembly code can always be at least as fast as Java code, or a handwritten parser can always be at least as fast as a parser generated by YACC or ANTLR—in other words, it’s beside the point. The unspoken implication of the claim is that hand-coded persistence will perform at least as well in an actual application. But this implication will be true only if the effort required to implement at-least-as-fast hand-coded persistence is similar to the amount of effort involved in utilizing an automated solution. The really interesting question is what happens when we consider time and budget constraints?
    Given a persistence task, many optimizations are possible. Some (such as query hints) are much easier to achieve with hand-coded SQL/JDBC. Most optimizations, however, are much easier to achieve with automated ORM. In a project with time constraints, hand-coded persistence usually allows you to make some optimizations. Hibernate allows many more optimizations to be used all the time. Furthermore, automated persistence improves developer productivity so much that you can spend more time hand-optimizing the few remaining bottlenecks.
    Finally, the people who implemented your ORM software probably had much more time to investigate performance optimizations than you have. Did you know, for instance, that pooling PreparedStatement instances results in a significant performance increase for the DB2 JDBC driver but breaks the InterBase JDBC driver? Did you realize that updating only the changed columns of a table can be significantly faster for some databases but potentially slower for others? In your handcrafted solution, how easy is it to experiment with the impact of these various strategies?
  4. Vendor independence: An ORM abstracts your application away from the underlying SQL database and SQL dialect. If the tool supports a number of different databases (and most do), this confers a certain level of portability on your application. You shouldn’t necessarily expect write-once/run-anywhere, because the capabilities of databases differ, and achieving full portability would require sacrificing some of the strength of the more powerful platforms. Nevertheless, it’s usually much easier to develop a cross-platform application using ORM. Even if you don’t require cross-platform operation, an ORM can still help mitigate some of the risks associated with vendor lock-in.

    In addition, database independence helps in development scenarios where developers use a lightweight local database but deploy for production on a different database.
Introducing Hibernate, EJB3, and JPA: Hibernate is a full object/relational mapping tool that provides all the previously listed ORM benefits. The API you’re working with in Hibernate is native and designed by the Hibernate developers. The same is true for the query interfaces and query languages, and for how object/relational mapping metadata is defined.

Before you start your first project with Hibernate, you should consider the EJB 3.0 standard and its subspecification, Java Persistence. Let’s go back in history and see how this new standard came into existence.

Understanding the standards:First, it’s difficult (if not impossible) to compare a specification and a product. The questions that should be asked are, “Does Hibernate implement the EJB 3.0 specification, and what is the impact on my project? Do I have to use one or the other?”

The new EJB 3.0 specification comes in several parts: The first part defines the new EJB programming model for session beans and message-driven beans, the deployment rules, and so on. The second part of the specification deals with persistence exclusively: entities, object/relational mapping metadata, persistenc manager interfaces, and the query language. This second part is called Java Persistence API (JPA), probably because its interfaces are in the package javax.persistence. We’ll use this acronym throughout the tutorial.

This separation also exists in EJB 3.0 products; some implement a full EJB 3.0 container that supports all parts of the specification, and other products may implement only the Java Persistence part. Two important principles were designed into the new standard:
  • JPA engines should be pluggable, which means you should be able to takeout one product and replace it with another if you aren’t satisfied—even if you want to stay with the same EJB 3.0 container or Java EE 5.0 application server.
  • JPA engines should be able to run outside of an EJB 3.0 (or any other) runtime environment, without a container in plain standard Java.
The consequences of this design are that there are more options for developers and architects, which drives competition and therefore improves overall quality of products. Of course, actual products also offer features that go beyond the specification as vendor-specific extensions (such as for performance tuning, or because the vendor has a focus on a particular vertical problem space).

Hibernate implements Java Persistence, and because a JPA engine must be pluggable, new and interesting combinations of software are possible. You can select from various Hibernate software modules and combine them depending on your project’s technical and business requirements.

Hibernate Core: The Hibernate Core is also known as Hibernate 3.2.x, or Hibernate. It’s the base service for persistence, with its native API and its mapping metadata stored in XML files. It has a query language called HQL (almost the same as SQL), as well as programmatic query interfaces for Criteria and Example queries. There are hundreds of options and features available for everything, as Hibernate Core is really the foundation and the platform all other modules are built on. You can use Hibernate Core on its own, independent from any framework or any particular runtime environment with all JDKs. It works in every Java EE/J2EE application server, in Swing applications, in a simple servlet container, and so on. As long as you can configure a data source for Hibernate, it works. Your application code (in your persistence layer) will use Hibernate APIs and queries, and your mapping metadata is written in native Hibernate XML files.

Hibernate Annotations:
A new way to define application metadata became available with JDK 5.0: type-safe annotations embedded directly in the Java source code. Many Hibernate users are already familiar with this concept, as the XDoclet software supports Javadoc metadata
attributes and a preprocessor at compile time (which, for Hibernate, generates XML mapping files).

With the Hibernate Annotations package on top of Hibernate Core, you can now use type-safe JDK 5.0 metadata as a replacement or in addition to native Hibernate XML mapping files.

The JPA specification defines object/relational mapping metadata syntax and semantics, with the primary mechanism being JDK 5.0 annotations. (Yes, JDK 5.0 is required for Java EE 5.0 and EJB 3.0.) Naturally, the Hibernate Annotations are a set of basic annotations that implement the JPA standard, and they’re also a set of extension annotations you need for more advanced and exotic Hibernate mappings and tuning.

You can use Hibernate Core and Hibernate Annotations to reduce your lines of code for mapping metadata, compared to the native XML files, and you may like the better refactoring capabilities of annotations. You can use only JPA annotations, or you can add a Hibernate extension annotation if complete portability isn’t your primary concern. (In practice, you should embrace the product you’ve chosen instead of denying its existence at all times.)

The JPA specification also defines programming interfaces, lifecycle rules for persistent objects, and query features. The Hibernate implementation for this part of JPA is available as Hibernate EntityManager, another optional module you can stack on top of Hibernate Core. You can fall back when a plain Hibernate interface, or even a JDBC Connection is needed. Hibernate’s native features are a superset of the JPA persistence features in every respect. (The simple fact is that Hibernate EntityManager is a small wrapper around Hibernate Core that provides JPA compatibility.)

Working with standardized interfaces and using a standardized query language has the benefit that you can execute your JPA-compatible persistence layer with any EJB 3.0 compliant application server. Or, you can use JPA outside of any particular standardized runtime environment in plain Java (which really means everywhere Hibernate Core can be used).

Hibernate Annotations should be considered in combination with Hibernate EntityManager. It’s unusual that you’d write your application code against JPA interfaces and with JPA queries, and not create most of your mappings with JPA annotations.


Chapter 2

Starting a Hibernate project: In some projects, the development of an application is driven by developers analyzing the business domain in object-oriented terms. In others, it’s heavily influenced by an existing relational data model: either a legacy database or a brandnew schema designed by a professional data modeler. There are many choices to be made, and the following questions need to be answered before you can start:
  • Can you start from scratch with a clean design of a new business requirement, or is legacy data and/or legacy application code present?
  • Can some of the necessary pieces be automatically generated from an existing artifact (for example, Java source from an existing database schema)? Can the database schema be generated from Java code and Hibernate mapping metadata?
  • What kind of tool is available to support this work? What about other tools to support the full development cycle?
The following development scenarios are common:
  • Top down—In top-down development, you start with an existing domain model, its implementation in Java, and (ideally) complete freedom with respect to the database schema. You must create mapping metadata— either with XML files or by annotating the Java source—and then optionally let Hibernate’s hbm2ddl tool generate the database schema. In the absence of an existing database schema, this is the most comfortable development style for most Java developers. You may even use the Hibernate Tools to automatically refresh the database schema on every application restart in development.
  • Bottom up—Conversely, bottom-up development begins with an existing database schema and data model. In this case, the easiest way to proceed is to use the reverse-engineering tools to extract metadata from the database. This metadata can be used to generate XML mapping files, with hbm2hbmxml for example. With hbm2java, the Hibernate mapping metadata is used to generate Java persistent classes, and even data access objects—in other words, a skeleton for a Java persistence layer. Or, instead of writing to XML mapping files, annotated Java source code (EJB 3.0 entity classes) can be produced directly by the tools. However, not all class association details and Java-specific metainformation can be automatically generated from an SQL database schema with this strategy, so expect some manual work.
  • Middle out—The Hibernate XML mapping metadata provides sufficient information to completely deduce the database schema and to generate the Java source code for the persistence layer of the application. Furthermore, the XML mapping document isn’t too verbose. Hence, some architects and developers prefer middle-out development, where they begin with handwritten Hibernate XML mapping files, and then generate the database schema using hbm2ddl and Java classes using hbm2java. The Hibernate XML mapping files are constantly updated during development, and other artifacts are generated from this master definition. Additional business logic or database objects are added through subclassing and auxiliary DDL. This development style can be recommended only for the seasoned Hibernate expert.
  • Meet in the middle—The most difficult scenario is combining existing Java classes and an existing database schema. In this case, there is little that the Hibernate toolset can do to help. It is, of course, not possible to map arbitrary Java domain models to a given schema, so this scenario usually requires at least some refactoring of the Java classes, database schema, or both. The mapping metadata will almost certainly need to be written by hand and in XML files (though it might be possible to use annotations if there is a close match). This can be an incredibly painful scenario, and it is, fortunately, exceedingly rare.
We will use bottom up approach to make a example project and describe different aspects of hibernate.
Reverse engineering a legacy database:

Research on Crawler | document categorization

altra vista* (this is most important and top)
google
yahoo
nutch
ubicrawl
crawlwave

search these crawlers in http://scholar.google.com/

search research materials | scholar.google.com

http://scholar.google.com/

Google Chart API

This is used for drawing chart dynamically using Google API.
http://chart.apis.google.com/chart?cht=p3&chd=t:70,30&chs=250x100&chl=Hello|World
http://code.google.com/apis/chart/

Interesting and thundaring news

http://pakalert.wordpress.com/2009/01/19/video-illuminati-exposed/

Arale, a Java web spider | Crawler

While many bots around are focused on page indexing, Arale is primarly designed for personal use. It fits the needs of advanced web surfers and web developers. Some real life cases are:

  • downloading only images, videos, mp3 or zip files from a site.
  • manuals, articles, ebooks fragmented in many files to discourage download.
  • user-unfriendly sites. Popups, banners and tricky scripts annoying you before you can download a resource.

Multithreaded means that Arale can download more than one file simultaneously. Arale can easily saturate your bandwidth, thus providing the fastest possible download speed for your internet connection.
http://flavio.tordini.org/arale

KD Tree

In computer science, a kd-tree (short for k-dimensional tree) is a space-partitioningdata structure for organizing points in a k-dimensional space. kd-trees are a useful data structure for several applications, such as searches involving a multidimensional search key (e.g. range searches and nearest neighbor searches). kd-trees are a special case of BSP trees.
http://en.wikipedia.org/wiki/Kd-tree


Geocoding

Geocoding is the process of finding associated geographic coordinates (often expressed as latitude and longitude) from other geographic data, such as street addresses, or zip codes (postal codes). With geographic coordinates the features can be mapped and entered into Geographic Information Systems, or the coordinates can be embedded into media such as digital photographs via geotagging.
Reverse geocoding is the opposite: finding an associated textual location such as a street address, from geographic coordinates.
A geocoder is a piece of software or a (web) service that helps in this process.
http://en.wikipedia.org/wiki/Geocoding
http://googlemapsapi.blogspot.com/2006/06/geocoding-at-last.html

Developing Location Based Services: Introducing the Location API for J2ME

captures the mobile phone's GPS coordinates and updates a web server
The first part of the article will show how to build, configure and deploy a MIDlet that captures the mobile phone's GPS coordinates and updates a web server with the new data using the Generic Connection Framework (GCF) over the HTTP protocol. In the second part you will learn how to calculate the device's heading and how to visualize the its location on an AJAX powered Google Maps Mashup.
http://mobiforge.com/developing/story/developing-location-based-services-introducing-location-api-j2me


Google Maps Latitude, Longitude Popup
Simply click on the map on a location and it will provide you with the latitude and longitude in the callout window.
http://www.gorissen.info/Pierre/maps/googleMapLocation.php
http://conversationswithmyself.com/googleMapDemo.html
http://www.evolt.org/article/Javascript_to_Parse_URLs_in_the_Browser/17/14435/?format=print

অনলাইন দর্শনার্থীর সংখ্যা দেখা | See number of online viewer

আপনার ওয়েবসাইটে বর্তমানে কতজন দর্শনার্থী দেখছে তা যদি আপনার ওয়েবসাইটেই দেখা যায় তাহলে কেমন হয়। এজন্য http://www.myonlineusers.com/ এ লগইন করুন। এবার Site address এর টেক্টট বক্সে http:// সহ আপনার ওয়েবসাইটের ঠিকানা লিখুন এবং Get the Code! button বাটনে ক্লিক করুন তাহলে প্রোগ্রামিং সংকেত পাবেন। এখন উক্ত সংকেত কপি করে আপনার ওয়েবপেজের প্রথম পেজে রাখুন এবং হোষ্টিং করুন। এখন থেকে আপনার ওয়েবসাইট যখন যত দর্শনার্থী দেখবে তখন তত জনের সংখ্যা দেখা যাবে।

ওয়েবপেজের স্ক্রিনশট নেয়ার software | Take screen short of webpage with a simple software

http://www.websitescreenshots.com
থেকে ৫৮২ কিলোবাইটের ওয়েবশট সফটওয়্যারটি বিনামূল্যে ডাউনলোড করে ইনষ্টল করে নিন। ইনষ্টল করার পরে এটাকে আপনি পোর্টেবল হিসাবেও ব্যবহার করতে পারেন। এবার সফটওয়্যারটি চালু করে Url অংশে ওয়েবপেজের ঠিকানা, Output এ ইমেজের নাম ও কিধরনের ফরম্যাটে ইমেজ সেভ করতে চান তা দিন এবং Image এ ইমেজ সাইজ, এবং Browser এ কত রেজুলেশনের ব্রাউজ করতে চান তা দিয়ে Start বাটনে ক্লিক করুন। তাহলে কিছুক্ষণের মধ্যে আপনার হিসাবমত ইমেজ তৈরী হয়ে যাবে।

JMeter Tutorial | Load Testing your Applications with Apache JMeter

http://fredpuls.com/site/softwaredevelopment/java/test/test_jmeter_quick_start.htm
http://javaboutique.internet.com/tutorials/JMeter/index.html
http://www.scribd.com/doc/258124/jmeter-distributed-testing-step-by-step
http://jakarta.apache.org/jmeter/usermanual/index.html

Frequently visited sites by Bangladeshi people | xampp | yahoo | zia international airport

xampp: http://www.apachefriends.org/en/xampp.html
yahoo: yahoo
zia international airport: http://www.flightstats.com/go/Airport/airportDetails.do?airportCode=DAC

Frequently visited sites by Bangladeshi people | prothom alo | qatar airways | rajuk | songs.pk | the daily star | utube | valentine sms | wikipedia

prothom alo: http://www.prothom-alo.com/
qatar airways: http://www.qatarairways.com/global/en/homepage.html
rajuk: http://www.rajukdhaka.gov.bd/index.htm
songs.pk: http://www.songs.pk/
the daily star: http://www.thedailystar.net/newDesign/index.php
utube: http://www.youtube.com/
valentine sms: http://www.stvalentinesday.org/valentines-day-sms.html
wikipedia: http://www.stvalentinesday.org/valentines-day-sms.html

Frequently visited sites by Bangladeshi people : ittefaq | jaijaidin | kaspersky | love sms | mail.yahoo.com | national university | online university

ittefaq: http://www.ittefaq.com/content/2009/05/10/
jaijaidin: http://www.jaijaidin.com/
kaspersky :http://www.kaspersky.com/af/globalstore?thru=reseller%3Dgoogle_aw%26gclid%3DCIbyisKysZoCFYM_3godanaLcQ
love sms: http://www.lovelysms.com/
mail.yahoo.com: https://login.yahoo.com/config/login_verify2?&.src=ym
national university: http://www.nu.edu.bd/
online university: http://onlineunicourses.com/

Frequently visited sites by Bangladeshi people | Aktel|bdjobs | cricinfo | dhaka stock exchange | east west university | facebook | gmail | hotmail |

Aktel: http://www.aktel.com/
bdjobs: http://www.bdjobs.com/
cricinfo: http://www.cricinfo.com/
dhaka stock exchange: http://www.dsebd.org/
east west university: http://www.ewubd.edu/ewu/showDocument.php?documentid=100
facebook: http://www.facebook.com/
gmail: http://mail.google.com/
hotmail: http://login.live.com/login.srf?wa=wsignin1.0&rpsnv=10&ct=1241946028&rver=5.5.4177.0&wp=MBI&wreply=http:%2F%2Fmail.live.com%2Fdefault.aspx&lc=1033&id=64855&mkt=en-US

Storing Hierarchical Data in a Database | Storing Tree in a Database

http://www.sitepoint.com/article/hierarchical-data-database/2/

Flex Tutorial

  • Install Flex IDE
  • Go to "Help" > "Adobe Flex 3 Help". Read and do as described in all sections and subsections here.

AI in Java | Cocho Solver | Constrain Satisfaction Problem in Java Tutorial

Choco is Java library that can be used for:

  • teaching (a user-oriented constraint solver with open-source code)
  • research (state-of-the-art algorithms and techniques, user-defined constraints, domains and variables)
  • real-life applications (many application now embed choco)

http://www.emn.fr/x-info/choco-solver/doku.php
http://www.softpedia.com/get/Programming/Components-Libraries/Choco.shtml

Flash Tutorial

  • Install flash 8 or more
  • Goto "Help" > "Flash Help". In Help follow the steps:
    • Goto "All Books" > "Getting started with flash" > "Introduction". Read and do as described in following section
      • What is Flash
      • What you can do with flash
      • Making a simple Flash document
    • Goto "All Books" > "Getting started with flash" > "Tutorial: Building Your First Flash Application". Read and do as described in all sections here.
    • Goto "All Books" > "Flash Tutorials". Read and do as described in all sections and subsections here.
    • Goto "All Books" > "Getting started with flash" > "Tutorial: Building a Video Player". Read and do as described in all sections here.
  • Also Follow the following links:

Moodle | Course Management System (CMS) | Learning Management System (LMS) | Virtual Learning Environment (VLE)

Moodle is a Course Management System (CMS), also known as a Learning Management System (LMS) or a Virtual Learning Environment (VLE). It is a Free web application that educators can use to create effective online learning sites. Moodle.org is a community site where Moodle is made and discussed.

Android Tutorial

What Is Android?
On November 5th, 2007 leading technology and wireless companies came together to announce the future development of a truly open platform for all kinds of mobile devices - Android. Leading this development are Google Inc, T-Mobile, Intel, HTC, Qualcomm, Motorola along with many other companies under the umbrella of the Open Handset Alliance - a global alliance between technology and mobile industry leaders.
http://www.talkandroid.com/google-android-faq/

There are two steps to develop android application
step 1: Download eclipse
http://www.eclipse.org/downloads/
step 2: Install SDK
http://developer.android.com/sdk/1.1_r1/installing.html

Developer guide
http://developer.android.com/guide/index.html
1. How to work with eclipse
http://developer.android.com/guide/developing/eclipse-adt.html
2. In Other IDEs
http://developer.android.com/guide/developing/other-ide.html

EJB (Enterprise Java Bean) Tutorial

App server, Web server: What's the difference? | Difference between Web and Application server
1. http://www.javaworld.com/javaqa/2002-08/01-qa-0823-appvswebserver.html
2. http://wiki.answers.com/Q/What_is_the_difference_between_an_application_server_and_a_web_server
3. http://www.sap-img.com/java/difference-between-web-and-application-server.htm
4. http://www.blurtit.com/q137688.html

Choosing Application Server (GlassFish or JBoss)
1. http://weblogs.java.net/blog/arungupta/archive/2007/06/why_glassfish_o.html
2. http://anachronymous.com/2009/01/jboss-or-glassfish.html
3. http://forums.java.net/jive/thread.jspa?threadID=2310
4. http://www.brakkee.org/joomla/content/view/64/9/
Comment: I choose GlassFish for me

EJB 3.0 Enterprise Beans for the GlassFish Application Server
1. http://wiki.netbeans.org/CreatingEJB3UsingNetbeansAndGlassfish
2. http://www.netbeans.org/kb/55/ejb30.html
3. http://www.netbeans.org/kb/trails/java-ee.html

EJB 3.0 Enterprise Beans for the JBoss Application Server
1. http://www.netbeans.org/kb/55/ejb30-jboss.html

NETBEANS MASTER INDEX
http://www.javapassion.com/netbeans/masterindex.html#General_IDE_tutorials

উবুন্টুতে গ্রামীণফোনের ইন্টারনেট ব্যবহার | Use Grammin Phone's Internate in Ubuntu


পেনড্রাইভ থেকে পিসিতে ভাইরাস ঢোকবার পথটাই বন্ধ করে দিন | Protect virus from pendrive

পেনড্রাইভ থেকে পিসিতে ভাইরাস ঢোকবার ব্যাপারটি নতুন কোন সমস্যা নয়। এই ভাইরাসগুলোর যন্ত্রনায় অনেকেই প্রচন্ড বিরক্ত। পেনড্রাইভের মাধ্যমে যে ভাইরাসগুলো ছড়ায় সেগুলো বেশিরভাগই ট্রোজান জেনারেশনের। এগুলোকে সাধারনত ওয়ার্ম বলা হয়। এই ওয়ার্মগুলোর মধ্যে কোন কোনটি আপনার পিসির উপর একসেসকে ইন্টারনেটে উন্মুক্ত করে দেয়। এছাড়া ফোল্ডার অপশন গায়েব হওয়া, হিডেন ফাইল শো না করা অথবা কোন নির্দিষ্ট সিস্টেম ফোল্ডার একসেস করতে না দেওয়া কিংবা রেজিষ্ট্রি এডিটর বা সিস্টেম কনফিগারেশন ইউটিলিটি খুলতে না দেয়া এই ভাইরাসগুলোর খুব সাধারন লীলা। অনেকেই অনেক এন্টিভাইরাস ব্যবহার করেও মাঝে মাঝে এই সমস্যা সমাধান করতে পারেন না। এই ভাইরাসগুলো কখন ঢুকলো তাও বুঝতে পারেন না অনেকে।

উইন্ডোজে বাই ডিফল্ট অটোরান সার্ভিস চালু করা থাকে। ফলে সিডিরোম বা ডিভিডিরোম ড্রাইভে ডিস্ক ঢোকালে বা পিসিতে পেনড্রাইভ ঢোকালে সেগুলো নিজে নিজেই চালু হয়ে যায় বা কিভাবে আপনি তা চালু করবেন তা আপনাকে জিজ্ঞাসা করে। প্রথমত এই অটোরানের সুযোগ নেয় ভাইরাসগুলো। আপনি যদি এইসব ড্রাইভগুলোর প্রপার্টিতে গিয়ে অটোরান ট্যাব থেকে অটোরান বন্ধ করে দেন; এর পরও ভাইরাসগুলো ঢোকে তখন যখন আপনি মাই কম্পিউটারে গিয়ে সেই ড্রাইভ খোলার জন্য তার উপর ডাবল ক্লিক করেন। এর কারন হলো পেনড্রাইভের ভেতরে যদি কোন ভাইরাস থাকে তাহলে সে পেন ড্রাইভের ভেতরে (রুটে) একটি অটোরান নামের আই.এন.এফ ফাইল তৈরী করে রাখে। এই ফাইলে পেন ড্রাইভটি ওপেন করা মাত্রই যাতে ভাইরাসটি পিসিতে ঢুকে যায় সেই নির্দেশ দেয়া থাকে।

পেনড্রাইভের মাধ্যমে ছাড়ানো ভাইরাসগুলোর থেকে আপনার পিসিকে যদি মুক্ত রাখতে চান তাহলে নিচের নিয়মগুলো অনুসরন করুন:

(১) ড্রাইভের প্রপার্টিতে গিয়ে সেই ড্রাইভের আটোরান বন্ধ করলেই এটি পুরোপুরি বন্ধ হয় না। ফলে উইন্ডোজের আটোরান সার্ভিস পুরোপুরি বন্ধ করে দেয়ার জন্য Start > Settings > Control panel > Administrative tools > Services -এ যান। সেখানে লিস্ট থেকে Shell Hardware Detection খুঁজে বের করে এর উপর ডাবল ক্লিক করে তার প্রপার্টিজে যান। সেখানে প্রথমে Startup type এর কম্বোবক্স এর লিস্ট থেকে Disabled সিলেক্ট করুন। এর পর Stop বাটনে ক্লিক করে Ok করুন। এর ফলে উইন্ডোজের অটোরান সার্ভিসটি পুরোপুরি বন্ধ হবে। এই কাজটি বার বার করতে হবে না, একবার করলেই হবে।

(২) কোন পেন ড্রাইভ পিসিতে ঢোকাবার আগে তার ভেতরে ভাইরাস আছে কিনা সে সম্পর্কে আপনি যদি নিশ্চিত না থাকেন তাহলে কখনই মাই কম্পিউটারে গিয়ে ডাবল ক্লিক করে সেটি ওপেন করবেন না। সেটা ওপেন করতে Start > Programs > Accessories-এ গিয়ে Windows Explorer ওপেন করুন। সেখানে দেখুন বামে একটি লিস্ট রয়েছে এবং ডানে একটি লিস্ট রয়েছে। বাম পার্শ্বের এরকম লিস্টকে ট্রি-ভিউ লিস্ট বলা হয়। ট্রি-ভিউ লিস্টে মাই কম্পিউটারের উপর সিঙ্গেল ক্লিক করলে তা এক্সপ্যান্ড হবে। এই ভাবে ট্রি-ভিউ লিস্টে যেই ফোল্ডার বা ড্রাইভের উপর ক্লিক করা হবে সেই ফোল্ডার/ড্রাইভের ভেতরে যেই ফোল্ডারসমূহ রয়েছে তা তার নিচেই খুলে যাবে আর ডানের লিস্টে খুলবে তার ভেতরের ফাইল এবং ফোল্ডারসমূহ দুটোই। পেনড্রাইভের ক্ষেত্রে ফোল্ডর খুলতে অবশ্যই ট্রি-ভিউ লিস্ট ব্যাবহার করুন। আর ফাইল খুলতে ডান পার্শ্বের লিস্ট ব্যবহার করুন। ভুল করেও ডান পার্শ্বের লিস্ট থেকে কোন ফোল্ডারের উপর ডাবল ক্লিক কলে ফোল্ডার ওপেন করবেনা। তাহলে সেই ফোল্ডারে ভাইরাস থাকলে সেটা অটোরান হয়ে আপনার পিসিকে আক্রমন করবে।

(৩) পিসিতে পেনড্রাইভ ঢোকানের পর প্রথমেই এক্সপ্লোরার -এ গিয়ে ট্রি-ভিউ লিস্ট থেকে পেনড্রাইভের উপর ডান ক্লিক করে এন্টিভাইরাস দিয়ে তা চেক করে নিন। এন্টিভাইরাস দ্বারা যদি কোন ভাইরাস ধরা না পড়ে তাহলেও নিশ্চিন্ত হবেন না। ওপরে বলে দেয়া নিয়মের মত করে পেনড্রাইভ একসেস করুন। (ইচ্ছে করলে এক্সপ্লোরারের একটি শর্টকাট ডেক্সটপে তৈরী করে নিতে পারেন)

(৪) কোন বন্ধুকে যদি শুধুমাত্র কোন ফাইল/ফোল্ডার পেনড্রাইভে কপি করে দেয়ার থাকে তাহলে তার পেনড্রাইভ লাগানোর পর সেই ফাইল/ফোল্ডারের উপর ডান ক্লিক করে মেনু থেকে সেন্ড টু এর মাধ্যমে পেনড্রাইভে সেন্ড করে দিন। প্রয়জনে না থাকলে পেনড্রাইভ ওপেন করবেন না। প্রত্যেকবার পেনড্রাইভ ব্যবহারের সময় উপরের এই বিষয়গুলি ভালোভাবে খেয়াল রাখুন। তেমন কঠিন কিছু কিন্তু নয়, একটু সতর্ক থাকুন - ভাইরাস ঢুকবেনা।

ইন্টারনেটের মাধ্যমে অন্য কম্পিউটার নিয়ন্ত্রণ | Control other computer with internet

আপনার বন্ধু থাকে প্রবাসে আর আপনি বাংলাদেশে। আপনার বন্ধু কম্পিউটারে খুব বেশী দক্ষ না। আপনি আপনার বন্ধুকে কিছু শেখাতে চান বা তার কম্পিউটারের কিছু কাজ করে দিতে চান। কিন্তু দুজন হাজার কিলোমিটার দুরে থেকে কিভাবে এটা সম্ভব। টিমভিউয়ার সফটওয়্যারের মাধ্যমে আপনি আপনার বন্ধুর কম্পিউটার ব্যবহার করতে পারবেন, ফলে আপনি তাকে যেমন কিছু শেখাতে পারবেন তেমনই তার বিভিন্ন কাজও করে দিতে পারবেন। এজন্য অবশ্যই উভই কম্পিউটারে ইন্টারনেট সংযোগ এবং টিমভিউয়ার সফটওয়্যার ইনষ্টল থাকতে হবে।
এজন্য উভয়ই http://www.teamviewer.com থেকে সফটওয়্যারটি ডাউনলোড করে ইনষ্টল করুন। এবার উভয়ই সফটওয়্যারটি চালু করুন, তাহলে কিছুক্ষণের মধ্যে Your Details অংশে ID এবং Password আসবে। যেহেতু আপনি আপনার বন্ধুর কম্পিউটার নিয়ন্ত্রণ করবেন তাই আপনার বন্ধুর কাছ থেকে এসএমএস, ফোন, মোবাইল, ম্যাসেজ (চ্যাট) বা ইমেইলের মাধ্যমে তার টিমভিউয়ারের ID এবং Password জেনে নিন। এখন আপনার টিমভিউয়ারের (Remote Support নির্বাচন রেখে) Partner Details এর ID অংশে আপনার বন্ধুর দেওয়া আইডি লিখে Connect Partner বাটনে ক্লিক করুন। তাহলে সফটওয়্যার ইন্টারনেটের মাধ্যমে আপনার বন্ধুর কম্পিউটারের টিমভিউয়ার পরীক্ষা করবে। এবপরে পাসওয়ার্ড চাইলে আপনার বন্ধুর দেওয়া পাসওয়ার্ড লিখে Log On বাটনে ক্লিক করুন। কিছুক্ষণের মধ্যে আপনার বন্ধুর দেওয়া আইডির টাইটেলে একটা উইন্ডো আসবে, যা আপনার বন্ধুর কম্পিউটারের ডেক্সটপ। এখন আপনি উক্ত ডেস্কটপের মাধ্যমে আপনার বন্ধুর কম্পিউটারের সম্পূর্ণ নিয়ন্ত্রণ (ফাইল/ফোল্ডার তৈরী, ডিলিট করা, টাইপ করা, সফটওয়্যার ইনষ্টল করা, ডাউনলোড করা, গান দেখা ইত্যাদি) করতে পারবেন। মোট কথা ইন্টারনেটর সংযোগ অক্ষুন্ন রেখে কম্পিউটার লগঅফ/সার্টডাউন ছাড়া বাকি সবই করতে পারবেণ। এছাড়াও Filetransfer থেকে সংযোগ নিলে আপনার নিজের কম্পিউটারের ফাইল আপনার বন্ধুর কম্পিউটারের মধ্যে ফাইল/ফোল্ডার আদান প্রদান করতে পারবেন।

একাধিক কম্পিউটারে ইন্টারনেট শেয়ার করা | Sharing internet in more than one computer

আমরা যারা মোবাইল বা মডেম দ্বারা ইন্টারনেট ব্যবহার করি তারা চাইলে অনান্য লোকাল কম্পিউটারে ইন্টারনেট শেয়ার করে ব্যবহার করতে পারি। ধরি আপনার কম্পিউটারটি আরো দুটি কম্পিউটারের সাথে ল্যানের সাহায্যে সংযোগ স্থাপন করা আছে। আপনি আপনার কম্পিউটারে এডজ মডেম দ্বারা ইন্টারনেটের সংযোগ নিয়েছেন। এখন আপনি চাইলে অনান্য কম্পিউটারগুলোতেও ইন্টারনেটের সংযোগ দিতে পারেন শেয়ার করে। এতে অবশ্য গতি কিছুটা কমে যাবে।এজন্য আপনি আপনার লোকাল এরিয়া নেটওয়ার্কের আইপি এড্রেস দেখে নিন। ধরি আপনার লোকাল এরিয়া নেটওয়ার্কের আইপি এড্রেস হচ্ছে ১৯২.১৬৮.১.১২।





প্রথমে আপনি আপনার কম্পিউটারে এডজ মডেম দ্বারা ইন্টারনেটের সংযোগ স্থাপন করুন। এরপরে সিস্টেম ট্রেতে থাকা উক্ত সংযোগের আইকনের উপরে মাউসের ডান বাটন ক্লিক করে Status এ ক্লিক করুন। অথবা Control Panel থেকে Network Connections এ গিয়ে উক্ত সংযোগের আইকনের উপরে মাউসের ডান বাটন ক্লিক করে Status এ ক্লিক করুন একটি স্টেটাস উইন্ডো আসবে। এবার General ট্যাবে থেকে Properties বাটনে ক্লিক করুন তাহলে প্রোপার্টিস উইন্ডো আসবে। এবার Advance ট্যাবে ক্লিক করে Internet Connection Sharing অংশে Allow other network users to connect through this computer’s internet connection চেক (যদি আপনার একাধিক লোকাল এরিয়ার সংযোগ থাকে তাহলে একটি ম্যাসেজ আসবে যে আপনি কোন লোকাল এরিয়াতে ইন্টারনেট শেয়ার দিবেন, আপনি আপনার পছন্দেরটি নির্বাচন করবেন।) করে Ok করুন। তাহলে Network Connections এর পরপর তিনটি ম্যাসেজ আসবে যেগুলোতে ধারাবাহিক ভাবে Ok Yes Ok করুন। এখন দেখুন আপনার কম্পিউটারের লোকাল আইপি পরিবর্তন হয়ে ১৯২.১৬৮.০.১ হয়েছে।




এখন আপনি লোকাল এরিয়ার Status এ গিয়ে Properties বাটনে ক্লিক করে General ট্যাবে থেকে This connection uses the following items অংশের Internet Protocol (TCP/IP) নির্বাচন করে Properties বাটনে ক্লিক করুন। এবার আইপি ১৯২.১৬৮.০.১ পরিবর্তন করে পূর্বের আইপি ১৯২.১৬৮.১.১২ দিন এবং Ok করুন।
এবার যে কম্পিউটারে আপনি ইন্টারনেট সংযোগ পেতে চান সেই কম্পিউটারের লোকাল এরিয়ার Status এ গিয়ে Properties বাটনে ক্লিক করে General ট্যাবে থেকে This connection uses the following items অংশের Internet Protocol (TCP/IP) নির্বাচন করে Properties বাটনে ক্লিক করুন। এবার Default gateway এর আইপি এড্রেস হিসাবে ১৯২.১৬৮.১.১২ লিখুন। এরপরে Use the flowing DNS server addresses অপশন বাটন চেক করে Preferred DNS server এর আইপি এড্রেস হিসাবেও ১৯২.১৬৮.১.১২ লিখে Ok Ok Ok করুন।
এবার দেখুন আপনার এই কম্পিউটারে ইন্টারনেটের সংযোগ এসেছে। এভাবে আপনি অন্য আরেকটি কম্পিউটারে সংযোগ নিতে পারনে। ব্রডব্যান্ডের সংযোগও এভাবে শেয়ার করে ব্যবহার করা যাবে।

WhatsUp Gold দিয়ে নেটওয়ার্ক মনিটর করুন | Monitor your network with WhatsUp Gold


কর্পোরেট অফিসগুলোতে বিভিন্ন রকম সার্ভার, রাউটার, সুইচ, ল্যান প্রিন্টার সহ অনেক ডিভাইস থাকে যা সরসারি নেটওয়ার্কে সংযুক্ত থাকে। এবং অনেক সার্ভার এবং ডিভাইস আছে যা সারাক্ষন চালু থাকতে হয়। বিশেষ করে ইমেইল সার্ভার, ওয়েব সার্ভার, রাউটার ইত্যাদি ২৪ ঘন্টা অনলাইনে থাকাটা বাধ্যতামূলক। এসব সার্ভার এবং ডিভাইস ১ ঘন্টা বন্ধ থাকার ফলে কোম্পানী বড় অংকের অর্থনৈতিক ক্ষতির সম্মুখীন হতে পারে। ফলে সিস্টেম এডমিনিস্ট্রেটরদের সারাক্ষন সতর্ক থকাতে হয় কখন সার্ভার ডাউন হল, আই এস পি'র সাথে লিংক ঠিক আছে কিনা ইত্যাদি ব্যাপারে। বেশী সমস্যা হয়ে যায় অফিস টাইমের পরে। কারণ তখন অফিসে কেউ না থাকার ফলে সার্ভার/লিংক কখন ডাউন হল বুঝা যায় না। ফলে তাৎক্ষনিক ব্যবস্থা ও নেওয়া যায় না। তাই সিস্টেম এডমিনিস্ট্রেটরদের জন্য নেটওয়ার্ক মনিটরিং সিস্টেম খুবই গুরুত্বপূর্ন একটা ব্যাপার। WhatsUp Gold সফটওয়ারটি দিয়ে ভাল একটা নেটওয়ার্ক মনিটর সিস্টেম তৈরী করা যায় খুব সহজেই। এই সফটওয়্যার ব্যবহার করে আমরা কিছু সার্ভারকে মনিটর করব যেন ডাউন হওয়ার সাথে সাথেই ওয়ার্নিং সাউন্ড বাজতে থাকবে।

বিস্তারিত দেখুন এখানে


Bluetooth রিমোট কন্ট্রোল | Bluetooth Remote Control

আপনার যদি একটি Bluetooth যুক্ত ফোনসেট থাকে, তাহলে আপনি সেটাকে আপনার PC এর Remote Controller হিসাবে ব্যবহার করতে পারেন। আমি এরকম অনেকগুলো সফটয়্যার ইউজ করেছি,তার ভিতর সবচেয়ে যেটা ভাল সেটা হল, "Bluetooth Remote Control"

এটা ইউজ করতে যা যা লাগবে তা হলঃ

১.একটি Bluetooth যুক্ত ফোনসেট (2.0 হলে ভাল হয়)
২.BluetoothRemoteControl.exe (সফটয়্যার)
৩.একটি Bluetooth ডিভাইস।


How to Use:
প্রথমে pc তে BluetoothRemoteControl.exe সফটয়্যারটি ইন্সটল করুন। pc তে প্রোগ্রামটি রান করুন। সেখানে গেলে"install phone client" নামে একটা ট্যাব দেখতে পাবেন। এখানে ক্লিক করলে একটা উইন্ডো ওপেন হবে। (এখানে instruction নামে একটা ফাইল আছে,এটা ফলো করতে পারেন) এখান থেকে আপনার ফোনে জাভা সফটয়্যারটি ইন্সটল করুন। ফোনে প্রোগ্রামটি রান করুন, pc তে প্রোগ্রামটি রান করুন। PC তে "select Phone" ট্যাবে ক্লিক করুন। অন্য একটি উইন্ডো্তে সার্চ করে আপনার Bluetooth এর নাম পেয়ে গেলে finish এ ক্লিক করুন। এবার "connect to phone " ট্যাব এ ক্লিক করুন।
Then Enjoy................

সুবিধা সমূহঃ
১.PowerPoint Presentation ( প্রত্যেক slide এর image preview অথবা outline preview.
2. PowerPoint lite.
3. Itune
4. Mouse controller ( আপনার PCর window এখানে দেখতে পাবেন, Phone এর joystick দিয়ে mouse control)
5. Windows Media player
6. Winamp
7. File Browser (Pcর যেকোন drive এ গিয়ে যেকোন file ওপেন)
8. Windows System Control (System Volume, Start Screensaver, Shutdown, Restart)
9.Keymaps(Acrobat Reader, Xingview, Irfanview, BSplayer,Realplayer,power DVD, VLC mediaplayer,MMjukebox)
10. যেকোন program যেটাতে keyboard shortcut আছে তা manually
সেট করে নিতে পারবেন( program টিতে গিয়ে application>new ট্যাবে)


সফটয়্যারটির Download Link:

Click This Link



এটা Traial Version, এটাকে unlimited এ রুপান্তর করতে, program টিতে গিয়ে purchase>active manually ট্যাবে clickকরুন। Serial No. প্রবেশ করান,OK করুন।


Serial No. পেতে mail করুনঃ springrain.04@gmail.com

গুগল এ থিসিস সার্চ করুন | Search Thesis In Google

অনেকের থিসিস লেখার সময় আগের কারো লেখা থিসিস পেলে সুবিধা হয়। আমি থিসিস সার্চ করার একটা সিস্টেম শিখেছিলাম। মনে হয় অনেকেই জানে, তবু লিখি।

প্রথমে গুগল এ যান। তারপর "ইউনিভার্সিটি সার্চ" লিখুন। এখন গুগল এর একটা সাইট আসবে যেটা তে ইউনিভার্সিটি সার্চ কথাটা থাকে। এখানে এ ক্লিক করুন। তারপর অনেকগুলো ইউনিভার্সিটির নাম আসবে(যেমন Caltech/MIT/ Princeton/ Berkley.. ..) । এখন যে কোনো একটা নামের ওপর ক্লিক করলে আবার সার্চ অপশন আসবে। এবার কী ওয়ার্ড লিখে সার্চ দিতে হবে। যেমন etd (stands for electronic thesis document) লিখে সার্চ দিলে সব থিসিস চলে আসবে।

এটা ব্যবহার করলে অনেক থিসিস খুজে পাওয়া যায়। এর অনেকগুলো ডাউনলোড করা যায়। এই সাইট টা আসলে ইউনিভার্সিটিগুলোর অনলাইন লাইব্রেরিতে নিয়া যায়। আমি Caltech এ সাইট থেকে কয়েকটা নামিয়ে ছিলাম।

ভালো একটা থিসিস পেলে অনেক সময় জার্নাল এর চেয়ে ভাল কাজ হয়।

দুটি প্রক্সি সফটওয়ার | Proxy software

কখনো কখনো প্রক্সি দিয়ে ওয়েব সাইট ভিজিট করার প্রয়োজন হয়। এর অনেক কারন রয়েছে। যেমন কোন সাইটকে দেশের সরকার কর্তৃক ব্যান করা, ওয়েবসাইট কর্তৃপক্ষ সেই দেশের আইপি ব্যান করা ইত্যাদী।

যাই হোক, যে কোন কারনেই হোক, ব্যান করা ওয়েবসাইট ভিজিট করা যায় প্রক্সি ব্যাবহার করে। নিচে দুটি প্রক্সি সফটওয়ারের কথা বলছি।

১/ Ultra Surf

এ সফটওয়ারটি চমৎকার কাজ করে। সব সাইট ই ওপেন করা যায়। Portable এই সফটওয়ারটি কে আপনি Flopy Disc ও USB Memory তে রেখে প্রয়োজন মত কাজে লাগাতে পারেন। তবে এই সফটওয়ারটি শুধু IE কাজ করে। ডাওনলোড শেষ হলে আনজিপ করার সময় আপনার এন্টিভাইরাস সফটওয়ারটি এটাকে এন্টিভাইরাস হিসেবে ডিটেক্ট করে ডিলেট করতে পারে। তাই এন্টিভাইরাস সফটওয়ারটিকে সে সময় ডিসএবল রাখুন।

Download

বিস্তারিত


২/ Anchorfree


এটি একটি পাওয়ারফুল প্রক্সি সফটওয়ার। যে কোন ব্রাইজারতেই এটি কাজ করতে পারে।

Download

টাস্ক ম্যানেজার হ্যাজ বিন ডিসেবলড বাই ইউর এডমিনিস্ট্রেটর !! | Task manager has been disabled by your administrator | Computer virus problem

ধরুন আপনার কোনো ভুলের কারনে অথবা অসতর্কতার কারণে পিসির ফোল্ডার অপশন চলে গেল। এখন ফোল্ডার অপশনে গিয়ে হিডেন ফাইলে একসেস করবেন সেই উপায় নেই। এটি মুলত কোনো ভাইরাসই হোক অথবা অন্য কোনো প্রোগ্রামই হোক অনেক সময় অ্যান্টিভাইরাস দিয়ে স্ক্যান করে ডিলিট করে দিতে , কিন্তু ৯৯% সম্ভাবনা ঐ ফাইলটি ডিলিট করা তো দুরের কথা, ধরাই পড়বে না। যার ফলে আপনি চাইছেন টাস্ক ম্যানেজারে গিয়ে ঐ প্রোগ্রামের প্রসেস বন্ধ করে দিতে, কিন্তু আশ্চর্যের সাথে দেখলেন টাস্ক ম্যানেজার ও গায়েব ! মাথায় হাত দেয়া ছাড়া উপায় নাই। একটাই রাস্তা আছে রেজিস্ট্রি এডিটরে গিয়ে কিছু ভ্যালু চেন্জ করে ফোল্ডার অপশন টা ফিরিয়ে আনা কিন্তু আরো জটিল ব্যাপার হল রেজিস্ট্রি এডিটরেও অ্যাকসেস করা যাচ্ছে না। বলছে Regeditor is disabled by the Administrator. এই পর্যায়ে এসে উইন্ডোজ রিইনস্টল করা ছাড়া কোনো উপায় নেই।

এই ধরনের সমস্যা থেকে বাচতে নিচের সফ্টওয়্যার টি ব্যবহার করলে ৯৯.৯৯% সম্ভাবনা আপনার ফোল্ডার অপশন, টাস্ক ম্যানেজার, রেজিস্ট্রি এডিটর পুনরায় ফিরে পাবেন।



সম্পুর্ন ফ্রি এই ফাইলটি মাত্র ৭ কিলোবাইটের ! ডাওনলোড করে চালু করুন। তারপর পরবর্তী ধাপে যান এবং শেষ হলে পিসি রিস্টার্ট করুন। দেখবেন ফিরে এসেছে ফোল্ডার অপশন, টাস্ক ম্যানেজার, এবং রেজিস্ট্রি এডিটর।

ডাওনলোড করুন

অনলাইনে ফ্রী ল্যান্স কাজ | Online Freelencing

গতানুগতিক চাকুরীর বাইরে নিজের ইচ্ছামত কাজ করার স্বাধীনতা হচ্ছে ফ্রিল্যান্সিং। ইন্টারনেটের কল্যানে এখন আপনি খুব সহজেই একজন ফ্রিল্যান্সার হিসেবে আত্মপ্রকাশ করতে পারেন। এখানে একদিকে যেরকম রয়েছে যখন ইচ্ছা তখন কাজ করার স্বাধীনতা, তেমনি রয়েছে কাজের ধরন বাছাই করার স্বাধীনতা। আয়ের দিক থেকেও অনলাইন ফ্রিল্যান্সিং এ রয়েছে অভাবনীয় সম্ভাবনা। এখানে প্রতি মূহুর্তে নতুন নতুন কাজ আসছে। প্রোগ্রামিং, গ্রাফিক্স ডিজাইন, ওয়েবসাইট, গেম, 3D এনিমেশন, প্রোজেক্ট ম্যানেজমেন্ট, সফ্টওয়্যার বাগ টেস্টিং, ডাটা এন্ট্রি - এর যেকোন এক বা একাধিক ক্ষেত্রে আপনি সফলভাবে নিজেকে একজন ফ্রিল্যান্সার হিসেবে তৈরি করে নিতে পারেন। তবে প্রথমদিকে আপনাকে একটু ধ্যর্য এবং কয়েকটি বিষয় মাথায় রেখে নিজেকে প্রস্তুত করে নিতে হবে। এই প্রতিবেদনটি তাই এমনভাবে তৈরি করা হয়েছে যাতে আপনি একজন নতুন ফ্রিল্যান্সার হিসেবে নিজেকে সফলভাবে প্রকাশ করতে পারেন।

ফ্রিল্যান্সিং ওয়েবসাইট

ইন্টারনেটে অনেকগুলো জনপ্রিয় ওয়েবসাইট রয়েছে যারা ফ্রিল্যান্সিং সার্ভিস দেয়। এগুলো থেকে যেকোন একটিতে রেজিস্ট্রিশনের মাধ্যমে আপনি শুরু করতে পারেন। এসব ওয়েবসাইটে যারা কাজ জমা দেয় তাদেরকে বলা হয় Buyer বা Client এবং যারা এক কাজগুলো সম্পন্ন করে তাদেরকে বলা হয় Provider বা Coder. একটি কাজের জন্য অসংখ্য কোডাররা Bid বা আবেদন করে এবং ওই কাজটি কত টাকায় সম্পন্ন করতে পারবে তাও উল্লেখ করে। এদের মধ্য থেকে ক্লায়েন্ট যাকে ইচ্ছা তাকে নির্বাচন করতে পারে। সাধারণত পূর্ব কাজের অভিজ্ঞতা, টাকার পরিমাণ এবং বিড করার সময় কোডারের মন্তব্য কোডার নির্ববচন করার ক্ষেত্রে গুরুত্বপূর্ণ ভূমিকা পালন করে থাকে। কোডার নির্বাচন করার পর ক্লায়েন্ট কাজের সম্পূর্ণ টাকা ওই সাইটগুলোতে জমা করে দেয়। এর মাধ্যমে কাজ শেষ হবার পর সাথে সাথে টাকা পাবার নিশ্চয়তা থাকে। পুরো সার্ভিসের জন্য কোডারকে কাজের একটা নির্দিষ্ট অংশ ওই সাইটকে ফি হিসেবে দিতে হয়। এই পরিমাণ ওয়েবসাইট এবং কাজের ধরনভেদে ভিন্ন ভিন্ন (১০% থেকে ১৫%)। এই সাইটগুলোকে কয়েকটি জনপ্রিয় ফ্রিল্যান্সিং ওয়েবসাইট হচ্ছে: http://www.RentACoder.com, http://www.GetAFreelancer.com, http://www.GetACoder.com, http://www.Scriptlance .com, http://www.Joomlancers .com , http://www.oDesk.com ইত্যাদি।

নিচে কয়েকটি সাইট নিয়ে বিস্তারিত আলোচনা করা হল:

http://www.RentACoder.com

রেন্ট-এ-কোডার এ প্রায় দুই লক্ষ কোডার রেজিস্ট্রেশন করেছে। এই সাইটে প্রতিদিনই প্রায় ২৫০০ এর উপর কাজ পাওয়া যায়। সাইটের সার্ভিস চার্জ বা কমিশন হচ্ছে প্রতিটি কাজের মোট টাকার ১৫% যা কাজ সম্পন্ন হবার পর কোডারকে পরিশোধ করতে হয়। এই প্রতিবেদনটি মূলত রেন্ট-এ-কোডার সাইটকে ভিত্তি করে লেখা হয়েছে। তবে মূল ধারনা প্রতিটি সাইটের ক্ষেত্রেই প্রায় একই।

http://www.GetAFreelancer.com

এই সাইটে মোট কোডার বা প্রোভাইডারের সংখ্যা হচ্ছে প্রায় সাত লক্ষ। এই সাইটেও প্রায় ২৫০০ এর উপর কাজ প্রতিদিন পাওয়া যায়। সাইটির সার্ভিস চার্জ হচ্ছে প্রতিটি কাজের মোট টাকার ১০%। তবে গোল্ড মেম্বারদের জন্য কোন সার্ভিস চার্জ নেই। গোল্ড মেম্বার হতে প্রতি মাসে আপনাকে মাত্র ১২ ডলার পরিশোধ করতে হবে। নতুন ইউজারদের জন্য এই সাইটে ট্রায়াল প্রোজেক্ট নামে একটি বিশেষ ধরনের কাজ পাওয়া যায় যাতে শুধুমাত্র নতুন কোডারাই বিড করতে পারবে। ফলে প্রথম কাজ পেতে আপনাকে খুব বেশি দিন অপেক্ষা করতে হবে না।

http://www.joomlancers.com

এই সাইটে শুধুমাত্র Joomla এর কাজ পাওয়া যায়। Joomla হচ্ছে একটি ওপেনসোর্স কন্টেন্ট ম্যানেজমেন্ট সিস্টেম। যারা Joomla এ পারদর্শী তারা এই সাইটে বিড করে দেখতে পারেন। এখানে প্রায় ৫৫০০ ফ্রিল্যান্সার রেজিস্ট্রেশন করেছে আর এখানে প্রতিদিন প্রায় ১৫০ টি কাজ পাওয়া যায়। এই সাইটে কমিশন হিসেবে প্রতিটি কাজের ১০% টাকা কোডারকে পরিশোধ করতে হবে। গোল্ড মেম্বার হতে হলে আপনাকে প্রতি মাসে ৫০ ডলার প্রদান করতে হবে।

http://www.oDesk.com

এক সাইটের ফিচার উপরে উল্লেখিত সাইট থেকে সম্পূর্ণ আলাদা। এখানে প্রোভাইডারকে প্রতি ঘন্টা কাজের জন্য টাকা প্রদান করা হয়। ক্লায়েন্ট আপনাকে সম্পূর্ণ প্রজোক্টের জন্য বা নির্দিষ্ট সময়ের জন্য (কয়েক সপ্তাহ বা কয়েক মাস এর জন্য) নিয়োগ দিতে পারে। রেজিষ্ট্রেশন করার সময় প্রতি ঘন্টায় আপনার কাজের মূল্য উল্লেখ করে দিতে হবে। কাজ শেষে আপনি যত ঘন্টা কাজ করেছেন ঠিক ততটুকু পরিমাণ টাকা ক্লায়েন্ট আপনাকে প্রদান করবে। কাজ করার মূহুর্তে আপনার ব্যয়কৃত সময় নির্ধারণ করার জন্য আপনাকে একটি সফ্টওয়্যার চালু রাখতে হবে। এই সফ্টওয়্যারটি একটি নির্দিষ্ট সময় পরপর আপনার ডেস্কটপের স্ক্রিসশট এবং অন্যান্য তথ্য ক্লায়েন্টের কাছে পাঠাবে। ফলে ওই সময় আপনি কাজ করছেন কিনা ক্লায়েন্ট সহজেই নির্ধারণ করতে পারবে। তবে অন্য সাইটগুলোর মত এখানেও অনেক কাজ পাওয়া যায় যেখানে সম্পূর্ণ প্রজেক্টের জন্য একটি নির্দিষ্ট টাকা প্রদান করা হয়। এই সাইটে প্রতি কাজের জন্য ১০% টাকা কমিশন হিসেবে প্রদান করতে হয়। যেহেতু বেশিরভাগ কাজ ঘন্টা হিসেবে প্রদান করা হয় তাই অন্য সাইটগুলোর তুলনায় এই সাইট থেকে অনেক বেশি পরিমাণে টাকা আয় করা সম্ভব।

অনলাইনে কাজের ধরন

অনলাইনে প্রায় সকল ধরনের কাজ করা যায়। আপনি যে কাজে পারদর্শী তা দিয়েই ঘরে বসে আয় করতে পারেন। এজন্য আপনাকে যে কম্পিউটার সায়েন্সে স্নাতকধারী হতে হবে তা কিন্তু নয়। আর আপনি যদি মনে করেন কোন একটি নির্দিষ্ট ক্ষেত্রে আপনি বিশেষ পারদর্শী নন তাহলে ডাটা এন্ট্রি এর মত কাজগুলো করতে পারেন। ছাত্ররাও ফ্রিল্যান্সিং এর মাধ্যমে পড়ালেখার পাশাপাশি বাড়তি আয়ের একটা ব্যবস্থা করতে পারেন। ইন্টারনেটে নিম্নলিখিত প্রকারের কাজ পাওয়া যায়: প্রোগ্রামিং , ওয়েবসাইট তৈরি , ডাটাবেইজ, গ্রাফিক্স ডিজাইন, এনিমেশন, গেম তৈরি, প্রজেক্ট ম্যানেজমেন্ট, সফ্টওয়ার টেস্টিং এবং ডাটা এন্ট্রি।

কিভাবে শুরু করবেন

প্রথমে যে কোন একটি ফ্রিল্যান্সিং সাইটে রেজিস্ট্রশন করে নিতে হবে। রেজিস্ট্রশন করা সময় আপনার ব্যক্তিগত তথ্য, ঠিকানা, ইমেইল ইত্যাদি সঠিকভাবে দিতে হবে। রেজিস্ট্রেশনের একটি ধাপে আপনার একটি প্রোফাইল/রেজ্যুমে তৈরি করতে হবে যেখানে আপনি কোন কোন ক্ষেত্রে পারদর্শী তা উল্লেখ করবেন। এখানে আপনি আপনার পূর্ব কাজের অভিজ্ঞতা, ওয়েবসাইট লিংক ইত্যাদি দিতে পারেন। পরবর্তীকালে এই প্রোফাইল কাজ পাবার ক্ষেত্রে গুরুত্বপূর্ণ ভূমিকা পালন করবে।

সফলভাবে রেজিস্ট্রেশন সম্পন্ন হবার পর, এখন আপনি বিড করা শুরু করে দিতে পারেন। ফ্রিল্যান্সিং সাইটগুলোতে প্রতি মূহুর্তে নতুন কাজ আসছে। আপনার পারদর্শীতা আনুযায়ী প্রতিটা কাজ দেখতে থাকুন। প্রথম কয়েক দিন বিড করার কোন প্রয়োজন নেই। এই কয়েকদিন ওয়েবসাইটি ভাল করে দেখে নিন। ওয়েবসাইটের বিভিন্ন নিয়ম-কানুন এবং সাহায্যকারী আর্টিকেল পড়ে ফেলতে পারেন। একটি কথা মনে রাখবেন, প্রথমদিকে কাজ পাওয়া কিন্তু সহজ নয়। তাই আপনাকে ধর্য্যসহকারে বিড করে যেতে হবে। প্রথম কাজ পেতে হয়ত ১০ থেকে ২০ দিন পর্যন্ত সময় লেগে যেতে পারে। কয়েকটি কাজ সফলভাবে সম্পন্ন করার পর আপনাকে আর পেছন ফিরে তাকাতে হবে না। তখন ক্লায়েন্টরাই আপনাকে খোজে বের করবে।

কয়েকটি গুরুত্ত্বপূর্ণ বিষয়
শুরুতে কয়েকটি গুরুত্বপূর্ণ বিষয় আপনাকে জানতে হবে। সেগুলো হল:

Rating :

একটি কাজ সম্পন্ন হবার পর ক্লায়েন্ট আপনার কাজের দক্ষতার উপর ভিত্তি করে ১ থেকে ১০ এর মধ্যে আপনাকে ভোট দিবে। এখানে সর্বোত্তকৃষ্ট রেটিং হচ্ছে ১০। নতুন কাজ পাবার ক্ষেত্রে এই রেটিং খুবই গুরুত্বপূর্ণ ভূমিকা পালন করে থাকে। তাই সবসময় চেষ্টা করবেন ‌১০ রেটিং পেতে। এজন্য কাজ জমা দেয়ার আগে ভাল করে দেখে নিন আপনি ক্লায়েন্টের চাহিদা অনুযায়ী সকল কাজ সঠিকভাবে সম্পন্ন করেছেন কিনা এবং নির্ধারিত সময় শেষ হবার পূর্বেই কাজ জমা দিন। গড় রেটিং ৯ এর চেয়ে কম হলে ধীরে ধীরে নতুন কাজ পাবার সম্ভাবনা কমে যাবে।

Ranking :

ফ্রিল্যান্সিং একটি সাইটে সকল কোডার এর মধ্যে আপনার অবস্থান কত তা জানা যায় রেংকিং এর মাধ্যমে। রেন্ট-এ-কোডারে আপনার গড় রেটিং এবং সর্বমোট কত টাকার কাজ সম্পন্ন করেছেন তা দিয়ে আপনার অবস্থান নির্ধারিত হয়। রেটিং এর মত রেংকিং ও নতুন কাজ পাবার ক্ষেত্রে গুরুত্বপূর্ণ ভূমিকা পালন করে থাকে। যার রেংকিং যত সামনের দিকে তার কাজ পাবার সম্ভাবনা অন্যদের চাইতে বেশি। তবে বিড করার সময় আপনি যদি ক্লায়েন্টকে আপনার মনোবল, আত্মবিশ্বাস আর সম্ভব হলে পূর্ব কাজের অভিজ্ঞতা দেখাতে পারেন তাহলে সবাইকে পেছনে ফেলে আপনিই কাজ পেয়ে যেতে পারেন।

Deadline :

কাজ শুরু করার পূর্বে ক্লায়েন্ট কাজ জমা দেবার একটি ডেডলাইন বা সর্বোচ্চ সময়সীমা উল্লেখ করে দেয়। আপনার যদি মনে হয় যে এই কাজ আপনি ক্লায়েন্ট কর্তৃক নির্ধারিত সময়ে জমা দিতে পারবেন না তাহলে কাজ শুরু করার পূর্বেই ক্লায়েন্টকে অনুরোধ করুন ডেডলাইন সময় বাড়িয়ে দিতে। ক্লায়েন্ট সম্মত হলে কাজটি শুরু করুন। আর যদি ক্লায়েন্ট সময় বাড়াতে আপত্তি জানায় তাহলে কাজটি গ্রহন না করাই আপনার জন্য ভাল হবে। কারন ডেডলানে উল্লেখিত সময়ের মধ্যে যদি আপনি কাজটি জমা দিতে না পারেন তাহলে কাজের সম্পূর্ণ টাকাই আপনি হারাতে পারেন। উপরন্তু ক্লায়েন্ট আপনাকে একটি বাজে রেটিং দিয়ে দিতে পারে। তাই কখনও যদি এরকম কোন পরিস্থিতির উদ্ভব হয় তখন অনতিবিলম্বে আপনার বর্তমান অবস্থা ক্লায়েন্টকে জানান এবং ডেডলাইন সময় বাড়ানোর জন্য অনুরোধ করুন।

Mediation/Arbitration:

কখনও যদি ক্লায়েন্ট আপনাকে টাকা দিতে অস্বীকৃতি জানায় বা সম্পূর্ণ কাজ জমা দেবার পর আপনাকে বলে যে আপনি ঠিকভাবে সকল কাজ সম্পন্ন করেন নি তাহলে আপনি ফ্রিল্যান্সিং সাইটের মেডিএশন/আর্বিট্রশনের সাহায্য নিতে পারেন। এই সার্ভিসের মাধ্যমে আপনি ওই সাইটের কাছে আপনার সমস্যা জানাতে পারেন। সাইটের কর্তৃপক্ষ তখন উভয়পক্ষের অভিযোগ শুনবে এবং কাজ চলাকালীন সময় ক্লায়েন্ট এবং আপনার মধ্যে যে ম্যাসেজ আদান-প্রদান হয়েছে তা যাচাই করে দেখবে। সবশেষে আপনার অভিযোগ সত্য হলে আপনি পুরো টাকা পেয়ে যাবেন। তবে যতটা সম্ভব আর্বিট্রেশনে না যাওয়াই উত্তম, কারন অনেকক্ষেত্রে দেখা গেছে কর্তৃপক্ষ ক্লায়েন্টকে সাপোর্ট করে এবং আপনি কোন টাকা পাবেন না। আপনি দোষী প্রমাণিত হলে কর্তৃপক্ষ আপনাকে একটি বাজে রেটিং দিয়ে দিবে। তাই চেষ্টা করবেন আলোচনার মাধ্যমে ক্লায়েন্টের সাথে মিমাংসা করে নিতে। এরকম অনাকাংক্ষিত পরিস্থিতিতে না পড়তে চাইলে কাজ শুরু করার পূর্বে ক্লায়েন্টকে বলুন তাদের চাহিদা পরিষ্কার করে উল্লেখ করতে। ক্লায়েন্টকে সরাসরি ইমেইল না করে সকল ম্যাসেজ আদান-প্রদান ওই সাইটের ম্যাসেজ সিস্টেমের মাধ্যমে করুন।

Escrow :

কাজ শুরু করার পর ক্লায়েন্ট কাজের সম্পূর্ণ টাকা ওই ফ্রিল্যান্সিং সাইটে জমা রাখে। এই জমা রাখাকে বলা হয় এসক্রো যা কাজ সম্পন্ন হবার পর কোডারের টাকা পাবার সম্ভাবনা নিশ্চিত করে। ক্লায়েন্ট টাকা এসক্রোতে জমা রাখা পূর্বে কাজ শুরু করা উচিত নয়।

একটি প্রজেক্ট সম্পন্ন করার ধাপসমূহ

নিচে রেন্ট-এ-কোডার সাইটের আলোকে একটি প্রজেক্টের শুরু থেকে শেষ পর্যন্ত ধাপগুলো পর্যায়ক্রমে বর্ণনা করা হল:

১. প্রজেক্ট সার্চ করা

প্রতিদিনই বিভিন্ন ধরনের নতুন নতুন কাজ আসছে। এর মধ্য থেকে আপনি যে বিষয়ে দক্ষ তা খোজে বের করে প্রতিটি কাজ পর্যবেক্ষণ করুন। এতে ওই ধরনের কাজে ক্লায়েন্টদের চাহিদা এবং কাজের মূল্য সম্পর্কে আপনার সুস্পষ্ট ধারনা হবে। নির্দিষ্ট এক বা একাধিক ধরনের কাজ খোজার জন্য আপনি সাইটের প্রজেক্ট ফিল্টার সেটিং-এর সাহায্য নিতে পারেন।

২. বিড করা

একটি কাজ পর্যবেক্ষণ করার পর আপনি যদি মনে করেন কাজটি আপনি সফলতার সাথে সম্পন্ন করতে পাবেন তাহলে ওই কাজের জন্য বিড করুন। বিড করতে আপনাকে সাইটে লগইন করতে হবে। বিড করার জন্য আপনি ওই কাজটি কত ডলারে সম্পন্ন করতে পারবেন তা উল্লেখ করুন এবং কাজটি সম্পর্কে আপনার মতামত জানিয়ে ক্লায়েন্টকে ম্যাসেজ দিন। এখানে লক্ষণীয় হচ্ছে, একটি কাজের জন্য সর্বোচ্চ কত ডলার বিড করতে পারবেন তা প্রজেক্টের বিবরণের সাথে উল্লেখ করে দেয়। তাই তার মধ্যে বিড করুন। তবে আপনি যদি ওই সাইটে এর আগে কোন কাজ না করে থাকেন তাহলে যতটুকু সম্ভব কম মূল্য উল্লেখ করুন। আপনার রেংকিং বাড়ার সাথে সাথে বিডের মূল্য বাড়িয়ে দিন।

৩. কাজ শুরু করা

সকল কোডারের মধ্য থেকে ক্লায়েন্ট যদি আপনাকে নির্বাচিত করে থাকে তাহলে দেরি না করে শুরু করে দিন। ক্লায়েন্ট সাধারণত কাজ শুরুর সাথে সাথে সকল টাকা এসক্রোতে জমা রেখে দেয়। তবে কোন কারনে জমা দিতে দেরি হলে তাকে অনুরোধ করুন। এরপর ক্লায়েন্টের কাছ থেকে প্রয়োজনীয় ফাইল, তাদের সার্ভার ও ডাটাবেইজের তথ্য জেনে নিয়ে কাজ শুরু করে দিন। সম্ভব হলে প্রতিদিন বা একদিন পরপর আপনার কাজের অগ্রগতি সম্পর্কে তাকে অভিহিত করুন। ক্লায়েন্টের কোন চাহিদা না বুঝতে পারলে যত দ্রুত সম্ভব তার সাথে যোগাযোগ করুন। ক্লায়েন্টকে সরাসরি ইমেইল না করে সবসময় চেষ্টা করবেন ওই সাইটের ম্যাসেজ সিস্টেমের সাহায্যে যোগাযোক করুন। এতে পরবর্তিতে অনাকাঙ্খিত পরিস্থিতি সৃষ্টি হলে তা মোকাবেলা করতে পারবেন।

৪. প্রতি সপ্তাহের স্টেটাস রিপোর্ট

রেন্ট-এ-কোডারে বড় কাজগুলোর জন্য প্রতি শুক্রবারে কাজের সর্বশেষ অবস্থা জানাতে হয়। এজন্য ওয়েবসাইটে প্রজেক্টের পাতায় গিয়ে "File Weekly Status Report" বাটনে ক্লিক করুন এবং আপনার মন্তব্য দিন। কোন কারনে আপনি যদি স্টেটাস রিপোর্ট না দেন তাহলে আপনার রেংকিং-এর মোট স্কোর থেকে ১০০০ স্কোর বাদ দেয়া হবে। ফলে রেংকিং-এ আপনি অন্যদের থেকে অনেকটা পিছিয়ে পড়বেন।

৫. কাজ জমা দিন

কাজ শেষ হবার পর দেরি না করে সাইটে গিয়ে সমস্ত কাজ zip করে আপলোড করে দিন। খেয়াল রাখবেন যাতে আপনি ডেডলাইনে উল্লেখিত সময়ের পূর্বেই কাজ জমা দিতে পারেন। কাজটি যদি হয় ওয়েবসাইট তৈরি করা তাহলে অনেক সময় ক্লায়েন্টের সার্ভারে সাইটি আপলোড এবং সেটাপ করে দিতে হতে পারে।

৬. ক্লায়েন্ট কাজ গ্রহণ করবে

এরপর ক্লায়েন্টের মন্তব্যের জন্য অপেক্ষা করুন। কোন পরিবর্তন থাকলে ক্লায়েন্ট আপনাকে জানাবে। আর ক্লায়েন্ট যদি আপনার কাজে সন্তুষ্ট হয় তাহলে সে সাইটে একটি বাটনে ক্লিক করার মাধ্যমে কাজটি গ্রহন করবে যা ইমেলের মাধ্যমে সাথে সাথে আপনাকে জানিয়ে দেয়া হবে। একই সাথে এসক্রো থেকে টাকার একটি অংশ সাইটে আপনার একাউন্টে জমা হবে। আরেকটি অংশ (১০% বা ১৫%) সাইটটি ফি হিসেবে রেখে দেবে।

৭. রেটিং এবং মন্তব্য করুন

এবার প্রজেক্টের পাতায় গিয়ে ক্লায়েন্টকে ১ থেকে ১০ এর মধ্যে রেটিং করুন এবং একটি মন্তব্য দিন। ক্লায়েন্টের ব্যবহারে আপনি সন্তুষ্ট থাকলে তাকে ১০ রেটিং দিন, এতে ভবিষ্যতে সে আপনাকে আরো কাজ দিবে। ঠিক একইভাবে ক্লায়েন্টও আপনাকে একটি রেটিং এবং মন্তব্য দিবে যা আপনার প্রোফাইলে সারাজীবন থাকবে। ভবিষ্যতে অন্য ক্লায়েন্টরা এই রেটিং এবং মন্তব্যের উপর ভিত্তি করে কাজ দিবে। একবার রেটিং দেবার পর তা কখনওই পরিবর্তন করা সম্ভব নয়। তাই ক্লায়েন্ট কাজ গ্রহণ করার পূর্বে তাকে জিজ্ঞেস করে নিন যে সে আপনার কাজে সম্পূর্ণ সন্তুষ্ট কিনা এবং আপনাকে ১০ রেটিং দিচ্ছে কিনা। যদি সে সন্তুষ্ট না হয় তাহলে আলোচনার মাধ্যমে বাকি কাজটুকু সম্পন্ন করে দিন।

অর্থ তোলার উপায়সমূহ

একটি কাজ পুরোপুরি সম্পন্ন করার পর আপনার পাওনা টাকা ফ্রিল্যান্সিং তাদের সার্ভিস চার্জ রেখে বাকিটা ওই সাইটে আপনার একাউন্টে জমা করে দেয়। তারপর মাস শেষে বা মাসের মাঝামাঝি সময়ে আপনি সর্বমোট টাকা বিভিন্ন উপায়ে দেশে নিয়ে আসতে পারেন। এখানে টাকা উত্তোলনের কয়েকটি কার্যকরী পদ্ধতিগুলো নিয়ে বিস্তারিত আলোচনা করা হল:

ব্যাংক টু ব্যাংক ওয়্যার ট্রান্সফার

অর্থ তোলার একটি নির্ভরযোগ্য ও নিরাপদ উপায় হচ্ছে ওয়্যার ট্রান্সফার। এই পদ্ধতিতে মাস শেষে ৩ থেকে ৫ দিনের মধ্যে টাকা বাংলাদেশে আপনার ব্যাংক একাউন্টে সরাসরি এসে জমা হয়ে যাবে। তবে এই পদ্ধতিতে চার্জ একটু বেশি, প্রতিবার টাকা উত্তোলনে ৪৫ থেকে ৫৫ ডলার খরচ পড়বে। এই পদ্ধতিতে টাকা উত্তোলন করতে হলে আপনাকে নিম্নে উল্লেখিত তথ্যগুলো ফ্রিল্যান্সিং সাইটে প্রদান করতে হবে:

1.আপনার ব্যাংক একাউন্ট নাম্বার, ব্যাংক এর ঠিকানা, ব্যাংক এর SWIFT Code ।

2.ফ্রিল্যান্সিং সাইটি যে দেশে অবস্থিত সেই দেশের একটি ব্যাংক এর নাম যা মধ্যবর্তী হিসেবে কাজ করবে। এজন্য আপনি আপনার ব্যাংক এ গিয়ে জেনে নিন তারা ওই দেশের কোন কোন ব্যাংক এর মাধ্যমে টাকা আদান-প্রদান করে থাকে। এবং

3. এরপর মধ্যবর্তী ওই ব্যংক এর Routing নাম্বার আপনাকে সংগ্রহ করতে হবে যা আপনি ব্যাংকটির ওয়েবসাইট এ পেয়ে যেতে পারেন। ব্যাংক এর সাইটে না পেলে Google এ সার্চ করে পেয়ে যেতে পারেন অথবা আপনার ব্যাংক থেকেও সংগ্রহ করতে পারেন। যুক্তরাষ্ট্রের ক্ষেত্রে এই নাম্বারকে বলা হয় ABA Routing Number।

স্নে‍ইল মেইল চেক


এটি তুলনামূলকভাবে একটি ঝামেলামুক্ত কিস্তু সময়সাপেক্ষ পদ্ধতি। আপনার মোট আয় যদি ১০০ ডলারের এর উপর হয় তাহলে চেকের মাধ্যমে সাধারন চিঠিতে পেয়ে যাবেন। এক্ষেত্রে প্রতিবার খরচ পড়বে মাত্র ১০ ডলার। তবে চিঠি আসতে কয়েক সপ্তাহ সময় লেগে যেতে পারে। আর চেকটি আসবে ডলার-এ, তাই এটিকে টাকাতে রূপান্তর করতে হলে আপনার ব্যাংকের সাহায্য নিতে হবে।

পে-অনার ডেবিট কার্ড

উপরের উল্লেখিত দুটি পদ্ধতি থেকে সবচাইতে দ্রুত পদ্ধতি হচ্ছে Payoneer Debit Card। সম্প্রতি প্রায় সকল ফ্রিল্যান্সিং সাইটগুলো এই MasterCard সার্ভিসটি চালু করেছে। এই পদ্ধতিতে মাস শেষে আপনি টাকা খুবই দ্রুত পৃথিবীর যেকোন স্থান থেকে ATM এর মাধ্যমে উত্তোলন করতে পারেন। এজন্য এককলীন খরচ পড়বে ২০ ডলার আর মাসিক খরচ পড়বে ১০ থেকে ১৫ এর মত। ATM থেকে প্রতিবার টাকা উত্তোলনের জন্য খরচ পড়বে ২ থেকে ৩ ডলার। এজন্য প্রথমে ফ্রিল্যান্সিং ওই সাইটের মাধ্যমে Payoneer সাইটে একটি একাউন্ট করতে হবে। তারপর ১৫ থেকে ২০ দিনের মধ্যে আপনার ঠিকানায় একটি MasterCard পৌছে যাবে। কার্ডটি হাতে পাবার পর নির্দেশনা অনুযায়ী কার্ডটি সচল করতে হবে এবং ৪ সংখ্যার একটি গোপন পিন নাম্বার দিতে হবে। পরবর্তীতে এই নাম্বারের মাধ্যমে যেকোন ATM থেকে টাকা উত্তোলন করতে পারবেন। এখানে বলে রাখা ভাল বাংলাদেশে অনেকগুলো ব্যাংক এর ATM এই কার্ড সাপোর্ট করে না। স্ট্যান্ডার্ড চাটার্ড ব্যাংক এর ATM থেকে আপনি সহজেই টাকা উত্তোলন করতে পারেন।

ওয়েব ডেভেলপারদের জন্য কয়েকটি তথ্য

অনলাইনে যত ধরনের কাজ পাওয়া যায় তার মধ্য সবচেয়ে বেশি কাজ হচ্ছে ওয়েব ডেভেলপমেন্ট নিয়ে৷ ওয়েবসাইট তৈরি, পরিবর্তন, পরিবর্ধন, ওয়েবসাইট ক্লোন, টেম্পলেট বা ওয়েবসাইটের জন্য ডিজাইন তৈরি করা, সার্চ ইঞ্জিন অপটিমাইজেশন বা এসইও ইত্যাদি এর মধ্যে অন্তুভু্ক্ত৷ ওয়েবসাইট তৈরি করার ক্ষেত্রে স্ক্রিপ্টিং ল্যাঙ্গুয়েজ হিসেবে সবচাইতে বেশি ব্যবহার হয় পিএইচপি এবং ডাটাবেজ হিসেবে MySQL৷ পিএইচপি অত্যন্ত সহজ একটি ল্যাঙ্গুয়েজ, যা এক থেকে দুই সপ্তাহের মধ্যে শেখা সম্ভব৷ এ নিয়ে বাজারে প্রচুর বই পাওয়া যায়৷ আর গুগল-এ সার্চ করে আপনি প্রচুর কোড, টিউটরিয়াল, ওপেনসোর্স স্ক্রিপ্ট পেয়ে যাবেন৷ পিএইচপি এবং MySQL-এর সাথে HTML, Javascript, CSS, XML Jইত্যাদি বিষয়ের ওপরও ভাল জ্ঞান থাকতে হবে৷ এজন্য আপনি http://www.w3schools.com সাইটের সাহায্য নিতে পারেন৷

পিএইচপি এবং MySQL শেখার পর এবার নিজে কয়েকটি ওয়েবসাইট তৈরি করুন৷ সাইটের আইডিয়ার জন্য বিভিন্ন ধরনের ওয়েবসাইট পর্যবেক্ষণ করুন এবং এক বা একাধিক ওয়েবসাইটের ক্লোন করার চেষ্টা করুন৷ এতে আপনি একটি ওয়েবসাইটে কী কী ফিচার থাকতে পারে, সে সম্পর্কে একটি স্পষ্ট ধারণা পাবেন৷ ফ্রিল্যান্সিং সাইটে আপনি পূর্ব কাজের অভিজ্ঞতা হিসেবে এই কাজগুলো উল্লেখ করতে পারেন এবং ক্লায়েন্টকে আপনার তৈরি করা ওয়েবসাইটগুলোর স্ক্রিনশট দেখাতে পারেন৷

অনেক ক্ষেত্রে সম্পূর্ণ নতুন ওয়েবসাইট তৈরি না করে ক্লায়েন্টরা বিভিন্ন ধরনের ওপেন সোর্স স্ক্রিপ্ট পছন্দ করে৷ জনপ্রিয় কয়েকটি স্ক্রিপ্ট হচ্ছে osCommerce, ZenCart, Joomla, Drupal, Wordpress ইত্যাদি৷ এই স্ক্রিপ্টগুলোকে পরিবর্তন করা, নতুন মডিউল বা ফিচার যোগ করা, ডিজাইন পরিবর্তন করা ইত্যাদি নিয়ে অসংখ্য কাজ পাওয়া যায়৷ আপনি শুধু এরকম এক বা একাধিক স্ক্রিপ্ট নিয়ে কাজ করতে পারেন৷ এমন অনেক সফটওয়্যার ফার্ম আছে, যারা কেবল Joomla বা sCommerce-এর ওপর ভিত্তি করে প্রতিষ্ঠিত হয়েছে৷

অনলাইন ফ্রিল্যান্সিং হচ্ছে নিজের এবং দেশের অর্থনৈতিক মুক্তির একটি শক্তিশালী মাধ্যম৷ এই পদ্ধতিতে দেশ প্রচুর পরিমাণে বৈদেশিক মুদ্রা অর্জন করতে পারে৷ বর্তমান যুব সমাজ যেখানে বেকারত্বের অভিশাপে জর্জরিত, সেখানে আপনি নিজেই হয়ে উঠতে পারেন অন্যের চাকরিদাতা৷ খুবই সামান্য মূলধন আর কয়েকজন দক্ষ কর্মী নিয়ে আপনিও চালু করতে পারেন একটি সফটওয়্যার ফার্ম বা ডাটা এন্ট্রি হাউজ৷ এজন্য দরকার আপনার সাহস, দক্ষতা আর ফ্রিল্যান্সিং সাইটে ভাল একটি প্রোফাইল৷

শেষ কথা

ফ্রিল্যান্স আউটসোর্সিং কাজে ফ্রিল্যান্সারের স্বাধীনতা থাকে৷ ফ্রিল্যান্সারের ইচ্ছে মতো কাজ বেছে নেয়ার সুযোগ থাকে৷ একজনফ্রিল্যান্সার নিজের সুবিধামতো সময় বিবেচনা করেও কাজ বেছে নিতে পারে৷ আর এই কাজের জন্য সবচেয়ে ভালো দিক হচ্ছে, যেকোনো পেশার লোক বা চাকরিজীবী শুধু প্রোগ্রামিং বা সংশ্লিষ্ট কাজ শিখেই আউটসোর্সভিত্তিক ফ্রিল্যান্সিং করতে পারবেন৷এখানে যোগ্যতার মাপকাঠী হচ্ছে আপনি ফ্রিল্যান্সিংয়ের যে শাখায় কাজ করতে চান, সেই বিষয়ে আপনি কতটুকু জানেন৷ অন্যকোনো যোগ্যতার প্রয়োজন নেই৷ বাংলাদেশের প্রেক্ষাপটে এই ধরনের কাজ খুবই উপযোগী৷

বলার অপেক্ষা রাখে না, নয়-এগারোর পর থেকে পুরো বিশ্বেই আইসিটি খাতের লোকেরা কর্মপরিধি সীমিত করে দিয়েছিল৷ তার প্রভাব বাংলাদেশেও পড়েছে৷ পুরো বিশ্বের মতো এদেশেও কমপিউটার বিজ্ঞান বা কমপিউটার প্রকৌশলী অনুষদের ছাত্রসংখ্যা কমেছে৷ এই সময়ে আইসিটি খাতে কাজও কমে গিয়েছিল৷ এসব অনুষদের ছাত্রদের মধ্যে এক ধরনের হীনম্মন্যতা এখনো কাজ করে৷ আমাদের দেশের মতো দেশে যেখানে ভালো চাকরি বা কাজের পরিধি বেশ কম, সেখানে উন্নত বিশ্বে শুধু আইসিটি নয় যেকোনো অনুষদের ছাত্ররাই পড়াশুনার ফাঁকে ফাঁকে নিজ নিজ বিষয় সংশ্লিষ্ট পার্টটাইম কাজ করে উপার্জন করতে পারে৷ অনেক ক্ষেত্রে দেখা যায়, এ কাজ করে ছাত্ররা তাদের নিজ নিজ টিউশন ফি পরিশোধ করতে পারে৷ দুঃখজনক হলেও সত্যি, আমাদের দেশে এ ধরনের কাজ প্রায় নেই বললেই চলে৷ অথচ আমাদের পাশের দেশ ভারতেও আইসিটি সংশ্লিষ্ট অনুষদে পড়াশোনার পাশাপাশি কাজ পাওয়া যায়৷ পড়াশোনার পাশাপাশি এ ধরনের কাজে প্রধান সুবিধা হচ্ছে ছাত্ররা নিজেদের ভবিষ্যতযোগ্যতা সম্বন্ধে সচেতন থাকতে পারবে৷ প্রযুক্তিভিত্তিক যেকোনো বিষয়েই যা খুব জরুরি৷

আমাদের দেশে ছাত্রদের জন্য ফ্রিল্যান্স আউটসোর্সিং নতুন করে আশার সৃষ্টি করে৷ আইসিটির হাজার হাজার ছাত্রদের মধ্যে এমন হতাশা কাজ করে যে, আগের চেয়ে এই খাতে কাজ কমছে এবং এই কাজ কমার প্রবনতা কমাতে পারে অনলাইন ফ্রিল্যান্স৷ শুধু ফ্রিল্যান্স আউটসোর্সিং করে নিজেই আইসিটিভিত্তিক বাণিজ্যিক প্রতিষ্ঠান খুলে বসেছে এমন নজির খুব কম নয়৷ আর আমাদের পাশের দেশসমূহে ফ্রিল্যান্স খুব জনপ্রিয়৷ শুধু ভালো ইন্টারনেটের অভাবে আমরা অনেকদিন ধরেই এই খাত থেকে পিছিয়ে ছিলাম৷ যদিও ভালো ইন্টারনেট সংযোগের পুরো সুবিধা আমরা এখনো পাচ্ছি না৷ কজ


কেস স্টাডি - ০১

আউটসোর্সিং করে বাংলাদেশে অনেকেই বেশ আয় করছে



আমি এ. কে. এম. মোকাদ্দিম৷ বয়স ২৬ বছর৷ সিলেট শাহজালাল বিজ্ঞান ও প্রযুক্তি বিশ্ববিদ্যালরে সিএসই বিভাগ থেকে পড়াশোনা শেষে এখন একটি প্রাইভেট ফার্মে কাজ করছি৷

ফ্রিল্যান্স এখন আমার কাছে নেশার মতো৷ ২৫ বছর বয়স থেকে আমি ফ্রিল্যান্স আউটসোর্সিংয়ের সাথে জড়িত৷ শুরুতে নির্দিষ্ট কারো কাছ থেকে ফ্রিল্যান্স আউটসোর্সিংয়ের ব্যাপারে শুনিনি৷ তবে বিশ্ববিদ্যালয়ে থাকার সময় কয়েকজন বড় ভাই পরামর্শ দিয়েছিলেন ফ্রিল্যান্স আউটসোর্সিং করতে৷ তবে আমার শুরু তারও অনেক পরে৷ তার আগে বাংলাদেশের কাজ করতাম৷

ফ্রিল্যান্স আউটসোর্সিং শুরু করা বলতে শুরু নয়৷ শুরু করতে চাইলেই কেউ শুরু করতে পারে না৷ প্রথম প্রথম একটু সমস্যা হয়ই৷ কাজ পেতে একটু কষ্ট হয়৷ কারণ, কম রেটিং পাওয়া বা রেটিং ছাড়া কাউকে ক্লায়েন্টরা সহজে কাজ দিতে চায় না৷ আমিও অনেক পরে কাজ পেয়েছি৷ শুরুতে অনেক সময় ক্লায়েন্টের সাথে ঠিকমতো যোগাযোগ না করলে বা দেরি হলেও কাজ ছুটে যেত৷ ফ্রিল্যান্স আউটসোর্সিং জগতের অনেক টার্মসও বুঝতাম না৷ তাই কমিউনিকেশনে একটু সমস্যা হতো৷ হয়ত ক্লায়েন্ট বলছে এক সফটওয়্যারের কথা, আর আমি ভাবছি অন্যটি৷ এরকম আরো অনেক সমস্যাই হয়েছে৷ তবে ফ্রিল্যান্স আউটসোর্সিং শুরুতেই যা সমস্যা৷ কিন্তু একবার ভালো রেটিং করতে পারলে বা পুরো ব্যাপারটি বুঝে গেলে আর সমস্যা হয় না৷ আমার ভালো রেটিং পাবার পর আর পেছনে ফিরে তাকাতে হয়নি৷

ফ্রিল্যান্স আউটসোর্সিং করে অনেকেই এখন বাংলাদেশে বসে আয় করছে৷ বাংলাদেশে বসে আয় করতে কোনো সমস্যা নেই৷ এক সামাজিক প্রতিবন্ধকতা ছাড়া৷ কারণ, এদেশের মানুষের স্বপ্ন থাকে পড়াশোনা শেষে ব্যবসায় বা চাকরি করা ৷ আর ফ্রিল্যান্স আউটসোর্সিং এগুলোর সাথে ঠিক মেলে না৷ বেশিরভাগ মানুষই ভাবে এটা একটি ক্ষণস্থায়ী কাজ৷ অনেকেই বুঝে না ফ্রিল্যান্স আউটসোর্সিং কী তবে আস্তে আস্তে পরিবর্তন হচ্ছে৷ ইদানীং অনেকেই এটাকে ভালো চোখে দেখছে৷

কাজশেষ হলে টাকা পাওয়া যায়৷ উন্নত বিশ্বের সুযোগ-সুবিধা কম বলে বাংলাদেশে টাকা আনা একটু ঝামেলার৷ কারণ, বাংলাদেশে paypal নেই৷ বেশিরভাগ পেমেন্ট হয় এর মাধ্যমে৷ টাকার জন্য থার্ড পার্টি সার্ভিস যেমন Xoom, Western Union দিয়ে টাকা আনতাম প্রথম দিকে৷ এখন অবশ্য ক্রেডিট কার্ডের মাধ্যমে টাকা আনি৷

ফ্রিল্যান্স আউটসোর্সিংকে পুরোপুরি পেশা হিসেবে বেছে নেয়া যায়৷ এতে মাসিক আয়ের কোনো ঠিক নেই৷ যদি সময়মত কাজ পাওয়া যায় আর ঠিকমত কাজ ডেলিভারি দেয়া যায়, তবে 800 থেকে 1200 ডলার আয় করা সম্ভব প্রতিমাসে৷ এটি নির্ভর করছে অভিজ্ঞতা ও সুনামের ওপর৷

ফ্রিল্যান্স আউটসোর্সিং করতে চাইলে যে শুধু ফ্রিল্যান্স আউটসোর্সিংই করতে হবে বা এর প্রোগ্রামিং জানতেই হবে এমন কোনো কথা নেই৷ কোনো কিছু না জানলে ডাটাএন্ট্রির মতো কাজ করা যেতে পারে৷ ঘরে বসে ইন্টারনেটে শুধু সফটওয়্যার ডেভেলপমেন্ট ছাড়াও গ্রাফিক্স ডিজাইন, এনিমেশন, পেইন্টিং, মার্কেটিং, ফ্যাশন ডিজাইনিং, ক্যাড, ফটোগ্রাফি, কনসাল্টিং, কাস্টমার সাপোর্ট ইত্যাদি কাজ করে আয় করা যায়৷ তবে শুধু কাজ পেলাম আর কাজ করলাম তা নয়৷ ফ্রিল্যান্সে আসলে ডেভেলপমেন্টের কাজ করা ছাড়া অন্যান্য কাজ যেমন ক্লায়েন্ট হ্যান্ডলিং, নতুন কাজ যোগাড়- এসব করার জন্য যথেষ্ট সময় দিতে হয়৷ এজন্য ভালোই সময় দিতে হয়৷ প্রতিদিন প্রায় ১২-১৪ ঘণ্টার মতো সময় দিতে হয়৷

ফ্রিল্যান্স আউটসোর্সিংয়ে রেটিং খুব গুরুত্বপূর্ণ বিষয়৷ রেটিংয়ের ব্যাপারে সবাইকেই মনোযোগী হতে হবে৷ তা না হলে ফ্রিল্যান্স আউটসোর্সিং না করাই ভালো৷ আমার রেটিং 10/10৷ আর http://www.script-lance.com -এ সর্বোচ্চ ৠাংকিং ছিল 221৷ বর্তমানে এটা কমে গিয়ে 191-এ নেমেছে৷ কারণ, আমি এখন বিভিন্ন সাইটে কাজ করছি৷ রেটিং বাড়াতে হলে টাইমলি বাগ ফ্রি সফটওয়্যার ডেলিভারি দিতে হবে, অবশ্যই চাহিদা পূরণ করতে হবে৷ এসব করলে রেটিং বাড়বে এতে কোনো সন্দেহ নেই৷ তারপরও সবকিছুই নির্ভর করে গ্রাহকের ওপর৷ কারণ রেটিং দেয়ার ক্ষমতা তার হাতে৷

কাজ করতে করতে অনেক মজার ঘটনাতো ঘটে৷ আমার ক্ষেত্রে তেমন কোনো মজার ঘটনা নেই আসলে৷ তবে মাঝে মাঝেআমি কোনো কোনো প্রকল্প প্রস্তাবনা দিলে হয়ত দেখতাম আমার কোনো বন্ধুও সেখানে প্রোপোজাল দিয়েছে, পুরোটাই অনিচ্ছাকৃত৷কিন্তু একটা স্নায়ুযুদ্ধ ভর করে মনের মধ্যে৷ তবে এক্ষেত্রে পেশাদারিত্বের কোনো বিকল্প নেই৷ অন্যান্য দেশের ফ্রিল্যান্সাররা অনেকপেশাদার৷ আমরা সে তুলনায় পিছিয়ে আছি৷

বাংলাদেশে এটার সম্ভাবনা খুবই উজ্জ্বল৷ এটা পুরোপুরি মেধা ও সৃজনশীলতার ব্যাপার৷ আমাদের দেশের ছেলেদের কোয়ালিটিঅনেক ভালো৷ শুধু কাজে লাগাতে হবে৷ এজন্য বিশ্ববিদ্যালয় কর্তৃপক্ষ ছাত্রদের মধ্যে সচেতনতা সৃষ্টি করতে পারে৷ ইদানীং অনেকবাংলাদেশীই ফ্রিল্যান্সিংয়ে আসছে৷ এক বছর আগেও এর হার বেশ কম ছিল৷ ধীরে ধীরে এটি জনপ্রিয় হচ্ছে৷ তবে এ কাজের জন্যবিদ্যুত্ ও ইন্টারনেট অপরিহার্য অংশ৷ তাই এ দুটো বিষয়ে সরকারের পদক্ষেপ নেয়া উচিত৷

নতুন যারা ফ্রিল্যান্স আউটসোর্সিং করতে চাচ্ছে তাদেরকে বলব তাড়াহুড়া না করতে৷ একটু সময় লাগতে পারে৷ তবে সফলতা অনিবার্য৷ লেগে থাকলে সফলতা আসবেই।


কেস স্টাডি - ০২

বাংলাশেফ্রিল্যান্স আউটসোর্সিংয়ের ভবিষ্যত্ খুবই উজ্জ্বল



আমি এ. এইচ. এম. শাহনূর আলম শাওন৷ চট্টগ্রারে সি, ইউ, ই, টি, থেকে সিএসই বিভাগে স্নাতক ডিগ্রি নিয়েছি৷ আমার বয়স ২৬, এখন ফ্রিল্যান্স আউটসোর্সিং করছি৷

সর্বপ্রথম আমি একটি জাতীয় দৈনিকে প্রকাশিত একটি ফিচার পড়ে জানতে পারি ফ্রিল্যান্স আউটসোর্সিংয়ের মাধ্যমে ঘরে বসেকাজ করে আয় করা সম্ভব৷ তখন থেকেই আমার চিন্তা ছিল কিভাবে এর মাধ্যমে সফল হওয়া যায়৷ যেই ভাবা সেই কাজ৷ বলাযায়, এর পর থেকে এক্ষেত্রে আমার অভিযানের শুরু৷ আমি প্রায় আড়াই বছর ধরে এই আউটসোর্সিংয়ের সাথে জড়িত৷

প্রথম যখন আমি কাজ শুরু করি, তখন আমার আশপাশে এমন কেউ ছিলো না, যার কাছে আমি নতুন কোনো সমস্যা নিয়ে আলোচনা করতে পারি৷ যার কারণে নিজেকেই সব সার্চ করে সমাধান বের করতে হতো৷ এতে করে অনেক সময় দেখা গেল, খুব ছোট একটা সমস্যায় আমাকে অনেক বেশি সময় খরচ করতে হয়েছে৷ শুরুতে কোনো গাইডলাইন পাইনি৷ তবে কাজ করতে গিয়ে নানা সমস্যায় পড়তে হয়েছে৷

যে সমস্যাগুলো আমাকে মারাত্মকভাবে ভোগায় সেগুলো হলো-

০১. ধীরগতির ইন্টারনেট-যা আমাদের প্রোডাক্টিভিটি অনেকাংশে কমিয়ে ফেলে৷ যেমন ধরুন, আমাকে একটা সাইটের বাগ ফিক্সড করার জন্য বলা হলো, আর সময় দেয়া হলো ২ ঘণ্টা৷ কিন্তু ধীরগতির ইন্টারনেটের কারণে সাইটটি ব্রাউজ করে বাগ পয়েন্ট আউট করতেই আমার লেগে গেল ৯০ মিনিট৷ দ্রুতগতির ইন্টারনেট থাকলে একই কাজ ৩০ মিনিটে করা সম্ভব৷

০২ বিদ্যুত্ সমস্যা হচ্ছে আরেকটি প্রধান সমস্যা৷ ধরা যাক কোনো জরুরি কাজের ডেডলাইন হচ্ছে ৩ দিন এবং আমার সেটি ৩ দিনের মধ্যে শেষ করতে গেলে প্রতিদিন ১০ ঘণ্টা করে কাজ করতে হবে৷ দেখা গেল পরবর্তী ৩ দিনে সব মিলিয়ে বিদ্যুত্ থাকল ১০ ঘণ্টা৷