Wednesday, September 17, 2008

Magento a hope that will change the world....

Magento is a feature-rich eCommerce platform offering complete flexibility and control over the look, content and functionality
of an online store.

Key Features :-

Site Management
Control multiple websites and stores from one Administration Panel with ability to share as much or as little information as needed
Web Services API for easy integration between Magento and any third-party application

Marketing Promotions and Tools
Flexible Coupons (pricing rules) with ability to restrict to stores, customer groups, time period, products, and categories.

International Support
Support for Multiple Currencies

Shipping to multiple addresses in one order

Customer Accounts
Re-orders from account

Catalog Management
Batch Import and Export of catalog

Catalog Browsing

Layered / Faceted Navigation for filtering of products
Product comparisons

Friday, March 28, 2008

Get Ready For Rails 2.0

Be Get Prepared for upgrade with Ruby On Rails

Some hints can be followed as below :-

@params, @session, @flash, @env

As of Rails 2.0, you won’t be able to directly access the above instance variables. They have been replaced with methods, which makes customising their actions much easier. It also allows the internals of Rails to change without breaking the API. This is very easy to fix - just remove the @ in front of those variables - they will work exactly the same.

find_all, find_first, render_partial

In earlier version of Rails there were a number of grouped methods, that do very similar things - find, find_all and find_first all fetch records from the database, the only difference is the number of records they return. It was decided to combine these methods in to one where they are differentiated by passed in options. So find_all becomes find(:all) and find_first becomes find(:first) and render_partial becomes render(:partial).


Out of all the HTML helpers, the form tag was an anomaly because it required a start AND end helper. To make it fit in with way the rest of Rails works and to facilitate dynamic form generation, a block method called form_tag was created. This particular update has a trap in it through - because blocks don’t return values, the ERB tag you use must not have an = sign, so
<%= start_form_tag %>
<%= end_form_tag %>

<% form_tag do %>
<% end %>

Notice the omission of the equals sign in the latter example?

Also note that passing :post => %gt; true is deprecated. With the push for RESTfulness, the form needs to know about the other HTTP verbs, put and delete, so a new option has been created:
<% form_tag :method => :post do %>
<% end %>


A number of what used to be core components of rails have been moved out into plug-ins so as not to clutter the core with stuff that you don’t use very often. It also means that the development of the plugins can be much quicker than that of the core. Probably the major extraction is the third-party database interfaces. Now, by default only MySQL, SQLite and PostgreSQL are supported out of the box. All other databases are supported via gems named activerecord-database-adapter. If you want to use an Oracle just run

gem activerecord-oracle-adapter

and you will be peachy again.

Other extractions of note are the acts_as plug-ins. If you use acts_as_tree or acts_as_list in your model, you will need to script/plugin install them and the built-in pagination has now become the classic_pagination plug-in. Note that by the developers own admission that plug-in is slow (and was slow when it was in core), so if you use it, you may want to think about migrating across to the new and improved will_paginate plug-in.

Hurry up and get upgrade before time get elasped... :)
So GET, SET , Go................................

PHP Vs Ruby

Ajax: Rails and Symfony both use Scriptaculous and Prototype. CakePHP
does, but you have to download and install it separately, which, to
me, calls into question how well they're integrated.

Authentcation: CakePHP has a built-in system, but that system won't
fit all needs, so you'll end up writing custom code anyway.

Caching: CakePHP only has view caching.

Database versioning: None in CakePHP or Symfony, though Symfony has an
XML file for each db table, and, I suppose, you could svn them and
have versioning that way. Migrations in Rails are superior.

Environments: No real separation of environments (prod/dev/test) in

Console: None in CakePHP. Symfony and Rails, yes. If you want to use
Rails and you think you won't use the console, you're wrong. Once you
understand the power, you'll never want to debug without it.

Testing: Little integrated testing. It produces some stubs when you
"bake" a project, but I prefer how Rails puts those stubs there when
you're creating models and controllers, right from the get-go. (More
on this below.)

Join models: None in CakePHP. Rails has HABTM and has_many :through.
All tables are models in Symfony, so that's almost the same. More
like HABTM with extra info in the table. Propel, Symfony's ORM
engine, is actually quite interesting. (Though, I prefer

Form validation: Good in all frameworks, but there are some extra
steps involved in dealing with invalid form data in CakePHP.

Sunday, February 24, 2008

Increase your Blogg popularity

Get a creative commons license for your blog content
Creative Commons makes it easy to assign a license for your online content. I use a license called “Attribution-NonCommercial 2.0″
This means (in english)
You are free to* to copy, distribute, display, and perform the work* to make derivative works
Under the following conditions:* by Attribution. You must attribute the work in the manner specified by the author or licensor.* Noncommercial. You may not use this work for commercial purposes.
Get a feedburner account and direct feeds through feedburner
Most probably your blogging software will automatically provide an RSS feed capability. However, chances are that you may not be able to track how many readers are subscribing (and how they are subscribing) to your feed. By burning your feed via feedburner, you can get those statistics. Again, it only takes a few minutes to setup a free account on feedburner.
Implement subscription chiclets
People use variety of RSS readers and you want to make it easy for them to subscribe to your feed from those RSS readers. Feedburner provides scripts to create those subscription chiclets. I suggest that you should take a look at the available options and add those chiclets to your blog site.
Claim your blog on technorati
By registering yourself at technorati and claiming it, you have an ability to put your photo with your profile. When people search for stuff on technorati and your blog comes up in the search results your thumbsize photo appears with the search result. Every single thing helps.
Provide email subscriptions to your blog
You will be amazed how many people want to read your blog via their email. It’s easy to set that up. You can get a script to do that by registering at Feedblitz.
Link to your photo album
If you have an online photo album with a service like Flickr, put in a link to that as well.
Announce your blog to the world
The first thing that you can do is to use a service like Pingomatic to ping a few servers. Of course, best would be to write compelling content that would make others link to your site.
Register at Blogwise
Blogwise is a directory that is created manually by a bunch of cool folks. You can submit your blog for inclusion and someone over there will add it to the directory if they find the content appropriate. You can check out the listing for Life Beyond Code and may be leave your comments on this blog there.
Register in the TTLB ecosystem
TTLB (The Truth Laid Bear) eco-system ranks blogs by links.
Register at Blogarama
Blogarama is another manually moderated registry.
Link to your online bookmarks
If you have an account with and are tracking some interesting websites, you can link to your bookmark page.
Validate your feeds
Simple way is to subscribe to your own feed in your RSS readers. Other way is to use FeedValidator to check if everything is OK
Geo-tag your blog
Feedmap provides a simple way of associating your physical co-ordinates (city, zip) to your blog. As more people sign up for this service, your blog will appear in the “bloggers nearby” for your neighbours blogs.
Claim your blog at Feedster
You claimed your blog at Technorati. Now, please go ahead and claim it in Feedster as well. If you do well, you might even get into the feedster elite club “Feedster Top 500″ You can add an icon or your photo to personalize the search results
Enable MyBlogLog click tracking
MyBlogLog is really cool. It takes about 2 minutes to implement on your blog and provides real-time tracking (Pro Version) of user behavior (where did they come from and where did they go) on your blog.
Publish your conversations from other blogs to your blog via Comment
Succeeding in blogging requires participating in conversations. How do you bring all your conversations in one place? Well, CoComment has an answer via their Firefox plugin.
Leverage the power of HitTail to get more traffic
HitTail reveals in real-time the least utilized, most promising keywords hidden in the Long Tail of your natural search results. We present these terms to you as suggestions that when acted on will boost the natural search results of your site. It’s that simple.
Get cool widgets from MajikWidget
Do you want to add polls, voting or rating for your blog? Check out cool widgets from Majikwidget. You can get them for a song.
Register in BlogTopSites
BlogTopSites is a directory of blogs. Register your blog under the right category.
More widgets from WidgetBox
There are hundreds of them here. You can pick and choose…
Post your LinkedIn Profile via LinkedInABox
Amir Glick and Yaniv Solnik have a cool widget to display your LinkedIn profile on your blog sidebar.
Give back some link love with WhoLinked
WhoLinked will search through the web and send you back a list of sites that are linking to your site. You can say “thank you” to those sites by putting up this widget.
Provide target website previews via Snap Preview
Snap Preview Anywhere enables anyone visiting your site to get a glimpse of what other sites you’re linking to, without having to leave your site. By rolling over any link, the user gets a visual preview of the site without having to go there, thus eliminating wasted “trips” to linked sites.Register your blog at Findory

Findory aggregates some of the finest blogs and they recommend content based on users’ interest. So if a user is reading an article in another blog that has similar content, he or she may be presented with your blog to consider reading.
Get Clustrmaps for your blog
Show visitor count and the regions from where the visitors are coming

Web SEO Solution, SEO Company India, Search Engine Optimization India, Search Engine Marketing India, Web Marketing Company India

Friday, February 1, 2008

Exciting future with PHP5 and Oracle.

Get an overview of some of the new features in PHP 5—as well as comments on its future for Oracle users—from its release manager.

PHP 5 (PHP: Hypertext Preprocessor Version 5) was officially released on July 13, 2004. Not surprisingly, the release was widely covered by the media due to the leadership role PHP plays in the Web application market. It is true that technologies such as .NET and J2EE have had more exposure and hype than PHP, but ease-of-use, performance, tight integration with the Apache Web server, and a large collection of application building blocks have made PHP one of the leading Web application development languages.

You might ask yourself, since PHP 4 featuring the Zend Engine was so successful, why do we even need PHP 5 and the Zend Engine II? The truth is that there are certain areas in which PHP 4 does not excel. Most of these areas are more important for large projects and companies, where project management is more structured and interoperability between systems is a must. PHP 5 addresses these issues, allowing PHP not only to be more attractive for such projects but also to remain a leading technology for Web application development.

In this article I will address:

* The reasoning behind PHP 5
* A short overview of some of its new features
* A brief look at the future for PHP and Oracle users.

The New Object-Oriented Model of the Zend Engine II

Background With PHP's adoption growing steadily, its use in larger projects is also constantly increasing. There does seem to be a connection between large projects and the use of object-oriented (OO) methodology. Not that you can't write a small OO application, and it is certainly possible to write large, impressive applications without object-oriented programming (OOP). However, there does seem to be a tendency to pick the OO paradigm in these cases—probably because OOP offers more conventional tools for functional and technical design (UML — Unified Modeling Language), reuse of solutions for recurring problems (design patterns), and built-in mechanisms in the OO languages themselves that help enforce software designs and contracts.

The main problem with PHP's object model in prior versions was that objects were implemented as native types with copy semantics similar to integers and strings. This not only led to some very confusing behavior, due to sometimes unexpected implicit object cloning by PHP, but it also didn't allow us to implement some basic features, such as the ability to de-reference objects that are returned from methods.

The following examples illustrate these two problems.
a) Implicit object cloning:

class Person {
var $name;

function Person($name) {
$this->name = $name;

function setName($name) {
$this->name = $name;

function getName() {
return $this->name;

function lowerCaseName($obj)
$new_name = strtolower($obj->getName());

$obj = new Person("Andi");
print $obj->getName();


Most developers would expect this example to print out "andi." However, surprisingly, this example prints out "Andi" in PHP 4. This is due to the previously mentioned way PHP 4 treats objects like regular native types, and as a result, passing $obj to lowerCaseName() by value actually clones the object. The resulting manipulation that lowerCaseName() performs on $obj is done on a cloned version of the object. This behavior not only leads to surprising results but, for developers who were aware of this problem, it would require passing and returning objects by-reference, which would make the code harder to maintain because they'd have to insert "&" in many places (passing by-reference, returning by-reference, and assigning by-reference).

b) Inability to de-reference objects returned from methods:


If you aren't familiar with PHP 4, you would probably expect this example to work. However, as a result of the before-mentioned implicit cloning, the ability to de-reference an object that is returned from a method did not exist and could not be implemented. As a workaround, a lot of PHP 4 code would look as follows:

$temp_obj &= $obj->getParentObject();

There are other examples of how the basic infrastructure of objects was flawed in PHP 4, but these two examples should give you a good idea.

Main new language features. The most basic and important change in PHP 5 is to use handles (or id's) for objects instead of implementing them as native datatypes. When copied, only the handle (the id number) itself is actually being copied; the objects these handles represent are not being copied. This seemingly minor change in the semantics of the language is the major driving force behind the majority of the new PHP 5 features. It allows the addition of new language features and new PHP extensions, such as the great SimpleXML that takes full advantage of the new semantics.

Without going into too much detail (or this article would become a book), the following is a list of new language features in PHP 5.

New object cloning semantics As mentioned, the scripting engine never automatically clones objects in PHP 5, whether they are assigned, passed by-value, or returned by-value from a function. If cloning is required, then the developer may explicitly clone an object by using the new clone keyword (for example, clone $obj;). The developer may also implement a method named __clone() in his class, which will be called on the new resulting object, after the clone operation has copied all of the original object's properties. Implementing this callback is not required but can be useful if the developer wishes each object to have its own copy of a certain resource, thereby creating a new version of that resource for the cloned object (otherwise, both objects would be using the same resource). An example of such a resource is a file.

Public/private/protected access modifiers. PHP 5 supports the PPP (Private/Public/Protected) access modifiers commonly found in other object-oriented languages, such as C++ and Java. These access modifiers may be used on both properties and methods, and impose access restrictions.

Interfaces and abstract classes and methods. We at Zend Technologies received many requests for multiple inheritance (MI) in PHP, so we decided to address this issue in PHP 5. After comparing the implementation of many languages—mainly C++ and Java—to see which could be most easily adapted to PHP's dynamic nature, we decided to provide a solution for MI by using Java-style interfaces and abstract classes.

Ability for PHP extensions to overload PHP object syntax. Probably one of the most significant features of PHP 5 is the way the Zend Engine II has an abstraction layer between the object syntax and its semantics. This approach allows PHP extensions to create their own objects, which have different behavior than the user-level PHP objects. For example, the new COM extension uses these overloading capabilities in order to access COM objects in a way that is natural for PHP developers, using the regular PHP object syntax:

$ie = new COM("InternetExplorer.Application");
$ie->Visible = true;

Other extensions that take advantage of this ability include the SimpleXML, SOAP, and Perl extensions.

Other New Features There are probably a dozen more new language features in PHP 5, such as class constants, static properties and methods, __autoload(), and instanceof operator.You can find a more complete list at

Design Patterns As previously discussed, the ability to use design patterns in large (and often also small) PHP software projects is extremely important. It was possible to take advantage of such patterns in PHP 4, but—lacking important language features such as static properties and methods, PPP access modifiers, and interfaces—it was often hard to enforce all of the semantics of these patterns.

Singleton Pattern An often-used and excellent example is the Singleton pattern. Although it is one of the simpler patterns, in order to implement it in its entirety, static properties and methods and PPP access modifiers are a necessity.

For example:

class MySingleton {
static private $instance = NULL;

private function __construct() {

private function __clone() {

static public function Instance() {
if (self::$instance == NULL) {
self::$instance = new MySingleton();
return self::$instance;
// ... Additional code for the MySingleton class.

This implementation takes advantage of the new PHP 5 features, which results in a cleaner and less error-prone Singleton implementation. For example, the ability to declare the constructor and clone methods as private prevents developers from mistakenly instantiating an additional copy of the MySingleton class, as only the class itself may access these methods. The support for static properties is used in order to have a globally accessible property (self::$instance) that references the single instance of the class. Declaring the property private makes sure that only the class itself may fiddle with this property.

Immutable Object Pattern Another slightly less common design pattern is the Immutable Object pattern. This pattern is usually used in applications where a large amount of references to a relatively small group of values exists. It allows the application's code to share objects by making the objects immutable (forbidding their state to change), and forcing code that wants to do so to create a new instance of the class.

The following example shows how you can create a class that represents a SQL query. The assembled query statement itself might be used in many places in your application. Code that wishes to change the value of the query may do so using the changeStmt() method, which returns a handle to a new object that represents the specified query string.

final class ImmutableQueryStatement {
private $stmt;

public function __construct($stmt) {
$this->stmt = $stmt;

public function getStmt() {
return $this->stmt;

public function changeStmt($stmt) {
return new ImmutableQueryStatement($stmt);

This example takes advantage of a few new PHP 5 language features. To begin with, it uses the final keyword so that the class may not be "subclassed." This approach prevents developers from subclassing and implementing a version that may be mutable. In addition, changeStmt() takes advantage of the new object handles and returns the newly created object by-value (in PHP 4, a new object instance would have to be returned by reference, complicating the implementation). Last but not least, similar to the previous example, access modifiers are used to specify the access contract this class should adhere to.

XML and Web Services in PHP 5

Background In the past few years, XML has become increasingly important, allowing different applications and systems to interoperate using standard tools and methodology for dealing with data. This is one of the reasons for Oracle's and other vendors' strong support and adoption of the technology. In every company, the data is the centerpiece of the organization.

XML support in PHP 4 was quite a mess. Although it supported SAX (Simple API for XML), DOM (Document Object Model) and XSL (eXtensible Stylesheet Language), there was no unified and standards-conforming implementation. The SAX implementation was based on the aging Expat XML parser, the DOM extension's naming conventions weren't standards-conforming, and the extension never left experimental status. Also, XSL was supported using yet another XML library called Sablotron.

It was decided to rewrite the XML support in PHP 5, and a few developers from the PHP community stepped up to make this rewrite a reality. The first and most important decision was that all XML functionality be based on the excellent libxml2 library from the Gnome's project. With this in mind, all three existing extensions were rewritten. Most important, the DOM extension was revamped and its interface redefined to be W3C-compliant. At the time of PHP 5's release, DOM was no longer experimental but full-featured and stable.

SimpleXMLBesides the importance of rewriting and unifying the existing XML extensions, a new XML extension has emerged. This extension, called SimpleXML, allows developers to access XML files as if they were native PHP objects. Going back a few sections in this article, this became possible due to the new Zend Engine II giving extensions the ability to overload the object-oriented syntax.

Consider the following XML file:

John Doe

Janet Smith

The following PHP 5 code iterates over the XML file and prints out the names and account numbers of the clients:

$clients = simplexml_load_file('clients.xml');

foreach($clients->client as $client) {
print "$client->name account: $client->account_number\n";

Running this sample script would result in the following output:

John Doe account: 87234838
Janet Smith account: 72384329

With SimpleXML, accessing XML files becomes extremely easy. I have no doubt that SimpleXML will revolutionize the ease-of-use provided to the PHP developer for dealing with XML files. And if there are certain things SimpleXML cannot do, then due to the fact that both SimpleXML and the DOM extension use the same underlying library, the SimpleXML object can be converted to a DOM tree and more-advanced XML manipulations can be done in DOM. This conversion back and forth between SimpleXML and DOM is zero-copy, meaning it costs neither time nor additional memory.

SOAP Going back to my introduction, I mentioned interoperability as a key issue for large companies. Web services— and more specifically, the SOAP protocol—are becoming increasingly popular for solving interoperability issues between two or more systems.

As PHP 4 did not feature native integrated SOAP support in the default distribution, we believed that this issue had to be addressed for PHP 5. Therefore, we created a new native implementation for SOAP (client as well as server APIs) that allows PHP developers to create and consume Web services easily.

The following example shows just how easy it is to call SOAP services from PHP. You might notice that this extension uses the same object-oriented overloading capabilities as mentioned previously.

$client =
new SoapClient("");


At the time of this writing, running this example resulted in printing 11.23.

The Future and Oracle

General Released in July 2004, PHP 5 has only been around for a short time. Despite that, there are already quite a few interesting things happening in PHP development. There has been a lot of work on improving the performance of the scripting engine and, most importantly for the Oracle readers, there are many new database-related initiatives. Use of Oracle is strong in the PHP community, and a large amount of Zend customers are Oracle users. Their use of Oracle varies as it does with other databases but is usually a very conscious choice, which has to do with Oracle's proven track record, advanced features, and often an already existing investment in Oracle infrastructure.

Scripting Engine Performance When developing PHP 5, Zend and the community focused more on functionality than on performance. Therefore, except for a few exceptions, performance of the scripting engine was not improved between PHP 4 and 5.

In most PHP applications, the raw execution performance of PHP is not the main bottleneck. The most common bottlenecks are related to I/O and are usually database-related. That said, we still believe that improving the performance of the scripting engine itself will definitely benefit the PHP user. For this reason, we decided to invest significant resources to improve performance for PHP 5.1.x.

Since the release of PHP 5, we have invested a lot of resources in tuning the scripting engine. Many ideas were taken from a performance patch that Thies Arntzen and Sterling Hughes published about a year ago. Other ideas came from inside Zend and the PHP developer's community. The end result is an engine that is commonly more than twice as fast as PHP 4.0 and PHP 5.0 for synthetic benchmarks (benchmarks that don't include I/O and real-world code).

The improvement is quite impressive, and when PHP 5.1.0 is released all of the PHP users will enjoy it without having to make any changes to their source code. I believe that PHP 5.1.0 will be released early in the first quarter of 2005, but one can never tell with an open source project.

SQL Relay. SQL Relay (is a very interesting third-party project. It is a project that implements a proxy broker for SQL connections (including Oracle), allowing for connection pooling of database connections using PHP.

The project provides its own version of a PHP database extension (you will be required to change your PHP database code). This extension talks to the SQL Relay broker that relays queries and result sets to and from the database.

Some of SQL Relay's advantages:

* Using connection pooling, you can limit the amount of open connections to the database.
* In case PHP persistent connections can't be used in your environment, this solution solves the problem of long connect times when initiating an Oracle database connection.
* The project supports other programming languages too. If you have a hybrid environment, you can take advantage of the same SQL Relay daemons that are being used from PHP. In addition to PHP, language support includes C, Java, Perl, and quite a few more.
* Getting up and running with SQL Relay, although not trivial, is quite simple. I'd also like to note that the SQL Relay author was very responsive to my questions.

Some of SQL Relay's disadvantages:

* You have to use a different API than the PHP Oracle extension.
* Result sets are copied twice: first to the SQL Relay broker and then to PHP.
* You don't have as rich an API as you do when using PHP's native oci8 extension.

I think that if your project does require Oracle database connection pooling, it is a good idea for you to check out SQL Relay. It might not be perfect, but it might still take a while until a better solution comes along, and this one does seem to work.

PDO The PHP community has been working on a new database abstraction layer in addition to the existing oci8 PHP extension that has a native interface to the Oracle Database. As Oracle Technology Network already has an in-depth article covering PHP Data Objects (PDO), by Wez Furlong, suffice to say that PDO is something to watch. PHP has been waiting for quite some time for good native database abstraction. I believe that PDO may very well be the solution we have all been waiting for. The designers of PDO are some of the lead developers of the PHP community, and I like their approach with PDO. The following is a list of their design goals, as written in the PDO README file:

1. Be lightweight.
2. Provide a common API for common database operations.
3. Result in high performance.
4. Keep the majority of PHP-specific code in the PDO core (such as persistent resource management); drivers should only have to worry about getting the data and not about PHP internals.

On one hand it gives a common API for working with databases. But it also allows each driver to add its own additional functionality, so that PDO not only supports the least common denominator of the database APIs but will actually give you the opportunity to use all the features your database has to offer. And we all know Oracle has lots of them.

Propel Propel is an object persistence and query framework. It implements object/relational mapping (ORM) and is based on the Apache Torque project, which does the same for Java. Unlike PDO, Propel is a very high-level database abstraction layer, redefining how you query, create, and manipulate persistent objects. Propel, as expected from an OO/RDBMS mapping system, also deals with database schema creation.

There are many advantages to a system like this. For starters, developers can concentrate most of their time on writing business logic and have to deal less with the intricacies of the database—whether it is schema management or writing fancy SQL statements. Database manipulation is very natural, as developers just deal with regular objects and the persistence layer deals with the low-level details of updating the right fields and rows in the database.

The disadvantage is that you do lose some control. The automatic mapping of the OO model to the relational database is not always straightforward. Not only does it make it hard to write fancy, powerful, hand-crafted queries, but you're also not supposed to do so—you break the abstraction, and a tiny update of the mapping might break the application. Therefore, using such a system means you have to play by the rules of the tool. In most cases, this price is acceptable, as increased productivity helps shorten development times and improves code quality. However, there are certain instances where you might absolutely require this control.

Propel is a very interesting project and can come in handy. In addition, it is built on top of a database abstraction layer called Creole. Unlike PDO, this abstraction layer tries to mimic JDBC as much as possible and might be easier to use if you are converting existing Java code to PHP. That said, if PDO becomes mainstream and is distributed as part of standard PHP, it might be best to stick with that.

Java Integration Over a year ago, Zend and Sun Microsystems started Java Specification Request (JSR) 223 to define a standard on how to bridge between PHP and Java. Today the JSR's expert group comprises many software vendors, including Oracle. Although the JSR talks about all scripting languages, the initial interest was in PHP and mainly the possibility of calling Java code from PHP. You can guess that one of the primary motives for such connectivity would be to connect front-end PHP servers to back-end J2EE application servers and, more specifically, the ability to call Enterprise Java Beans (EJBs) directly from PHP code.

The following is an example of what making an Oracle JDBC query would look like using the Java interface:

figure 1
Figure 1: Bridging PHP and Java: What an Oracle JDBC query would look like

You can see that what you'll be able to do is write Java code in PHP. This should allow you to call any Java business logic you might have, specifically EJBs.

Such bridging support opens up new possibilities for Oracle Application Server users, who have invested in back-end business logic but want to take advantage of the fast development times and features of PHP.


PHP 5 has definitely been a great step forward for PHP and the PHP community. At the O'Reilly Open Source conference, a reporter asked some of us PHP community leaders if PHP 5 was everything we had hoped for. The answer was unanimous; PHP 5 has become much more than we initially had planned and expected.

More specifically, I think Oracle users have a lot to look forward to. With Oracle's published Statement of Direction regarding PHP inclusion in future Oracle Application Server releases, it is clear that the company has recognized the importance of PHP technology. I believe that following this recognition will come a variety of solutions that will improve Oracle/PHP productivity and flexibility, both very much required in today's ever-changing market. The initial bundling of PHP in the upcoming version of Oracle 10g and the PHP extension for Oracle JDeveloper are significant first steps for widespread PHP support by Oracle.

Thursday, January 31, 2008

Building Web Applications with Ruby on Rails

Ruby on Rails has taken the web application community by storm. The Ruby programming language fuses ideas from dynamic, scripting languages with a strong object-oriented framework. Based on the popular Model-View-Controller (MVC) paradigm, Ruby on Rails, also called RoR and just Rails, is a web programming application framework written in Ruby. Rails leverages Ruby's extensive support for metaprogramming, from which it derives much of its elegance and ease of development. Additionally, Rails makes extensive use of code generation features, making it easy to start a complete application and promoting agile programming techniques.

The key design features that make Rails unique in the web application world are "Don't Repeat Yourself" (DRY) and "Convention over Configuration". The DRY principle means that settings, such as database column names, only need to be specified in one place. Rails ensures that these definitions are visible to all the other web components that need them. Similarly, the Convention over Configuration principle means that web developers only need to make explicit the aspects of their web application that are different from others; Rails (and programmers, too) can infer similar aspects from conventions, e.g., naming conventions. This greatly reduces the need to specify meta data aobut your web application in configuration files, largely eliminating the XML metadata bloat that is common in other web frameworks.

Magic of Ajax with Ruby On Rails

Rails Implements Ajax

Rails has a simple, consistent model for how it implements Ajax operations.

Rails has a simple, consistent model for how it implements Ajax operations.

Once the browser has rendered and displayed the initial web page, different user actions cause it to display a new web page (like any traditional web app) or trigger an Ajax operation:

  1. A trigger action occurs. This could be the user clicking on a button or link, the user making changes to the data on a form or in a field, or just a periodic trigger (based on a timer).
  2. Data associated with the trigger (a field or an entire form) is sent asynchronously to an action handler on the server via XMLHttpRequest.
  3. The server-side action handler takes some action (that's why it is an action handler) based on the data, and returns an HTML fragment as its response.
  4. The client-side JavaScript (created automatically by Rails) receives the HTML fragment and uses it to update a specified part of the current page's HTML, often the content of a tag.

An Ajax request to the server can also return any arbitrary data, but I'll talk only about HTML fragments. The real beauty is how easy Rails makes it to implement all of this in your web application.

The 7 Habits of Highly Effective Web 2.0 websites

Steven Covey, author of “The 7 Habits of Highly Effective People” identified principals which also apply to modern Web 2.0 websites.

Highlights and Site Examples include:
  1. • Your customer is the boss- how your website can listen better
  2. • Start and update your website with your goals in mind
  3. • Balance user experiences with site goals
  4. • Deliver Value back to your web visitors
  5. • Be honest-examine and evaluate what doesn’t work
  6. • Web 2.0- Create an ongoing dialog and community with your customers
  7. • Sharpen your website’s saw- renewal techniques that work

Tuesday, January 29, 2008

Exciting world of programming with Ruby On Rails

Dream with Ruby On Rails

Rails is a full-stack framework for developing database-backed web applications according to the Model-View-Control pattern. From the Ajax in the view, to the request and response in the controller, to the domain model wrapping the database, Rails gives you a pure-Ruby development environment. To go live, all you need to add is a database and a web server.

Already Catched with Ruby On Rails

Everyone from startups to non-profits to enterprise organizations are using Rails. Rails is all about infrastructure, so it's a great fit for practically any type of web application Be it software for collaboration, community, e-commerce, content management, statistics, management, you name it. Examples: