Think Different

Zend Framework 2.0.0beta1 Released

dhiraj.patra@gmail.com (dhiraj patra) — Thu, 10 Nov 2011 02:21:24 PST

The Zend Framework community is pleased to announce the immediate availability of Zend Framework 2.0.0beta1. Packages and installation instructions are available at:

http://packages.zendframework.com/

This is the first in a series of planned beta releases. The beta release cycle will follow the "gmail" style of betas, whereby new features will be added in each new release, and BC will not be guaranteed; beta releases will happen no less than every six weeks. The desire is for developers to adopt and work with new components as they are shipped, and provide feedback so we can polish the distribution.

Once all code in the proposed standard distribution has reached maturity and reasonable stability, we will freeze the API and prepare for Release Candidate status.

Featured components and functionality of 2.0.0beta1 include:

New and refactored autoloaders:
- Zend\Loader\StandardAutoloader
- Zend\Loader\ClassMapAutoloader
- Zend\Loader\AutoloaderFactory
New plugin broker strategy
- Zend\Loader\Broker and Zend\Loader\PluginBroker
Reworked Exception system
- Allow catching by specific Exception type
- Allow catching by component Exception type
- Allow catching by SPL Exception type
- Allow catching by base Exception type
Rewritten Session component
Refactored View component
- Split helpers into a PluginBroker
- Split variables into a Variables container
- Split script paths into a TemplateResolver
- Renamed base View class "PhpRenderer"
- Refactored helpers to utilize __invoke() when possible
Refactored HTTP component
New Zend\Cloud\Infrastructure component
New EventManager component
New Dependency Injection (Zend\Di) component
New Code component
- Incorporates refactored versions of former Reflection and CodeGenerator components.
- Introduces Scanner component.
- Introduces annotation system.

The above components provide a solid foundation for Zend Framework 2, and largely make up the framework "core". However, the cornerstone feature of beta1 is what they enable: the new MVC layer:

Zend\Module, for developing modular application architectures.
Zend\Mvc, a completely reworked MVC layer built on top of HTTP, EventManager, and Di.

We've built a skeleton application and a skeleton module to help get you started, as well as a quick start guide to the MVC; the new MVC is truly flexible, and moreover, simple and powerful.

Additionally, for those who haven't clicked on the packages link above, we are debuting our new distribution mechanisms for ZF2: the ability to use Pyrus to install individual components and/or groups of components.

Since mid-August, we've gone from a few dozen pull requests on the ZF2 git repository to over 500, originating from both long-time Zend Framework contributors as well as those brand-new to the project. I'd like to thank each and every one of them, but also call out several individuals who have made some outstanding and important contributions during that time frame:

Evan Coury, who prototyped and then implemented the new module system.
Rob Allen, who, because he was doing a tutorial at PHPNW on ZF2, provided a lot of early feedback, ideas, and advice on the direction of the MVC.
Ben Scholzen, who wrote a new router system, in spite of a massive injury from a cycling accident.
Ralph Schindler, who has had to put up with my daily "devil's advocate" and "think of the user!" rants for the past several months, and still managed to provide comprehensive code manipulation tools, a Dependency Injection framework, and major contributions to the HTTP component.
Enrico Zimuel, who got tossed requirements for the cloud infrastructure component, and then had to rework most of it after rewriting the HTTP client from the ground up... and who still managed three back-to-back-to-back conferences as we prepared the release.
Artur Bodera, who often has played devil's advocate, and persisted pressing his opinions on the direction of the framework, often despite heavy opposition. We may not implement all (or many) of the features you want, but you've definitely influenced the direction of the MVC incredibly.
Pádraic Brady, who started the runaway train rolling with a rant, and helped make the project much more transparent, enabling the MVC development to occur in the first place.

Welcome to the ZF2 beta cycle!

courtsy: zend

Build A Web 2.0 Voting Widget With Flex

dhiraj.patra@gmail.com (dhiraj patra) — Mon, 07 Nov 2011 22:23:05 PST

IThere are few things that people like to do more than give their opinion about a subject of interest to them – especially on the Web. This can be very useful for engaging your site’s visitors, measuring their interest in a topic, or just allowing them to express themselves. Web 2.0, and the advent of Rich Internet Applications (RIAs), allow for the installation of polling widgets on your web site, making it easier than ever to take the pulse of your community.

There are several different technologies you could use to build an interactive voting widget, but the end user needs to be considered carefully. For instance, you could use Ajax – but this approach can introduce issues with client-side compatibility. You could use Applets, but that’s not a popular choice at the moment – too many web surfers disable the Java VM in their browsers.
A very good option, on the other hand, is Flash. Practically everyone has it installed – who hasn’t come across a link to YouTube at some point and wanted to watch a video?
But what if you’re not across Flash? And isn’t Flash really an animator’s tool anyway? Well, as we’ll see, it’s easy for developers to build Flash applications using the Flex framework – freely available as open source from Adobe. In this article, the first of two on this complex subject, we’ll walk through the process of building a Flash widget for voting using the Flex framework.
Flex Basics
Before we go any further, we’ll pause for a minute to talk about the Flex and Flash applications and where they fit into the client landscape. Take a look at the following graphic.

This diagram demonstrates how a Web 2.0 web page interacts with a PHP web server. The web page uses one of several tools to communicate with the web server. It can use Javascript and Ajax to make a request of the server, then update the page with the new data. Or it can use a Flash application to provide functionality to the user. This Flash application can either take up the entire page, or it may be contained to a widget that takes up just a portion of it. Flex has been used very successfully in both scenarios.
Flex applications are made of roughly three parts: the MXML that defines the interface, the ActionScript code that contains the application logic, and resources such as images and audio. To draw an analogy with web technologies, the MXML and ActionScript would be HTML and JavaScript respectively.
Now you could download the SDK and program your application using a simple text editor, but there’s a better option – a really good IDE called Flex Builder 3, available free from Adobe as a 30-day trial.
The following diagram shows Flex Builder 3 and how its function fits into the life cycle of generating a Flash application SWF.

Flex Builder manages the MXML, ActionScript, and resources as a project. It uses the Flex SDK compiler to continuously compile the project as you make changes. That temporary output SWF file is then launched in your default browser to do the testing.
Hopefully this provides some context for getting started with Flex. If you’d like a more detailed walk-through of this subject, I recommend you try this excellent tutorial on Flex for beginners.

Getting Flex Up and Running

The Flex Builder 3 installer comes with everything you need built in. It automatically installs the Flex SDK, as well as the Eclipse-based IDE and the AIR runtime (which is useful if you want to build a desktop application rather than a web app.
Once you have Flex Builder 3 installed on your machine, launch it and you should see something like this.

This is the empty Flex IDE. The next step is to create our first Flex project. Select Flex Project from the New menu and you should see this window.

You can name your project whatever you like. I chose Voteview, since for the purposes of this article I’m only going to build an application that views the current vote totals. We’ll discover the interactive widget in the next article.

After you hit Finish to build the project, you should see the result pictured below.

Flex Builder 3 automatically creates an MXML application with the same name as the project. In this case, the “voteview” project has one source file, voteviewer.mxml.
At this point, you’re probably thinking, “I thought we were doing Flex, so what’s this MXML?” MXML is one of the two major technologies in a Flex application; it’s a tag-based language used to build user interfaces. The other is ActionScript 3, which is the programming language that we use to add interactivity to the interface.
To make sure that everything’s working okay, we’ll add just a single tag to the MXML file, as shown here:

view plain print ?

The tag specifies that we want a control of type Label with the text of Hello World where the font size is 20px. This figure shows the result of launching it in Flex Builder.

If that works, you know that everything is installed correctly and you’re all set to start developing in Flex.
The next step is to put an XML file on a web server that will contain the current vote totals. This is the data that the Flex application will fetch and display.
You can format your XML any way you choose, but something along these lines is simple enough:

view plain print ?

What is the best Star Wars movie?

  

  What is the best Star Wars movie?

This XML defines that there is one question with three options, where each option has a name and a count of votes.
Once this XML file is up on your server somewhere (in my case, the localhost Apache server on my Mac), we can add some more tags to the MXML and get this party started!
Here’s a simple Flex application that reads the data from the XML file and then displays the question in a Label control, and the current votes in a DataGrid control:

view plain print ?

creationComplete="votes.send()">

  


  creationComplete="votes.send()">

There are two key elements involved in the code above. The first is the mx:HTTPService tag that defines where we will retrieve the data, and specifies an id for the data source. This service is invoked by the code attached to the creationComplete event on the Application tag.
The data display is handled automatically by Flex through the magic of the Flex event model. When the HTTService has successfully downloaded the XML, the lastResult variable on the service notifies the Label and the DataGrid that it has changed. Those controls then update themselves automatically to show the new values returned by the server.
Here’s the result of launching this in Flex Builder.

Well, it works okay, but it’s not very sexy in appearance, is it? I’m all about the sexy look, so I’m going to use Flex’s built-in charting service to display the votes in a pie chart instead of a DataGrid.
This updated code is shown below:

view plain print ?

creationComplete="votes.send()">
showAllDataTips="true"
dataProvider="{votes.lastResult.votes.options.option}">

  


  creationComplete="votes.send()">  

    

    

  
    showAllDataTips="true"  

    dataProvider="{votes.lastResult.votes.options.option}">

The only change here is that we replaced the DataGrid with a PieChart control. When we run this in Flex Builder, we’ll see the window shown here.

Now, that’s certainly better. A picture is worth a thousand words, as they say. But could it be even cooler? As it turns out, it can; the Elixir data visualization components available from ILOG offers a set of amazing charting controls that you can use on a trial basis.

Once we’ve installed the ILOG Elixir controls on the machine, we can link them into the project by referencing the Elixir libraries. From there, we add a reference to the Elixir PieChart3D instead of to the original PieChart control.
This updated code is shown below:

view plain print ?

creationComplete="votes.send()" xmlns:ilog="http://www.ilog.com/2007/ilog/flex">
showAllDataTips="true"
dataProvider="{votes.lastResult.votes.options.option}" elevationAngle="30">

   


  creationComplete="votes.send()" xmlns:ilog="http://www.ilog.com/2007/ilog/flex">   

     

     

  
    showAllDataTips="true"   

    dataProvider="{votes.lastResult.votes.options.option}" elevationAngle="30">

And when brought up in Flex Builder 3, it looks like this figure.

Now we’re really cooking with gas! With Elixir we can change the rotation of the chart, the colors, the viewing angle, the lighting, and more. We can even do all that on the fly by responding to mouseclick events and changing the parameters on the chart using ActionScript. This functionality allows the voter to spin the chart around and view it from different angles.
This is about as far as I’m going to go with the interface in this article series. To finish up, I’ll demonstrate how to use a different data transport technology, AMF, instead of XML. AMF is easier to use, particularly when you’re both reading and writing data – more on this in the next instalment!

NOTE:
AMF and XML aren’t the only ways that Flex can access data. Your applications can read JSON, text, AMF, or go direct to binary data through sockets. In other words, wherever your data is and whatever the format, Flex applications can get to it.

Going to AMF

Let’s use the free AMFPHP package to build an AMF service on the web server. AMFPHP comes with a built-in service browser, which I’ll show you in a minute, plus a directory where you put your services. In this case, we’ll add a new service to a new “votes” directory called VoteService.
Here’s the PHP code for VoteService:

view plain print ?

include_once(AMFPHP_BASE . "shared/util/MethodTable.php");
class VoteService
{
function getVotes()
{
return array( 'topic' => 'What is the best Star Wars movie?',
'votes' => array(
array( 'name' => 'Episode IV', 'count' => 150 ),
array( 'name' => 'Episode V', 'count' => 250 ),
array( 'name' => 'Episode III', 'count' => 50 )
)
);
}
}


include_once(AMFPHP_BASE . "shared/util/MethodTable.php");   

class VoteService   

{   

  function getVotes()   

  {   

    return array( 'topic' => 'What is the best Star Wars movie?',   

        'votes' => array(    

            array( 'name' => 'Episode IV', 'count' => 150 ),   

            array( 'name' => 'Episode V', 'count' => 250 ),   

            array( 'name' => 'Episode III', 'count' => 50 )   

          )   

        );   

  }   

}

For this example, we’re just going to return the same data as we’d have gained from the XML file on the server. That way, if the results look the same we know everything’s in order.
To test the service, navigate to the amfphp/browser directory in your browser. You should see something like this.

Next, click on the votes/VoteService and hit the Call button. This causes the AMF browser to invoke the service and display the results, as shown here.

We can see that the data is returned correctly as an ActionScript object that’s very easy to manipulate.
From here, we can change the HTTPService from the original PieChart application to a RemoteObject service. The RemoteObject class connects to the AMF endpoint and then defines a bunch of methods. You can see this in the updated source:

view plain print ?

creationComplete="voteRO.getVotes.send()">
endpoint="http://localhost/amfphp/gateway.php"
source="votes.VoteService" destination="votes.VoteService"
showBusyCursor="true">
showAllDataTips="true"
dataProvider="{voteRO.getVotes.lastResult.votes}">
...

   


  creationComplete="voteRO.getVotes.send()">   


  endpoint="http://localhost/amfphp/gateway.php"   

  source="votes.VoteService" destination="votes.VoteService"   

  showBusyCursor="true">   

   

   

     

  
    showAllDataTips="true"   

    dataProvider="{voteRO.getVotes.lastResult.votes}">   

...

Yes, that’s a lot more code than the HTTPService required to achieve the same outcome (don’t forget to download the code archive for this article). But using AMF instead of XML will make it a lot easier to perform both the vote collection and vote addition from the widget that we’ll create in the next article of this series.

There are few things that people like to do more than give their opinion about a subject of interest to them – especially on the Web. This can be very useful for engaging your site’s visitors, measuring their interest in a topic, or just allowing them to express themselves. Web 2.0, and the advent of Rich Internet Applications (RIAs), allow for the installation of polling widgets on your web site, making it easier than ever to take the pulse of your community.
There are several different technologies you could use to build an interactive voting widget, but the end user needs to be considered carefully. For instance, you could use Ajax – but this approach can introduce issues with client-side compatibility. You could use Applets, but that’s not a popular choice at the moment – too many web surfers disable the Java VM in their browsers.
A very good option, on the other hand, is Flash. Practically everyone has it installed – who hasn’t come across a link to YouTube at some point and wanted to watch a video?
But what if you’re not across Flash? And isn’t Flash really an animator’s tool anyway? Well, as we’ll see, it’s easy for developers to build Flash applications using the Flex framework – freely available as open source from Adobe. In this article, the first of two on this complex subject, we’ll walk through the process of building a Flash widget for voting using the Flex framework.

Flex Basics

Before we go any further, we’ll pause for a minute to talk about the Flex and Flash applications and where they fit into the client landscape. Take a look at the following graphic.

Getting Flex Up and Running

view plain print ?

What is the best Star Wars movie?

  

  What is the best Star Wars movie?

view plain print ?

creationComplete="votes.send()">

  


  creationComplete="votes.send()">

view plain print ?

creationComplete="votes.send()">
showAllDataTips="true"
dataProvider="{votes.lastResult.votes.options.option}">

  


  creationComplete="votes.send()">  

    

    

  
    showAllDataTips="true"  

    dataProvider="{votes.lastResult.votes.options.option}">

view plain print ?

creationComplete="votes.send()" xmlns:ilog="http://www.ilog.com/2007/ilog/flex">
showAllDataTips="true"
dataProvider="{votes.lastResult.votes.options.option}" elevationAngle="30">

   


  creationComplete="votes.send()" xmlns:ilog="http://www.ilog.com/2007/ilog/flex">   

     

     

  
    showAllDataTips="true"   

    dataProvider="{votes.lastResult.votes.options.option}" elevationAngle="30">

Going to AMF

view plain print ?

include_once(AMFPHP_BASE . "shared/util/MethodTable.php");
class VoteService
{
function getVotes()
{
return array( 'topic' => 'What is the best Star Wars movie?',
'votes' => array(
array( 'name' => 'Episode IV', 'count' => 150 ),
array( 'name' => 'Episode V', 'count' => 250 ),
array( 'name' => 'Episode III', 'count' => 50 )
)
);
}
}


include_once(AMFPHP_BASE . "shared/util/MethodTable.php");   

class VoteService   

{   

  function getVotes()   

  {   

    return array( 'topic' => 'What is the best Star Wars movie?',   

        'votes' => array(    

            array( 'name' => 'Episode IV', 'count' => 150 ),   

            array( 'name' => 'Episode V', 'count' => 250 ),   

            array( 'name' => 'Episode III', 'count' => 50 )   

          )   

        );   

  }   

}

view plain print ?

creationComplete="voteRO.getVotes.send()">
endpoint="http://localhost/amfphp/gateway.php"
source="votes.VoteService" destination="votes.VoteService"
showBusyCursor="true">
showAllDataTips="true"
dataProvider="{voteRO.getVotes.lastResult.votes}">
...

   


  creationComplete="voteRO.getVotes.send()">   


  endpoint="http://localhost/amfphp/gateway.php"   

  source="votes.VoteService" destination="votes.VoteService"   

  showBusyCursor="true">   

   

   

     

  
    showAllDataTips="true"   

    dataProvider="{voteRO.getVotes.lastResult.votes}">   

...

Written By:Jack Herrington
Jack Herrington is an engineer, author, and presenter who lives and works in the San Francisco Bay Area. He lives with his wife, daughter and two adopted dogs. When he's not writing software, books, or articles you can find him cycling, running, or in the pool training for triathlons. You can keep up with Jack's work and his writing at http://jackherrington.com.

How To Optimize Websites

dhiraj.patra@gmail.com (dhiraj patra) — Sun, 16 Oct 2011 22:13:14 PDT

Google found that moving from a 10-result page loading in 0.4 seconds to a 30-result page loading in 0.9 seconds decreased traffic and ad revenues by 20% (Linden 2006). When the home page of Google Maps was reduced from 100KB to 70-80KB, traffic went up 10% in the first week, and an additional 25% in the following three weeks (Farber 2006).
Tests at Amazon revealed similar results: every 100 ms increase in load time of Amazon.com decreased sales by 1%. (Kohavi and Longbotham 2007).

It’s quite clear. Everyone hates slow websites. The question is, how can you make your WordPress website faster? Keep reading and I’ll show you how you can take proactive steps towards speeding up your site.

What Determines Website Page Speed?

The Yahoo! YSlow and Google Page Speed Mozilla Firefox plugins evaluate your site against the widely accepted rules of website performance. The problem is, they don’t tell you what to do with the information they provide.
So, I’ll break down the top performance recommendations and show you you can apply them to your website.
Let’s do it.

1. Minimize the number of HTTP requests

Translation: Limit the number of files required to display your website
When someone visits your website, the corresponding files must be sent to that person’s browser. This includes CSS files, Javascript library references, and images.
As expected, every file you use to enhance your design detracts from its performance. Similary, WordPress plugins are notorious for injecting extraneous CSS code in the head of your site without giving you the option to manually add the required styles to your stylesheet.
The key takeaway is this: eliminate everything that’s unnecessary. If you’re using a plugin because you like, take a look at how it impacts your code. The extra page-load time may not be worth it.

2. Optimize and correctly display images

Translation: Make images as small as possible and don’t require the browser to resize them
Depending on the format, many images contain a ton of extraneous metadata that can drastically increase the size of the file. Many designers fail to compress their images before uploading them to the web, and the overall impact of this can be dramatic with image-intensive designs.
Another cardinal sin of inexperienced webmasters is to upload and serve an image far larger than what is required for the design. WordPress is an unfortunate enabler of this, as many novice website owners upload large images directly off of their digital cameras and utilize WordPress’s image resizing functionality to display a smaller version.
With free applications like Picnik and Image Optimizer at our disposal, there is simply no excuse not to resize and optimize! Visitors (and your server) will thank you.

3. Minify HTML, CSS, and Javascript

Translation: Remove all white space from code when possible before serving it to visitors
The spaces, tabs, and orderly structure used in code is to make it more human-readable. Servers and browsers don’t care about what the code looks like as long as it’s valid and executes without error. If you want your files to download faster, you can remove this whitespace before serving your code.
Since it would be impractical to remove white space from files that are constantly edited (unlike Javascript libraries like jQuery, which are almost always served minified), we’ll want to leverage a plugin like WP-Minify (good) or W3 Total Cache (best) to handle this at runtime without affecting the files we need to edit.
Whitespace is great for web design but in our code? Not so much.

4. Use a Content Delivery Network (CDN)

Translation: Use a CDN to lighten the load on your server and turbocharge its performance
A CDN is a high-performance network of servers across the globe that replicate the static assets of your website and serve them to visitors from the closest POP.
What?
I know, I know. The good news is that we don’t have to understand the mechanics behind Content Delivery Networks in order to understand their power: you have a team of servers distributing your static assets to visitors across the globe. I’ve written a post on making WordPress faster by integrating a CDN if you’re interested in further reading on the topic.
CDNs are among the most effective ways to absolutely turbocharge the speed of our sites. We can’t neglect the other areas of optimization in the process, so this should be treated as the crowning jewel atop your beautifully optimized website.

5. Gzip and compress components

Translation: Compress files at the server level before sending them to browsers
If you were instructed to hurl a piece of paper across the room as far as it can go, would you lightly crumple it or squeeze it with all your might? That’s right, you’d get your Hulk Smash on.
The sample principle applies here: we want to allow our webserver to compress our files before sending them to visitors. We can drop a few lines of code in our .htaccess file to accomplish this:

#Begin gzip and deflate

    AddOutputFilterByType DEFLATE text/html text/css application/x-javascript text/plain text/xml image/x-icon

This code might look a bit intimidating, but it’s actually pretty simple. We’re just checking to see if the Apache mod_deflate module exists and if so, electing to serve HTML, CSS, Javascript, plain text, and favicon files using gzip compression.
Note that this requires the Apache webserver and the mod_deflate module. To enable gzip compression with NGINX, ensure that the following lines exist inside of the appropriate directive:

server {
        gzip on;
        gzip_types text/html text/css application/x-javascript text/plain text/xml image/x-icon;
    }

Easy!

6. Choose over `@import`

Translation: Beware the suck of IE!
When including your stylesheets, always link to the files instead of using the @import reference. IE handles them differently by loading them as if the reference was at the bottom of the document. [sarcasm] Nice work, Microsoft! [/sarcasm]

7. Put stylesheets at the top

Translation: All interface-related stylesheet references should be included in the of your document
We never, ever, ever want to display unstyled content to visitors—not even for a split second. Files responsible for the appearance of our site should be loaded first so they can be applied to the HTML as it loads. Makes sense, right?
Nothing more to it.

8. Put scripts at the bottom

Translation: All functionality-related files can be loaded after our content is loaded
As we think through how to deliver our content to visitors as fast as possible and the subsequent steps that users will take, we will use the following priorities:

Get content to visitors as fast as possible
Don’t allow unstyled content to appear in the browser (put CSS in the )
Load the files required for interaction (tabbed widgets, certain external API calls, etc.) last

The thinking behind this is simple: users aren’t going to interact with the content before they can see it!

9. Utilize browser caching

Urban Translation: Where the cache at?
Standard Translation: Don’t require browsers to pull down another copy of static files every time
With browser caching, we’re explicitly instructing browsers to hang onto particular files for a specified period of time. When the file is needed again, the browser is to pull from its local cache instead of requesting it from the server again.
Running a website without caching in place makes as much sense as driving to the store for a glass of water every time you’re thirsty. Not only is in impractical and short-sighted, it takes more work!
The ExpiresByType directive is used to tell browsers which files to cache and how long to hang onto them. The example below would tell our visitors’ browsers to hang onto HTML, CSS, Javascript, and images, and favicon for an hour (3600 seconds):


    ExpiresActive On
    ExpiresByType text/html M3600
    ExpiresByType text/css M3600
    ExpiresByType application/x-javascript M3600
    ExpiresByType image/bmp M3600
    ExpiresByType image/gif M3600
    ExpiresByType image/x-icon M3600
    ExpiresByType image/jpeg M3600

Again, the code above is for your .htaccess file on an Apache server. The corresponding settings in NGINX would look something like this:

location ~* \.(jpg|png|gif|jpeg|css|js)$ {
        expires 1h;
}

Boom.

10. Use CSS Sprites

Translation: Serve one highly optimized image for your design to minimize the performance impact
A CSS sprite is an an image comprised of other images used by your design as something of a map containing the coordinates of all the images. Some clever CSS is used to show the proper section of the sprite when your design is loaded.
There are fantastic articles on the topic available across the web that dive into the mechanics of CSS sprites and wonderful resources for creating them. SpriteMe is a utility that generates the sprite and code required to make it work. If you inspect the code for the nav menu on Pearsonified.com, you’ll see a great example of how to implement a CSS sprite.

Whew! Still reading?

If so, great! You’re well on your way to a much faster website. If you implement even a handful of the techniques outlined in this post, you will see an immediate and dramatic improvement in your site’s performance. It’s not important that we know how everything works from database calls to HTTP requests—I surely don’t—it’s important that we’re familiar enough with the concepts to work towards them on our sites.

Work smarter, not harder

You could spend a few months learning the ins and outs of web server architecture, how different browsers implement caching, and how to tie it all together…or you could simply install and configure the W3 Total Cache plugin by Frederick Townes (CTO of Mashable).
I can give no higher recommendation for a performance-related plugin than this one. The features could easily fill another post, but I’ll give you the important part: W3TC helps you thoroughly address 80% of the recommendations outlined in this post. There are other solid options for caching plugins, but W3TC stands head and shoulders above the rest.

sources curtsy: diythemes.com

Differences between PHP4 and PHP5

dhiraj.patra@gmail.com (dhiraj patra) — Thu, 13 Oct 2011 21:47:23 PDT

Here's a quick overview of what has changed between PH4 and PHP5. PHP5 for the most part is backwards compatible with PHP4, but there are a couple key changes that might break your PHP4 script in a PHP5 environment. If you aren't already, I stronly suggest you start developing for PHP5. Many hosts these days offer a PHP5 environment, or a dual PHP4/PHP5 setup so you should be fine on that end. Using all of these new features is worth even a moderate amount of trouble you might go through finding a new host!

Note: Some of the features listed below are only in PHP5.2 and above.

Object ModelThe new OOP features in PHP5 is probably the one thing that everyone knows for sure about. Out of all the new features, these are the ones that are talked about most!

Passed by ReferenceThis is an important change. In PHP4, everything was passed by value, including objects. This has changed in PHP5 -- all objects are now passed by reference.

PHP Code:

$joe = new Person();$joe->sex = 'male';

$betty = $joe;$betty->sex = 'female';



echo $joe->sex; // Will be 'female'

The above code fragment was common in PHP4. If you needed to duplicate an object, you simply copied it by assigning it to another variable. But in PHP5 you must use the new clone keyword.

Note that this also means you can stop using the reference operator (&). It was common practice to pass your objects around using the & operator to get around the annoying pass-by-value functionality in PHP4.

Class Constants and Static Methods/Properties
You can now create class constants that act much the same was as define()'ed constants, but are contained within a class definition and accessed with the :: operator.

Static methods and properties are also available. When you declare a class member as static, then it makes that member accessible (through the :: operator) without an instance. (Note this means within methods, the $this variable is not available)

Visibility
Class methods and properties now have visibility. PHP has 3 levels of visibility:

Public is the most visible, making methods accessible to everyone and properties readable and writable by everyone.
Protected makes members accessible to the class itself and any subclasses as well as any parent classes.
Private makes members only available to the class itself.

Unified Constructors and DestructorsPHP5 introduces a new unified constructor/destructor names. In PHP4, a constructor was simply a method that had the same name as the class itself. This caused some headaches since if you changed the name of the class, you would have to go through and change every occurrence of that name.

In PHP5, all constructors are named __construct(). That is, the word construct prefixed by two underscores. Other then this name change, a constructor works the same way.

Also, the newly added __destruct() (destruct prefixed by two underscores) allows you to write code that will be executed when the object is destroyed.

Abstract ClassesPHP5 lets you declare a class as abstract. An abstract class cannot itself be instantiated, it is purely used to define a model where other classes extend. You must declare a class abstract if it contains any abstract methods. Any methods marked as abstract must be defined within any classes that extend the class. Note that you can also include full method definitions within an abstract class along with any abstract methods.

InterfacesPHP5 introduces interfaces to help you design common APIs. An interface defines the methods a class must implement. Note that all the methods defined in an interface must be public. An interface is not designed as a blueprint for classes, but just a way to standardize a common API.

The one big advantage to using interfaces is that a class can implement any number of them. You can still only extend on parent class, but you can implement an unlimited number of interfaces.

Magic Methods
There are a number of "magic methods" that add an assortment to functionality to your classes. Note that PHP reserves the naming of methods prefixed with a double-underscore. Never name any of your methods with this naming scheme!

Some magic methods to take note of are __call, __get, __set and __toString. These are the ones I find most useful.

Finality
You can now use the final keyword to indicate that a method cannot be overridden by a child. You can also declare an entire class as final which prevents it from having any children at all.

The __autoload FunctionUsing a specially named function, __autoload (there's that double-underscore again!), you can automatically load object files when PHP encounters a class that hasn't been defined yet. Instead of large chunks of include's at the top of your scripts, you can define a simple autoload function to include them automatically.

PHP Code:

function __autoload($class_name) {

     require_once "./includes/classes/$class_name.inc.php";

}

Note you can change the autoload function or even add multiple autoload functions using spl_autoload_register and related functions.

Standard PHP LibraryPHP now includes a bunch of functionality to solve common problems in the so-named SPL. There's a lot of cool stuff in there, check it out!

For example, we can finally create classes that can be accessed like arrays by implementing the ArrayAccess interface. If we implement the Iterator interface, we can even let our classes work in situations like the foreach construct.

Miscellaneous Features

Type Hinting
PHP5 introduces limited type hinting. This means you can enforce what kind of variables are passed to functions or class methods. The drawback is that (at this time), it will only work for classes or arrays -- so no other scalar types like integers or strings.

To add a type hint to a parameter, you specify the name of the class before the $. Beware that when you specify a class name, the type will be satisfied with all of its subclasses as well.

PHP Code:

function echo_user(User $user) {

    echo $user->getUsername();

}

If the passed parameter is not User (or a subclass of User), then PHP will throw a fatal error.

ExceptionsPHP finally introduces exceptions! An exception is basically an error. By using an exception however, you gain more control the simple trigger_error notices we were stuck with before.

An exception is just an object. When an error occurs, you throw an exception. When an exception is thrown, the rest of the PHP code following will not be executed. When you are about to perform something "risky", surround your code with a tryblock. If an exception is thrown, then your following catch block is there to intercept the error and handle it accordingly. If there is no catch block, a fatal error occurs.

PHP Code:

try {

    $cache->write();

} catch (AccessDeniedException $e) {

    die('Could not write the cache, access denied.');

} catch (Exception $e) {

   die('An unknown error occurred: ' . $e->getMessage());

}

E_STRICT Error Level
There is a new error level defined as E_STRICT (value 2048). It is not included in E_ALL, if you wish to use this new level you must specify it explicitly. E_STRICT will notify you when you use depreciated code. I suggest you enable this level so you can always stay on top of things.

Foreach Construct and By-Reference Value
The foreach construct now lets you define the 'value' as a reference instead of a copy. Though I would suggest against using this feature, as it can cause some problems if you aren't careful:

PHP Code:

foreach($array as $k => &$v) {

    // Nice and easy, no working with $array[$k] anymore

    $v = htmlentities($v);

}

// But be careful, this will have an unexpected result because

// $v will still be a reference to the last element of the $array arrayforeach($another_array as $k => $v) {



}

New Functions
PHP5 introduces a slew of new functions. You can get a list of them from the PHP Manual.

New Extensions
PHP5 also introduces new default extensions.

SimpleXML for easy processing of XML data
DOM and XSL extensions are available for a much improved XML-consuming experience. A breath of fresh air after using DOMXML for PHP4!
PDO for working with databases. An excellent OO interface for interacting with your database.
Hash gives you access to a ton of hash functions if you need more then the usual md5 or sha1.

Compatibility IssuesThe PHP manual has a list of changes that will affect backwards compatibility. You should definately read through that page, but here is are three issues I have found particularly tiresome:

array_merge() will now give you warnings if any of the parameters are not arrays. In PHP4, you could get away with merging non-arrays with arrays (and the items would just be added if they were say, a string). Of course it was bad practice to do this to being with, but it can cause headaches if you don't know about it.
As discussed above, objects are now passed by references. If you want to copy a object, make sure to use the clonekeyword.
get_*() now return names as they were defined. If a class was called MyTestClass, then get_class() will return that -- case sensitive! In PHP4, they were always returned in lowercase.

Usability of RIA with Flex

dhiraj.patra@gmail.com (dhiraj patra) — Thu, 08 Sep 2011 23:13:02 PDT

User Interface Design Principles

1. The Client Is Not The User
The client may think she knows what the user wants, but she cannot. This is because the client is not the user.
This brings me to the second principle:
2. Don't Give The Client What She Thinks The User Wants
If the client does not know what the user wants and you give her what she is asking for, you are doing her a disservice. You will ultimately be delivering an application that does not meet user's needs. Your client may initially be happy that you have given her exactly what she asked for but will she remain happy when the product is rejected by users?
I have seen too many designers and developers who are aware of these two principles but proceed to reach the wrong conclusion from it. Namely, that they know the user better. Which brings us to our next principle, which is, simply:
3. You Do Not Know What Your User Wants
You may be a user interface designer or developer with many years of experience but you do not know what users want. Which users? Those specific users who will be using the current application that you are building. Why? Because every application is unique. You may have built similar applications but, unless you have built exactly this application before, you do not know what the users of this application want.
So, who does know what your users want?
4. Only Users Know What Users Want
It's a basic concept but one that is alien to much of our industry. Only users of your application will know what works and what doesn't. It's surreal that, given this, most of us in our industry go out of our ways to delay asking them what they think of our applications. This brings me to the most imporant principle of all:
5. Test Early, Test Often, Then Test Again
Usability testing is not rocket science. In fact, it's quite a simple recipe:
Ingredients:

Two rooms
One or more representative users
A computer running your application
A usability tester
A video camera (no tape)
A TV screen

Take two rooms and place a computer running your application in one of them. In that room, place a representative user and a usability tester who will ask the user to perform various tasks in your application. Place a camera in the room to relay your user's actions to your design/development team who should be watching from the second room. (Ideally, having the rooms next to each other means that you don't have to run too much cable between the two but you can just as easily use wireless technologies or even broadcast the feed over the Internet to a development team across the globe.)
Leave to simmer then repeat.
Notice that you do not even need to record the test. If you do, chances are those tapes will become paperweights like most artifacts that are created during development. Remember: Agile is good.
Doing usability testing does not involve a large upfront financial investment. You can put together the above setup for around $1,000 these days. What it does involve, however, is buy-in to a User-Centered Product Development (UCPD) approach from the highest levels at both your and your client's organization.
Following a UCPD approach involves capturing measureable Usability Requirements alongside your Functional Requirements. You will have to set aside time to carry out usability testing at every iteration in your development process. You cannot do this without a budget. And you won't have a budget unless you have buy-in at the highest levels.
The above principles are perhaps the most important ones as they will determine your development process and your development process will largely decide whether your project succeeds (is accepted by your users) or fails (is rejected by your users.)
Alongside these process-related principles are design principles. These do not, in any way, replace testing. They are intended to give you a good starting point when designing your user interface, before you go to your users and say, "What do you think?"
6. Talk One Language
There should only ever be a single term or phrase used to refer to any given item in the application. An item here may refer to a concept, a business function or task or even a widget or individual interface element. You will find that the use of a metaphor for the project, as advocated by eXtreme Programming (XP), will ease this task tremendously.
7. Respect User Effort
Try to limit the user's physical toil while using the application. Repetitive Strain Injuries (RSI) are a fact of life today and we, as application designers, have to accept responsibility for the ergonomics of our applications.
8. Make difficult decisions
It is your job as the user interface designer to layer the user interface and make important decisions about its organization. Don't leave these decisions to the user just because it makes your life easier. If your application has a huge preferences section, treat this as a Design Smell and review the design to see if you have left decisions that you can make to the user.
9. Let The User Work
Users must be able to perform their most frequent, most important tasks without any resistance. For an SMS Messaging application, for example, this would include reading, replying to and forwarding messages and quickly checking the various mailboxes.
10. Prevent, Don't Scold
Whenever possible the UI should prevent the user from making a mistake instead of alerting the user to the mistake after the fact. This must be achieved without the UI getting in the way of the user.
11. Give Sufficient Feedback
The UI should give the user sufficient feedback for user actions. (This ties in nicely with Steve Krugs "Don't Make Me Think" philosophy: The user should never have to think "did that work?") Related to Don't Lose The User.
12. Show, Don't Tell
Although this may seem to contradict the Give Sufficient Feedback principle, it is actually meant to compliment it. Whenever possible, meaningful visual cues (when appropriate to the audience) should be chosen instead of lengthy textual descriptions. This can also pertain to actually teaching a user to do something in an application by showing them.
13. Don't Lose The User
The UI should protect the user's sense of spatial positioning. The user should never feel "lost" within the application.
14. Don't Sell What You Can't Deliver
Users must not be given Graphical User Interface (GUI) expectations that cannot be met (or can only be partially met) within a Web User Interface (WUI). Whenever OS or GUI expectations are set, they must be fully met. That said, the application must try and meet OS expectations as much as possible, especially for ergonomic features such as keyboard shortcuts and navigation but also for expected auxiliary helpers such as tooltips.
Don't Sell What You Can't Deliver is the main principle behind why Adobe chose to create a new component style called Halo in Flash and Flex instead of trying unsuccessfully to emulate either the Windows XP or Mac OS X look and feel.
15. Don't Keep Them Waiting
The application must perform fast enough to be considered usable within the given engineering limits for the application.
16. Innocent Until Proven Guilty
The user should be warned about a validation error on a control only if they have had a chance to interact with that control. (In other words, you should not perform validation on controls that are in their initial state and initially display a form full of validation errors.) Similarly, resetting a form should remove all validation errors.
17. Usability Approach to Accessibility
There is a trend I am noticing in our field that I find very worrisome and it concerns accessibility. Many people appear to be on a quest for the Magic Button of Accesibility (MBA). This is how an MBA works in an ideal world:
You gather usability requirements for your application for a given target audience. This target audience involves people with good eyesight, hearing, and motor control. Based on the usability requirements for this specific audience, you expand resources in designing a good user experience for this specific audience. You then spend further resources in developing your application, going back to users within this specific audience to get their feedback and to alter your design accordingly. Finally, right before you deliver your application, you press the Magic Button of Accessibility.
The Magic Button Accessibility magically makes the experience of your application as good for various other audiences. These include people who have various levels of sight, hearing, and motor control. Isn't it amazing that the MBA can transform a carefully crafted experience for a single audience into equally pleasurable experiences for many other audiences.
Unfortunately, the Magic Button of Accessibility doesn't exist because it cannot exist.
The MBA is an extreme example of the check-the-checkbox mentality to accessibility that is pravalent in our field today. I call this Checkbox Accessibility: For the most part, we do not really care what sort of experience users with accessibility requirements will have with our applications as long as we can check a checkbox on some form that says that our application is compliant with a set of rules.
If we can run our applications through a program that checks for this, all the better. After all, software is cheap compared to devoting extra time to design and develop an equally good experience for various other audiences. Checkbox Accessiblity is head-and-shoulders better than no accessibility but it does not guarantee a good experience for users with accessibility requirements.
The other approach to accessibiltiy is to see it as usability with different audiences. In other words, you cannot make your application truly accessible for users with disabilities without designing for those users. I call this the Usability Approach to Accessibility.
Having a usability approach to accessibility means that you have to gather usability requirements for disabled users just like you do for users without disabilities. You have to usability test with disabled users. And you have to realize that "disabled users" doesn't refer to a single audience but to multiple audiences, including those with accessibility requirements in sight, hearing and motor function.
Of course, just like usability with an audience of non-disabled users, usability for disabled users costs time and money and will require buy-in at the highest levels of your organization. If you are serious about accessibility, however, anything less is just not good enough.
These are general points of advice that can apply to any application. Based on these overall guidelines, the following are examples of high-level design decisions that were taken and applied in Opal. Keep in mind that Opal was developed in Flash MX but the issues are the same regardless of whether you are building an application in MTASC/SWFMill/FlashDevelop, Flash 8, Flash 9, Flex 1.5 or Flex 2. Each of those tools and technologies provides different features, components, programming models and development workflows but the end result, regardless of which technologies are used, is always evaluated by your users.

Principles applied: examples

Respect User Effort: eliminating scrolling
The message preview textbox displays a full SMS message without scrolling. It meant that sacrifices had to be made with some of the other form elements on the Message Tabs. Reading an SMS message is both an important and frequently-performed task and so the other sacrifices were justified (also see Make difficult decisions.)
Give Sufficient Feedback: SMS character count
A custom SMS character count widget shows users exactly how many characters they have left before they need to send a message as two or more SMS messages. This is an especially important piece of information for users as they are charged for each SMS message sent.
Prevent Don't Scold: Form validations
All forms implement client-side validation. Submit buttons (such as "Send Message" or "Add Contact") gray out until the form passes client-side validation. This does not remove the need for server-side validation and all form submissions are validated server-side for correctness and security before being processed. Client-side validation exists solely to improve the user experience and does not provide any security whatsoever.

Let The User Work: Mailbox Tabs and Message Action Tabs
A composite tab-based interface exposes the critical, frequent tasks to users. Mailbox Tabs give users single-click access to their mailboxes. They also expose context-sensitive message actions for each mailbox. Users can immediately see the actions that they can perform on a message in a given mailbox tab.
Implementing a context-sensitive menu that hides possible actions until it is triggered would have ranked at the opposite end of the usability spectrum and been ignored by most new users.
Show, Don't Tell: Menu Bar and Tool Bar as teaching methods for migrating Outlook users.
A menu bar and tool bar remind users of the ones in Outlook without creating operating system specific expectations.
The menu and tool bars implement Show, Don't Tell.
When an Outlook user first changes to a given mailbox using the menu or tool bar, the Mailbox tab animates to the chosen mail box, thereby showing the user that they could also have clicked on the tab (although the tab control is a well-known GUI component in its own right.) The same goes for when the user selects a Message Action (eg. Reply).
Don't Lose The User and Don't Sell What You Can't Deliver: Screen-based RIAs vs. Multiple-Window-based RIAs.
It is very important to note the differences between Graphical User Interfaces (as used by desktop applications such as Outlook) and Web User Interfaces (as used by Rich Internet Applications such as Opal). It is equally important to manage client's expectations as to the limitations of Web User Interfaces, even those termed "Rich" and developed using Flash.
The greatest difference between a WUI and a GUI is usually the most overlooked: WUI applications run from within a GUI application which, in turn, runs inside a window-based operating system. Past usability studies have shown that especially beginning users have problems with the concept of multiple windows, preferring usually to keep a single window up at a time. Even in multitasking operating systems like Windows XP or OS X, novice users sometimes prefer to start up a single application, shut it down and start another application and so on. The perceived complexity of the system is heightened when the user is confronted with an interface (an RIA such as Opal) within a GUI application (the web browser) that itself contains windows.
Firstly, we rob our novice user of the comforts of his single window existence. Secondly, the new windowing system works in a different way and contains its own rules and limits. It is thus important to implement a screen-based interface in RIAs so that you Don't Lose The User and Don't Sell What You Can't Deliver.
Even if an RIA developer takes pains to develop a Multi-Window Interface that mimics a certain dominant OS, the interface is still being presented to the user in the document area of a GUI application (the web browser). This is contrary to OS expectations wherein users expect not to see windows within documents. Perhaps this is one area where application browsers such as Central will have an impact on user expectations. It remains, however, that the only way a multi-window interface can provide a high-level of usability in an RIA is if the application can run in its own OS window and not as a document within a web browser and thus access the windowing abilities of whatever OS it happens to be running on. As this is currently not a possibility with Flash, we decided to go with a screen-based system in the application.
Although modal pop-ups are sparingly used due to issues of screen real-estate and Outlook migration expectations, users are visually shown that these dialog boxes are modal screens via the graying out of lower screens. Although this removes the OS expectations surrounding non-modal multiple-window interfaces, the graphic similarity of the dialog screens to windows still leads certain users in testing to attempt to move windows around.
Don't Keep Them Waiting: The name of the game is performance.
If there was one issue we kept running into during development, it was performance. Flash is not the fastest kid on the block and it is possible to run into issues when client's expectations are not managed as to the limitations of RIAs. Although RIAs can recreate a lot of the desktop application experience from within a web application, there are limits.
Flash 9 and ActionScript 3 have made great strides in performance and it is important to keep in mind that this project was being published for the Flash 6 player.
One issue, for example, was that the speed of the setSize() method on the Macromedia DRK Data Grid was resulting in unacceptable redraw times when the application was resized. This resulted in a very risky two-weeks in which I wrote a completely new Data Grid component that implemented the DRK Data Grid interface and could be plug-and-play replaced into application. The resulting Data Grid offered a 10x performance boost and brought redraw rates back within acceptable limits.
I hope that this article has challenged how you think about usability and accessibility and that you will find it to be a useful resource in designing and developing web applications. As always, I value your feedback so please feel free to leave a comment and share your thoughts.

Usability for Rich Internet Applications

After struggling for years to design Internet applications around the limitations of HTML, I have been very excited by the recent release of a range of Internet applications with increased richness and interactivity.

The key challenge in designing part-page updates is making sure people see them.

Rich Internet applications (RIAs) can provide opportunities to design much better user experiences. They can be faster, more engaging and much more usable. However, this improvement is not without its downside—RIAs are much more difficult to design than the previous generation of page-based applications. The richer interaction requires a better understanding of users and of human-computer interaction (HCI). Although there is a lot of HCI material and research available, it can be difficult to determine how it applies to this new environment.
In this article, I provide some practical tips for designing usable RIAs, based on fundamental principles of HCI.

What’s an RIA?

According to the Wikipedia, RIAs are “a cross between Web applications and traditional desktop applications, transferring some of the processing to the client end.”
The key difference between RIAs and other Internet applications is the amount of interaction in the interface. In a traditional page-based Internet application, interaction is limited to a small set of standard controls such as checkboxes, radio buttons, form fields and buttons. This severely limits our ability to create usable and engaging applications, and most Internet applications have been clumsier and more difficult to use than their desktop counterparts. An RIA can use a wider (and hopefully better) range of controls to improve users’ interaction with the interface, allowing efficient interactions, better error management, feedback and overall user experience.
Some of my favorite sites with RIA-style interfaces include:

Many are built with Flash or using Ajax techniques.
The key features of these applications include:

The user interacts directly with page elements (inline editing, drag-and-drop, panning a map)
Part of a page is updated (instead of reloading)
More detailed information is available on the same page (instead of on a new page)
Feedback, confirmation and error messages are provided within the page

These rich features are also those that provide the most challenge for designers who wish to ensure applications are highly usable.

Challenge #1: Deciding How Much Richness to Add

When designing RIAs, it is tempting to design many new features that add a lot of richness. Don’t give in to this temptation! Regular folks who have been using the Internet for a number of years are comfortable with the existing page-based model and limited interactivity, as clumsy as it may appear to designers and developers. It takes time for people to adapt to new approaches. It will be some time before conventions emerge and users are comfortable with the new generation of applications. Go slowly, adding richness where it significantly improves usability, and relying on traditional models where these better suit your user group.
Good user research (and a focus on users throughout the design process) and regular usability testing will help you determine how much richness is appropriate at a point in time.

Challenge #2: Interactive Page Elements

One way to add richness to your application is to allow users to directly interact with page elements: editing text inline, dragging and dropping graphic elements, panning a map.
A primary challenge is to communicate what can be done with page elements and how to use new controls. People must be able to identify that a control exists and easily determine how to use it.
In The Design of Everyday Things, Don Norman popularized the idea of perceived affordance (the perceived and actual properties of a thing that determine just how the thing could possibly be used). For example, the original 3D button has great perceived affordance. By highlighting the top and shadowing the bottom, people perceive it as popping out of the screen and easily understand that it can be pushed by clicking.
One way is to use controls that mimic things people are familiar with from the physical world, such as the slider on Fidelity Labs Mortgage Search.

Another is to change the appearance of the element or show the controls when the mouse hovers over it, showing what can be done without cluttering the interface. Backpack uses this to indicate elements that can be edited or deleted.

In addition to ensuring your controls have good perceived affordance, you should:

Remember how valuable a demonstration can be. In the initial stages of a new interface, use a small in-page tutorial video to show the interaction.
Ensure controls and interaction models are used consistently throughout the interface and are similar to other sites that your users visit. This helps people easily learn what to do and build on previous experiences.

Challenge #3: Refreshing Part of the Page

There is significant advantage in updating part of the page instead of refreshing it or opening a new page. It allows us to create faster applications, improve feedback to the user and manage errors better. Error management and feedback are critical to improving usability, but it’s particularly difficult to do with the page-based model. Users have become accustomed to taking an action (such as clicking a link), waiting for the action to complete, and checking the result of the action.
The key challenge in designing part-page updates is making sure people see them. We can use what we know about visual attention and visual processing to ensure people will see that part of the page has been updated:

Visual attention is attracted by movement and high color contrast (that’s why bright, animated banner ads are so distracting—our eyes are constantly pulled toward them). We can use this to our advantage and draw the eye to the updated part of the page.
When we take an action such as clicking a button, our eyes remain fixed on that point for a short time, then release to look somewhere else. By making sure the change occurs quickly and as close as possible to where they are looking, we can ensure the eye is drawn to the appropriate place.
Visual attention can only be focused on one thing at a time. Make one update at a time, and don’t use high-contrast, moving images elsewhere on the page. 37 Signals were one of the first to do this, popularizing the yellow fade technique. Odeo provides effective feedback by using color, movement and placing it right where the user is looking:

Challenge #4: Breaking the Page Model

As we interact with the world, we develop a mental model of how things work. Most users have developed a mental model of the Web based on pages—every click takes you to a new page. Clicking on the back button takes you to the previous page. This is a strong mental model, and is reasonably accurate for the majority of content-rich sites. Users will continue to apply their page-based mental model to RIAs unless they can clearly identify that the RIA uses a different model.
The first part of this challenge is to think very hard about where to use individual pages and where to use in-page richness. Think about the entire interaction of your application and break it up appropriately. Don’t try to put everything into one “page” just because you can.
One factor is the likely use of the back button. Consider when people may need to go “back”—this will give you clues about where to use pages. Don’t disable the back button, reducing users’ control of their situation.
Another challenge is how to visually express the difference between pages and in-page changes. You may need to design different visual navigation models so people can identify when they are getting a new page. It is likely that some new navigation methods will emerge over time.
Google Reader manages pages very poorly. The buttons in its traditional top navigation bar (Home, Your Subscriptions, etc.) imply navigation to individual pages, but actually change the content in the body of the page. When I first used Google Reader, I frequently tried to use the back button to return to the home page but was thrown right out to the last page I visited before reaching Google Reader. This was so frustrating, I stopped using it.

In contrast, Yahoo! News manages pages and in-page updates well. It has traditional top tabbed navigation to individual pages and in-page panels that change based on the news source:

Review Usability Best Practices

Don’t forget the usability basics. Jakob Nielsen’s Ten Usability Heuristics are as relevant now as they were in 1999. I stress this because I looked at the Flex showcase recently, and it looks like many of the applications are not built with these best practices in mind.

1. Visibility of system status (Feedback)

The system should always keep users informed about what is going on, through appropriate feedback within reasonable time.

1.0 BaseCamp by 37signals
The upload button is enabled, until clicked. Then it is replaced with a progress indicator until the file has finished uploading

1.1 Picnik
Progress message and indicator shows while the application loads

1.2 Tick
A feedback message is displayed when an action is performed

1.3 Windows Live Account
Password strength is shown as the password is entered

2. Match between system and the real world (METAPHOR)

The system should speak the users’ language, with words, phrases and concepts familiar to the user, rather than system-oriented terms. Follow real-world conventions, making information appear in a natural and logical order.

2.0 iTunes
Organized as a library that contains your media library: music, movies, shows, audibooks. Beneath the Library is the Store where you can buy more media to put in your Library.

2.1 Mindomo
The branches and hierarchy of a mind map can be easily reorganized visually in a non-linear manner. An outline would never work, but this matches the paradigm exactly.

3. User control and freedom (NAVIGATION)

Users often choose system functions by mistake and will need a clearly marked “emergency exit” to leave the unwanted state without having to go through an extended dialogue. Supports undo and redo and a clear way to navigate.

3.0 CollabFinder
Search is easy to open, enter info, execute or cancel.

3.1 Wufoo
Clearly marks where the person is and where they can go by showing the selection in each menu

3.2 Pages (Apple’s Word Processing Product)
Cell editing shows row and column ids, and the cells used in the equation. The equation can be saved or canceled.

3.3 Balsamiq
Undo and Redo buttons are available in the toolbar, and can also be accessed with the standard keyboard shortcuts

4. Consistency and standards (CONSISTENCY)

Users should not have to wonder whether different words, situations, or actions mean the same thing. Follow platform conventions.

4.0 Gmail
When Gmail was designed, they based the organizational folders on the same ones used in client email applications: Inbox, Drafts, Sent Mail.

4.1 Microsoft Office
Word, Excel, and PowerPoint all use the same style toolbar with the same primary menu options: Home, Insert, Page Layout… Consistency results in efficiency and perceived intuitiveness.

5. Error prevention (PREVENTION)

Even better than good error messages is a careful design, which prevents a problem from occurring in the first place.

5.0 Yammer
Disables the update button after it is clicked, so the person cannot update the post twice by accident

5.1 Example from “Web form Design:Filling in the Blanks” by Luke W.
Make the primary action prominent with a larger click area. Cancel and secondary actions are just shown as links

5.2 Google Auto Recommend
The auto recommend feature cuts down on mis-spellings

5.2 Wikpedia
Auto focus on input prevents a common source of frustration, typing only to realize nothing is displayed because the field did not have focus

6. Recognition rather than recall (MEMORY)

Minimize the user’s memory load. Make objects, actions, and options visible. The user should not have to remember information from one part of the dialogue to another. Instructions for use of the system should be visible or easily retrievable whenever appropriate.

6.0 Quanta IDE
Type ahead for coding in a development environment

6.1 Keynote
Previews the fonts you can pick from, instead of just the font name

7. Flexibility and efficiency of use (EFFICIENCY)

Accelerators — unseen by the novice user — may often speed up the interaction for the expert user such that the system can cater to both inexperienced and experienced users. Allow users to tailor frequent actions.

7.0 OmniFocus
List of keyboard shortcuts and accelerators

7.1 Numbers- Apple’s Spreadsheet product
Previews common function results on the left when a column is selected, more efficient that clicking on an action in the toolbar

8. Aesthetic and minimalist design (DESIGN)

Dialogues should not contain information, which is irrelevant or rarely needed. Every extra unit of information in a dialogue competes with the relevant units of information and diminishes their relative visibility. Visual layout should respect the principles of contrast, repetition, alignment, and proximity.

8.0 Kontain
Kontain’ search menu exemplifies the four principles of visual design:
Contrast: bold text is used for the two labels in the search
Repetition: the orange, blue, and green text match the media types
Alignment : strong left alignment of text, right aligned drop down
Proximity: a light rule is used to separate tags from the other options

8.1 Harvest
Sufficient padding and spacing keep this timesheet from being a visual nightmare. Header and footer rows, as well as the summary column use subtly different colors to indicate they are distinct from the content

9. Help users recognize, diagnose, and recover from errors (RECOVERY)

Error messages should be expressed in plain language (no codes), precisely indicate the problem, and constructively suggest a solution.

9.0 Digg
Provides immediate feedback with specific instructions

9.1 Humorous ‘ Page Not Found’ Error
Uses a funny image and copy, but provides viable alternatives (article listings and blog link) and a course of action (report it)

10. Help and documentation (Help)

Even though it is better if the system can be used without documentation, it may be necessary to provide help and documentation. Any such information should be easy to search, focused on the user’s task, list concrete steps to be carried out, and not be too large.

10.0 Picnik
Contextual help (this is an example of help in the ‘Collages’ module) tips in Picnik are clear and easy to navigate

10.1 GoodBarry
Embedded videos can be used to showcase features as well as get people started using the product

10.2 Zenoss
Help tips are displayed on hover, answering the most likely questions about a field or instructions

10.3 BaseCamp by 37signals
Help opens a new browser window/tab with a full set of help resources: search, FAQ, video tutorials, customer forums

Interview with Dries Buytaert, Creator of Drupal By David Peterson | April 28, 2010 | Web Tech

dhiraj.patra@gmail.com (dhiraj patra) — Thu, 01 Sep 2011 21:50:41 PDT

Drupalcon San Francisco — last week, David Peterson (@davidseth) caught up with Dries Buytaert(@Dries), the creator of Drupal, to discuss where Drupal is heading, what challenges are ahead and what keeps him going.

Dries Buytaert: What do you want to talk about?

David Peterson: I wanted to talk about where you see the big shifts happening — touching on Tim O’Reilly’s keynote address where he talked about the future of devices and cloud data. Also, I was in the Warner Brothers Drupalcon session and they said the biggest problem they were facing is not music piracy. It’s actually the fragmented way that people access content. The website is no longer the focal point; it’s actually the Nintendo Wii’s, the Xbox, PlayStations and mobile phones. So with that in mind, where do you see things going and how will Drupal facilitate that?

DB: Right.

DP: So let’s start with a very basic question. When do you think a stable beta version of Drupal 7 might land?

DB: So, Drupal 7 has about a 100 critical bugs left as of this morning. So we’ll do a release when that number is zero. But, I don’t really know when that number will be zero. It’s really up to everybody in the community to help fix it.

If we do some analysis on the current big fix rate, looking at our history of successful bug fixing, it looks like it could be anywhere between early June (best case) and the end September (worst case).

DP: What about a beta release? Drupal 7 is in alpha right now, will there be a certain point that you were looking to release a stable beta?

DB: We’ve released the third alpha. There’ll be a beta when we feel the upgrade path works.

DP: Like the upgrade from CCK to the new Fields API?

DB: The upgrade path from Drupal 6 to Drupal 7.

DP: So essentially a core 6 to core 7 upgrade?

DB: Well, yes. CCK is no longer a part of Drupal 7 so a migration path has to include taking what was CCK and upgrading it to Fields. That’s what we are thinking right now. It’s still some thing which we need to discuss a little bit more because the CCK people actually think it might be better to keep the CCK update as a contributed module, for a little while, for technical reasons.

But the bigger picture of a Drupal 7 release, the big goal is to get the upgrade path to work in a way that everybody agrees with and then we’ll switch to beta releases.

DP: In your keynote you mentioned distributions as being a really important aspect of Drupal and a real point of differentiation. Why do you feel it’s such a driving part of what makes Drupal unique and how will that help the uptake of Drupal in the wider community?

DB: To answer the first question, which I think was why is it important, when I talk to people, usability is still the number one issue. And not just usability but, “Can Drupal do this?”, “Can Drupal do that?”, “How do I do this?”. There’s a lot of barriers to get people started, that starts with installation, module selection and usability. There’s all of these things and I think distributions are a great way to solve that. These are packaged solutions instead of a framework with a big box of building blocks.

DP: And a scary learning curve (laughs).

DB: So I think it helps with the learning curve which I think will help with Drupal’s growth. If we can remove some of those barriers with new distributions then I think Drupal will succeed in growing a lot more.

DP: Kind of along a similar vein, what do you think are Drupal’s biggest challenges in terms of the future? In your keynote, you mentioned WordPress is now moving towards a more open model along with Joomla and other systems. What challenges does Drupal face within a more homogeneous group?

DB: The big threat, sort of an ugly word, but is of course that if Joomla and WordPress are coming from the bottom up, if you will, then that could replace part of our install base. So that’s a threat. And I think distributions could help protect ourselves against that because it means distributions could do many of the things that WordPress does. Just to be clear, I’m not super competitive with WordPress or Joomla. I don’t want to come across as fearing those projects.

DP: Yeah. I suppose maybe “threat” was not the right word. It’s more like ‘how do you keep Drupal relevant in a world that’s homogenising?’

DB: My long term concern is staying relevant. How do we keep the level of agility and innovation and stuff that we have today that allow us to be leading edge and to be all the things that make us so successful.

DP: So what are you doing to address that? Currently, I guess it’s a great community, lots of contributions and things like that. But I mean one of the things you addressed in the keynote again is you want more people to give back. How are you going to maintain that Drupal will always be at the forefront? How do you do that?

DB: It’s very much a cultural thing. I don’t think there’s technical solutions to these problems. Just a desire that people have to be innovators and for the project to be state of the art compared to other projects, but also to maintain the way that we work. I’m not saying that we should adjust the way we work. We have to keep the project healthy, but keep our core values, our base principles that we have had for many, many years. But I think the ingredients are all there. I think everything works pretty well the way things have been working and so trying to stick with those I think is key.

As it grows it’s always easy to apply rules. Its one of those things that sometimes adding rules is much, much easier than removing rules, so once you’ve added a rule or a new process it’s very hard to get rid of it.

DP: Things are developing at a fast pace now. Facebook has just announced the Open Graph protocol, essentially it’s a protocol that enables integration of web pages into a graph, a social graph. And I know in the Boston Drupalcon you talked about that and you’ve been talking Linked Data and the Semantic Web multiple times since. In Monday’s keynote you again talked about Tim Berners-Lee’s Giant Global Graph. Previously it’s always been a bit more academic and a bit more techie, but I guess with Facebook’s rubber stamp this morning its finally getting real and exciting.

DB: Yeah, I haven’t seen it yet but it sounds exciting.

DP: I have just just barely read it myself (laughing).

In Tim O’Reilly’s keynote he talked about the future of the web in which the browser becomes less important but portable devices and inter-operating with the cloud becomes the dominant medium.

How is Drupal going to lead in the era where the web browser and the web interface is actually on the decline and the rise of the cloud and devices?

DB: Right. I think it’s putting more focus on import and export, web service APIs and those kinds of things instead of just HTML. In Drupal 7 there are some significant improvements. We are starting to make the HTML renderer basically abstract away from the system a little bit so that we make it easier to generate other formats like JSON, XML or whatever. So I think evolving that sort of to the next level where there is much more web service integration and things like RDF and RDFa will help.

DP: So in some ways I guess kind of treating a Drupal page more as a data layer rather than a traditional static HTML page. Something that could act like a possible layer in a transaction. Something like that?

DB: For example it’s sort of related — like in Drupal 6, we basically generated snippets of HTML and that’s how a page was generated. In Drupal 7 we still do the same thing but before we start generating all of those snippets we first build a big data object of the entire page. A big nested structure which is sort of like a page object. And that actually makes it very cool because you capture the structure of the page and can perform operations on the page.

Also, by capturing the annotations around a function we could automatically generate a web service API for that function. If we can do that for the functions as well as for data types then I think Drupal becomes super hackable in a good way (laughs). We can start using it as a mash-up platform, start doing all of these things.

DP: That sounds Great.

Microsoft’s announcement at Drupalcon of a native SQL Server driver for PHP was really cool. Are there any other tricks up Drupal’s sleeve? Are there any other things in the works or strategic partnering with these previously less then Open Source friendly groups?

DB: I know there’s a lot of companies looking at Drupal right now trying to figure out how they can leverage Drupal. Ultimately that’s what they want to do. I know Dreamweaver recently got a Drupal plugin I think from Adobe. It’s another small example of how big companies are starting to take notice of Drupal, starting to build software for it.

DP: What other areas of technology interest you? What excites you? What keeps your brain ticking to the next step?

DB: A lot of different things. A Drupal specific one for example, I think the next thing that we need to look at for the enterprise is staging. I spoke to a lot of enterprise customers and staging and configuration management is a problem that we need to solve. It’s a difficult problem but at the same time that’s sort of what makes me excited about it. It’s not like a small problem. It’s actually a big problem which could require some significant engineering potentially so that keeps me excited.

I think cloud computing and software as a service are exciting me. Not only from a technical point of view but also from a business model point of view. I think cloud computing and software as a service actually bring new monetization opportunities to open source which is something that we didn’t really have before. I mean, some people did it before but we’re starting to better understand the possibilities of cloud computing and open source and how we can leverage it to monetize open source project. Which I think is healthy. Because we can still give everything back, but at the same time organisations will be able to make money off of open source which I think is very important for a project to be successful.

I think a good example of this is distributions in Drupal. It’s really cool. It would be really great to have many of them. And I think we’ve solved many, but not all, of the technical problems. And I think there’s going to be revisions of the technology that we’ve built in distributions. But I think the big challenge is still the business model around distribution. We need to figure out how people can make money by building distributions, because building a distribution is time consuming and it takes a lot of effort and I think that cloud computing and software as a service provides that opportunity to distributions.

DP: Yeah. So kind of on that same vein but maybe extrapolating out another few years… do you have a picture of the next big thing in store, Drupal 9, or a fairly long term 3 or 4 year goal with Drupal or just with your own developments or things in general.

DB: Umm… I don’t think… I do, but I’m not sure it’s a picture I can describe.

DP: Okay (laughs) probably a good thing.

DB: Yeah, I don’t know, it’s not like those four features or something. It’s like, for example I believe people’s expectations from web applications are rapidly changing. People expect them to be very easy to use. Very intuitive to use. There’s a lot of very specific applications being developed which are exactly that so I strongly believe that we should make Drupal easy to use

So if I think ahead I see something which is easy to use that’s as good as I can describe it. I also see mobile being much more prominent so I also see something which can be easily accessed from mobile websites or devices.

DP: We were just talking about the good hackability of Drupal and your interest in the cloud and how those things can combined. What you are describing looks to allow for that mobile, more ease of use and multi-device capability that is already upon us.

Lastly, what keeps you motivated. I mean you’re traveling a lot and you’re a fellow father of young ones, what keeps you moving and dreaming.

DB: That’s a really good question. You know for me as long as I can learn I’m having fun. Actually, it’s really having fun. I’m having a lot of fun and the fun comes from being able to learn — from being surrounded by people I can learn from. Just working with the people that I work with, you know all of the people in the community. Working on the projects that I work on, it keeps me really excited. So excitement and fun are it.

DP: Great, well thank you very much for your time.

DB: You’re welcome.

DP: It’s been an absolute pleasure talking to you.

Difference between Drupal and Joomla

dhiraj.patra@gmail.com (dhiraj patra) — Thu, 01 Sep 2011 21:48:45 PDT

Anyone trying to evaluate open source content management systems is aware that there aren't a lot of recent, useful comparative reviews. What's surprising is that this issue is true even for such popular solutions as Drupal and Joomla.

Stating in January that, "most comparisons of Drupal (news, site) and Joomla (news,site) conclude that you should select the one that best suits your needs. However, they give too little guidance about how to do that," Webology eBusiness Solutions set out to quantify the pros and cons of each by releasing a survey.

The Survey

The survey divided questions into five categories:

Developers
Documentation
Performance/Functional Aspects
Appearance
Ease of Use/Learning

Users were classified by their response to "CMS most experienced with," with those answering "Not Applicable/Don't Know" to this question being removed from the analysis.

In general, the respondents were slanted a bit more toward Joomla users than Drupal users. Their roles when working with their respective CMS's break down to the largest group being Project Managers, and other large groups including Programmers and Designers. The Drupal users were, somewhat unsurprisingly, more experienced, with a median of 7 years experience in web development, while Joomla users claimed 5.

The Results

In general, there were a lot of responses that fit expectations.

Drupal Users Love Drupal, Joomla Users Love Joomla

Drupal users list the highest client satisfaction with Drupal, and Joomla users list the highest satisfaction of their clients with Joomla. Drupal developers feel that Drupal is easier for developers to learn, and Joomla users feel that Joomla is easier to learn. After all, if you already chose Drupal or Joomla, there was probably a reason you chose it at the time.

Drupal Better for Extensibility and Large Sites

Once you get down to slightly less biased issues, it gets more interesting.

Drupal users rate their CMS higher than Joomla users rated theirs in areas such as documentation (especially core and module documentation) and bugs (core and modules). Drupal users apparently feel that their add-ons integrate better with the core, and their framework makes it easier to extend their CMS's capabilities.

Drupal users also rated Drupal higher than Joomla users rated Joomla for their support of multimedia, social networking, SSL, forums, event calenders, blogging, document management, SSL, internationalization, user management and permission features (a huge gap of 40%), ease of external integration, the ease of developing large, complex web sites, and the quality of add-ons for enhancing functionality.

Joomla Easier for the Non-Geeks

However, Drupal didn't win in every aspect. Joomla users rated Joomla higher than Drupal users rated Drupal when it came to the ability for non-technical people to learn the CMS interface (another large gap), maintenance and upgrading, the ability to create a new and functioning site quickly, the ability to teach clients to use their CMS effectively, and their willingness to put time and money into improving poorly performing extensions.

Which Web CMS is Better?

Sorry, there's still no cut and dried answer, and for that matter, we at CMSWire don't even believe in the question.

If this survey proves anything, it's that the choice of Web CMS depends on what you're trying to do — which is what we've been saying all along. At least now folks have a more quantifiable set of opinions to look at.

For the complete list of questions and responses, along with all of the numbers, see theWebology eBusiness Solutions blog. And if you want more CMS data (and a little controversy), see our coverage of Water & Stone's most popular open source CMS survey.

Benefits of PHP Programming in Custom Web Development

dhiraj.patra@gmail.com (dhiraj patra) — Tue, 23 Aug 2011 03:20:39 PDT

The original full form of PHP is Personal Home Page but in programming sense it stands for Hyper Text Preprocessor. HTML is client side language means Browser translate the HTML code into the “byte code” that is easy to follow for a computer. The “byte code” then translated into the out put as we see on the screen for instance in to the Text or Image.

Server side language in web development

PHP is server side language means PHP has an interpreter that interprets PHP code into the HTML code for a browser means every time it writes the HTML for your PC’s browser from the server where it resides. That means it can generate HTML for so many browsers at a time. Rest of process is same for the HTML as we have discussed earlier, means HTML get translated in to the byte code and byte code in to the computer screen Text or Image. With server-side scripting languages, you don’t need anything adding to your browser or computer, as the interpreter inside the machine that hosts the particular Website does most of the work.

Dynamic language in web development

HTML is static language therefore it creates static pages whilst PHP is dynamic language. Here dynamic means? Suppose you run a forum and you have a page written for today. You have to edit the whole site for its update if it is written in HTML, for a page for tomorrow you will again edit the site and so on for the next days. If your site is written in a PHP you need not go to edit it every time you write a post. This process is automated for a server side language.

What dose PHP do here? It sends the data of your written page for forum to the server. On server it saves in “pre-defined” variables (things that store a value), and using something called a “while loop” that continually loops all the posts saved in the Web page – and that’s it! PHP stores the posts in a MySQL database (something that holds data, if you like, like member accounts, etc) and uses that as long-term memory.

Fast and better in web development

PHP is compiled by PHP engine on runtime this makes its execution rapid so it is running fast. Its codes are highly optimized means it never put any strain over the server as well as nothing left for the machine of the browser where it runs means computers of the users. PHP is effective with a rational database like MySQL so it is fast with database use too.

Other benefits in web development

The code of PHP is simple and easy to understandIt is most suited to the needs of small business as it cost less compare to other languages and give better performance.PHP is highly adaptable to the most of the databases connectivity.PHP has cross platform compatibility means it can run on all OS like windows, Linux, Mac etc.PHP is cross browser compatible means it can run on any browser.PHP differentiate the presentation layer and data layers very well.It can be used in command line scripting.

PHP Tools useful in web developmentHere I did try to give you links of some of useful PHP tools during web development.Debugging Tools

Webgrind (code.google.com)Xdebug (xdebug.org)Gubed PHP Debugger (gubed.mccabe.nu)DBG (php-debugger.com/dbg/)PHP_Debug (php-debug.com)

Testing and Optimization Tools

PHPUnit (phpunit.de)SimpleTest (simpletest.org)Selenium (selenium-rc.openqa.org)PHP_CodeSniffer (matrix.squiz.net/developer/tools/php_cs)dBug (dbug.ospinto.com)

Documentation Tools

phpDocumentor (phpdoc.org)PHP DOX (phpdox.net)

Security Tools

SecurimageScavengerPHP-IDSPixy: PHP Security Scanner

Image Manipulation and Graphs

PHP/SWF ChartspChart – a chart-drawing PHP libraryWideImageMagickWand For PHP

PHP Code Beautifier

PHP_BeautifierPHPCodeBeautifierGeSHi – Generic Syntax Highlighter

Version-Control Systems

Phingxinc

Useful Extensions, Utilities and Classes

SimplePieHTML PurifierhtmlSQLPHPMathPublisherphpMyAdminPHPExcel

PHP Online Tools and Resources

Minify!PHP Object GeneratorgotAPI/PHPkodersPECL

In-Browser Tools (Firefox Add-Ons)

FirePHPphpLangEditorPHP LookupPHP Manual Search

Frameworks for PHP

DwooCodeIgniterYII Framework

PHP IDEs and Editors

PhpEDphpDesignerZend Studio

curtsy: kinjal

Tips for Learning Simple Php

dhiraj.patra@gmail.com (dhiraj patra) — Tue, 23 Aug 2011 03:19:20 PDT

When you are trying to learn a new programming language like PHP, it can get a bit intimidating, especially if you have never had experience with other programming languages before. But trust me, the toughest hurdle is really the starting point. Once you have gotten over that, it is really just a matter of keeping your focus and practicing. Be patient and learn the steps one at a time and you will get there. Here are some tips to help you learn simple PHP:

Learn the basics.

To learn a new language, specifically a programming language, you will need to have basic computer skills. Before you can learn PHP, you need to have a basic background on HTML. This is necessary to make PHP easier to grasp. Plus, you can alternate between the two later on using the same document.

PHP is a language that uses scripting and often used with HTML to supplement functions that HTML lacks. With PHP, you can collect and process data, make comparisons and calculations things that you can not do with HTML. Using this skill, you can create other functions to produce data that is more specialized.

Get the tools.

To create PHP pages, you will need a text editor. A plain text editor is a program that lets you edit files in plain text. These are the ones that come with extensions such as. php, .cgi, .html, etc. These types of text editors will not save formatting on the file, only the plain text. If you have been using a text editing program for your HTML file, that will do. you will probably use either Notepad (for Windows) or Text Edit (for Mac).

Get an FTP.

A File Transfer Protocol or FTP is used to exchange files from your computer to a remote server. This is the one we use to connect on a LAN or to an Internet site.

Get busy.

Once you have the right tools, you will have to practice creating files using PHP. There are some very important stuff that you will need to learn, including basic mathematics and IF statements and using variables. you will have to go through these first before you can hope to build a reliable PHP file.

Once you know your way around these skills, you can then start learning about loops. Loops are just your basic true or false statements that will perform repetitive actions again and again until certain conditions are met. After mastering the loops, you can then learn how to write your very own functions. Once you have learned how to manipulate the codes to create your desired result, there is virtually no limit to what you can do.

Online resources for learning simple PHP

You can not possibly learn simple PHP from a single short article like this, so it is best to expand your knowledge and turn to other resources like books and online sites. Some sites to check out:

PHP.About.com

There are several articles on this site that discuss the most basic information you need to know to learn simple PHP. This is a great source for web based tutorial that features clear step by step instructions on using PHP, HTML, XML and MySQL databases.

PHP Buddy.com

This site contains Quick Start tutorials on PHP and scripts that will make it easy for you to learn the program easily. This includes a brief introduction and learning basic PHP syntax. There are also valuable tutorials on using cookies, data inscription and working with functions and sessions using PHP.

PHP Freaks.com

This is a site for people who want to learn both PHP and MySQL. The site has 90 tutorials on PHP, more than 400 PHP code examples and nearly 3,000 articles that discuss various information, tips and tricks to make learning simple PHP quick and easy.

Article Source: http://www.articlesbase.com/programming-articles/tips-for-learning-simple-php-159206.html

Flash Builder for PHP 4.5.1 Gets iOS Support

dhiraj.patra@gmail.com (dhiraj patra) — Tue, 23 Aug 2011 03:18:05 PDT

IBM i shops that use the latest release of Zend Technology Flash Builder for PHP can now compile their Flash user interfaces into native iOS applications that will run on Apple devices. Flash Builder for PHP version 4.5.1, which was released late last month, enables developers to target all major client devices--including Windows, Mac, and Linux PCs; Web browsers; and iOS, Android, and Blackberry Playbook mobile devices--with a single development effort.

Zend launched the first release of Flash Builder for PHP (version 4.5) in May. The offering combines Adobe's Flash Builder development tool with a full copy of the Zend Studio IDE, enabling programmers to write slick Flash-based interfaces from the IDE they use to write back-end PHP apps for IBM i, Windows, Linux, and every other server supported by PHP.

The Eclipse-based software makes it relatively easy for PHP developers to use Flash to power their GUIs. Adobe and Zend have built a layer of integration into the software that allows developers to work on Flash and PHP projects from the comfort of a single IDE.

But why would somebody want to use Flash to begin with? There are pros and cons. On the plus side, Flash (formerly called Flex) provides a rich library of objects that make it quite easy to build so-called rich Internet applications (RIAs) using drag-and-drop motions. Also, the Flash Player (a layer that is normally required to run a Flash interface) is ubiquitous. It's installed as a Web browser plug-in on more than 99 percent of the world's PCs.

But there are downsides. For starters, some think Flash websites are annoying (these people were probably happiest in front of screen scraped 5250 apps, or 1990-era bulletin boards that resemble DOS.) But the biggest knock against Flash has been that it doesn't run on iOS, the Apple mobile device operating system that is taking over the world.

This is why the version 4.5.1 update is important. According to Zend's IBM alliance director Michael Scarpato, the new release of Flash Builder gets around this roadblock by using the Adobe Integrated Runtime (AIR), a cross-platform runtime that can run Flash applications on any supported device. Since iOS supports AIR, Flash Builder (and Flash Builder for PHP) developers can now target iOS devices with their i OS apps.

"AIR is the technology to run Flash," Scarpato says. "That technology has been extended to run anywhere. So it can run on iOS, Android, and Blackberry Playbook. It can run on desktop OSes like Linux and Mac and Windows. And it can also run in the browser."

Flash Builder for PHP 4.5.1 supports iOS by compiling the application and making it available to users through iTunes App store, Scarpato says. "You get that down, and all the components needed from AIR are bundled or compiled in the application, enabling it to run natively, so you don't need Flash and you don't need the browser at all," he says.

"This gives people the ability to create a common code base of Adobe flash code, along with Zend's PHP code running on the IBM i in Zend Server, and basically build the application once--build it in a way that it will run anywhere--and get to all of these different devices at the same time," he says.

While users will appreciate the modern look of a Flash interface, developers who use Flash Builder for PHP will appreciate the integration work that Zend has done to hook the PHP and Flash environments, according to Kent Mitchell, senior director of product management for Zend.

"Probably the single biggest feature that developers love is integrated debugging," Mitchell says. "When you're trying to figure out why code doesn't work--and some of the code is in Flex and Flash, and some is in PHP--if you have separate debuggers and they're not integrated, it's really a giant pain in the butt. So with this integrated debugging, you can literally start debugging on the mobile device, follow that request from the mobile device into the PHP, figure out where PHP is doing something wrong, then fix it, and then basically watch the flow all the way back out and make sure everything's working the way you expected it to."

The joint Flash offering with Adobe comes on the heels of last year's release of Zend Studio 8, which introduced JavaScript into the IDE for the first time. JavaScript, of course, is another technology that developers can use to create compelling Web 2.0-style applications. And the fact that Zend Studio supports several different JavaScript libraries, including jQuery, Dojo, ExtJs, and Prototype, gives customers choices.

The choice, then, to use Flash Builder would mainly be made if an organization had a substantial investment in Flash technology and had a lot of people with Flash skills in house. The capability to target nearly every device with a single development effort (something that is not yet possible writing just JavaScript) is another advantage of going the Flash Builder for PHP route.

It's worth noting here that Flash Builder can be used without PHP. In fact, the standalone Flash Builder product can create very compelling interfaces from RPG business logic. Check out Shannon O'Donnell's recent Four Hundred Guru story, "Adobe Flash Builder for the iSeries Programmer, Part 1", for more info on using Flash Builder.

There was a problem with the first release of Flash Builder for PHP that had a big impact on users who had installed Adobe's Creative Suite on their PCs. The problem, which caused the rest of the Creative Suite to stop working, has been addressed by Adobe in this knowledge base article.

Zend and Adobe are selling two versions of Flash Builder for PHP, including the standard edition and the premium edition. The premium edition, which costs $799, gives users access to advanced features, such as improved support for large apps, memory and performance profilers, a network monitor, and a command-line build, that aren't available in the standard edition, which costs $399.

IBM i customers should go through Zend to get access to the Flash Builder for PHP. Most IBM i customers are eligible for discounts from the listed price.

curtsy: Alex Woodie

PHP Frameworks

dhiraj.patra@gmail.com (dhiraj patra) — Tue, 23 Aug 2011 03:16:48 PDT

Before you can actually implement PHP frameworks on your web designing project it is important to fully understand the way they function and how they can work to enhance your project. PHP is actually the most popular and common script language used by web designers worldwide, and there is a definite reason for its popularity.

First of all it is simple to use and flexible, as many times coding and scripting can get tiresome and boring. PHP will help you to apply applications rapidly, saving time and generating more stable applications. It will also cut down the codes that recur frequently and are used by web developers. This is why web designers and developer favor this method, which is also very suitable for beginners.

You can build very stable applications and provide a precise data base of coding and interaction. This will save time on writing down repetitive codes and allow you the time for creative issues. There are various reasons for using PHP frameworks, the main one being that it speeds up issues related to web development.

If you can use the recurring codes for different project without having to insert them manually each time, this will save a lot of time and effort. You can use pre-constructed modules that will allow you to take care of all coding tasks that are recurring. Web designers can then concentrate in developing the various applications and avoid having to create a new foundation for each project.

The beauty of PHP lies in the simplicity of the system; this is why many prefer to use scripting language. However, the simplicity can also cause problems, although for beginners it is easy to implement, as you could be writing wrong codes and not realize you are doing so.

The problem is that when using PHP your applications will still work although you may have created a big security problem in the coding that you would not be aware of. This will mean that your website is not secure, as PHP will forgive a lot of misuse in coding, but unfortunately put you at a risk.

With PHP you can use many different frameworks as it offers an extensive choice of available tools to work with. PHP also allows you to create your own framework if you wish to add more creative ideas. However, many web designers use the available frameworks offered by PHP as they are extremely popular and are enhanced by support teams and forums.

You can use the forums to exchange views and ideas when using the same type of framework, which can be of create help when you are just starting. Before you use a determined framework you should examine it properly and decide if you can use it for the type of project you have in mind. To determine whether it is the right one to use, ask yourself if it will save you time and work, and if it will provide the stability you need.

The expenditure of PHP web development decrease for PHP developers

dhiraj.patra@gmail.com (dhiraj patra) — Tue, 23 Aug 2011 03:15:45 PDT

Personal home page: PHP is often a mostly used, general-purpose scripting language that is basically planned for web development to create dynamic sites and application. PHP great for server-side web site development, and this usually exercise on a web server. Hypertext Preprocessor doubles to create client-side GUI applications and command-line scripting.
Recent time this scripting language popularity is increasing each day for business web development. There are particular reasons for this popularity. First reason is this :, it’s available cost-free, along with the PHP owner provides complete source code for users to set up, customization, and extend for manage a webpage. That way, the expenditure of PHP web development decrease for PHP developers and it also advantage will receive Merchant.
To make a website using PHP certainly a simple and easy and not other development tool like ASP.Net and Java. The functions, methods and syntax for this scripting language simple and easy, and developer and programmer are aware of it easily. It is actually full supported with HTML. These way developers and programmers are increased, and then we can hire PHP web developers in low payment for your business.
PHP contains free and free libraries along with the intent being core build. PHP also embedded free open source database like PostgreSQL, MySQL and SQL ite, LDAP servers, as well as others. This scripting language also supports relational database management system. It decreases the web development cost.
PHP is generally used in combination with Linux the gw990, and it is an also open source and free as replacements. The development of the business website using PHP and Linux it is going to decrease the cost. PHP is usually deployed of many web servers, many os and platforms, and can be employed all sorts of relational database management systems.

curtsy: maryr.johnston

PHP.Net: 5.3.7 Upgrade Warning

dhiraj.patra@gmail.com (dhiraj patra) — Tue, 23 Aug 2011 03:14:34 PDT

In a quick note from the PHP.net site, they have a warning for those running PHP 5.3.7 (the most recent release) – there’s a bug that’s serious enough (with crypt) to where upgrades should probably wait until 5.3.8.

Due to unfortunate issues with 5.3.7 (see bug#55439) users should wait with upgrading until 5.3.8 will be released (expected in few days).

The issue causes the crypt() function to only return the (MD5-only) salt it was given instead of the correctly hashed string. If you need to replace this immediately, you can pull the latest from the snaps site (or binaries for Windows). Keep an eye out for PHP 5.3.8 in the near future.

If PHP Were British

dhiraj.patra@gmail.com (dhiraj patra) — Tue, 23 Aug 2011 03:13:33 PDT

When Rasmus Lerdorf first put PHP together, he - quite sensibly, despite his heritage - chose not to write it in Greenlandic or Danish. Good job too - that would have been rather unpleasant to work with. He opted instead, being in Canada at the time, for the local tongue. No, not French - that bastard dialect of the Queen's English commonly referred to as "US English"¹.

PHP developers in Britain have been grumpy about this ever since. What was he thinking? And more importantly, how do we undo this travesty? How do we developers ensure the traditions of the British Empire continue to be upheld, even in the digital age?

A Slap in the Face

plainpop-up

$variable_name

The first, but maybe the most important, of many changes that will allow PHP to achieve a more elegant feel is to remove that symbol so beloved by the US and replace it with something altogether more refined. More solid. More ... sterling.

plainpop-up

£variable_name

Getting Started

plainpop-up


    echo 'Hello World!';
?>

How many of today's British programmers have been put off at the outset by the brazen informality of this simple yet obscenely Americanised program, colloquially referred to as "Hello World"? A more Imperial, formal introduction might encourage a greater proportion of young British talent to remain with the language and thus give the broader community a more urbane air.

plainpop-up


    announce 'Good morrow, fellow subjects of the Crown.';
?>

Abbreviations

Few things are more abhorrent to the British than unnecessary abbreviations. "Text speak" is unheard of on the streets of London, as the natural ingrained British grammarian simply refuses to stoop to sending messages of the "c u soon traffic kthxbye" variety, instead proferring something altogether more elegant: "Dear Sir/Madam. I will arrive as soon as time allows, which I expect to be within the hour. I assure you the horses shall not be spared. Yours respectfully." (slower to type, yes, but we do not like to be rushed).

PHP, on the other hand, is full to bursting with abbreviations and acronyms which are entirely unnecessary:

plainpop-up

str_replace()
is_int()
var_dump()
preg_match()
json_encode()
mysql_connect()

The following changes should improve things:

plainpop-up

string_replace()
is_integer()
variable_dump()
perl_regular_expression_match()
javascript_object_notation_encode()
my_structured_query_language_connect()

Edit: I have corrected the expansion of "preg_match" - thanks to those who pointed it out.

Eloquence

plainpop-up

if ($condition) {
    // Code here
} else {
    // Code here
}

Shakespeare would be ashamed to see his native tongue twisted into this monstrosity. Brevity is to be applauded in the right context - in some dark corner, where it shall be seldom seen - but not here. The if ... else block is the most used conditional code in all of PHP, so it must be made as inoffensive as possible. There are many options for its replacement, but this may be the strongest:

plainpop-up

perchance (£condition) {
    // Code here
} otherwise {
    // Code here
}

The same naturally applies to the Americanised switch ... case construct, which one can only describe as clunky and unpleasant:

plainpop-up

switch ($variable) {
    case $option1:
        //Code here
        break;
    case $option2:
        //Code here
        break;
    default:
        //Code here
        break;
}

Words such as "switch", "break" and "default" are hard on the reader and lack context. The Right Honorable biggerthancheeses was kind enough to contribute a more gentrified suggestion (and has some interesting ideas, particularly around replacement of "include()" with something like "i_might_be_partial_to()", demonstrating a natural talent for the Imperialisation of programming languages):

plainpop-up

what_about (£variable) {
    perhaps £possibility:
        //Code here
        splendid;
    perhaps £other_possibility:
        //Code here
        splendid;
    on_the_off_chance:
        //Code here
        splendid;
}

Spelling

plainpop-up

imagecolorallocate()
serialize()
newt_centered_window()
connection_status()

Words fail me at this point. How is any self-respecting gentleman expected to make head or tail of these "words". It beggars belief that anyone could allow such distortions of words to be entered into a programming language. They, along with the cornucopia of similar errors, should be reverted to their proper forms immediately:

plainpop-up

imagecolourallocate()
serialise()
newt_centred_window()
connexion_status()²

Manners

plainpop-up

try {
    // Code here
} catch (Exception $e) {
    // Handle exception
    die('Message');
}

The try ... catch block is an excellent example of PHP's lack of manners. Far too direct to be allowed in the new PHP. Additionally, the word "die" is so very depressing. This new block, although more verbose, is vastly more polite and upbeat:

plainpop-up

would_you_mind {
    // Code here
} actually_i_do_mind (Exception £e) {
    // Politely move on
    cheerio('Message');
}

Class

Perhaps nothing is as important and ingrained in the British psyche as the notion of class and, while there are few opportunities for change within this part of PHP, the changes that there are to be made here are important.

plainpop-up

class Republic {
    public $a;
    private $b;
    protected $c;
}
$example = new Republic;

To begin with, the current system has no place for class hierarchy and this is unacceptable. So we shall begin by giving classes specific levels - upper, middle, working - and no class can access the methods of one of a higher level without the explicit permission of the higher order class (of course, though it might then have access, it would not be a true member of the higher order and could not itself grant higher order access to other lower order classes). "Public" and "Private", in the British class system, are often synonymous (see, for example, school system nomenclature), so these must be adjusted, as should the "Protected" property visibility. The word "new", while passable, has a much more appropriate replacement in matters of class.

plainpop-up

upper_class Empire {
    state £a;
    private £b;
    hereditary £c;
}
£example = nouveau Empire;

The Sun Never Sets ...

It is hoped that these few simple changes will improve the reputation and status of PHP among other languages. No longer will it be the poor American cousin - instead it can take its rightful place as the - British - King of the scripting languages.

Thanks

Many thanks to Mark and Pat, colleagues at GSBA, who started this resurrection of the British Empire in the pub on Friday.

1. Ok, the neighbouring local tongue.

2. Yes, connexion.

The future of PHP

dhiraj.patra@gmail.com (dhiraj patra) — Sat, 25 Jun 2011 22:32:33 PDT

PHP is already popular, used in millions of domains (according to Netcraft), supported by most ISPs and used by household-name Web companies like Yahoo! The upcoming versions of PHP aim to add to this success by introducing new features that make PHP more usable in some cases and more secure in others. Are you ready for PHP V6? If you were upgrading tomorrow, would your scripts execute just fine or would you have work to do? This article focuses on the changes for PHP V6 — some of them back-ported to versions PHP V5.x — that could require some tweaks to your current scripts.

If you're not using PHP yet and have been thinking about it, take a look at its latest features. These features, from Unicode to core support for XML, make it even easier for you to write feature-filled PHP applications.

New PHP V6 features

PHP V6 is currently available as a developer snapshot, so you can download and try out many of the features and changes listed in this article. For features that have been implemented in the current snapshot, see Resources.

Improved Unicode support

Much improved for PHP V6 is support for Unicode strings in many of the core functions. This new feature has a big impact because it will allow PHP to support a broader set of characters for international support. So, if you're a developer or architect using a different language, such as the Java™ programming language, because it has better internationalization (i18n) support than PHP, it'll be time to take another look at PHP when the support improves.

Because you can download and use a developer's version of PHP V6 today, you will see some functions already supporting Unicode strings. For a list of functions that have been tested and verified to handle Unicode, see Resources.

What is Unicode?

Unicode is an industry-standard set of characters, character encoding, and encoding methodologies primarily aimed at enabling i18n and localization (i10n). The Unicode Transformation Format (UTF) specifies a way to encode characters for Unicode. For more information about Unicode and UTF, see Resources.

Namespaces

Namespaces are a way of avoiding name collisions between functions and classes without using prefixes in naming conventions that make the names of your methods and classes unreadable. So by using namespaces, you can have class names that someone else might use, but now you don't have to worry about running into any problems. Listing 1 provides an example of a namespace in PHP.

You won't have to update or change anything in your code because any PHP code you write that doesn't include namespaces will run just fine. Because the namespaces feature appears to be back-ported to V5.3 of PHP, when it becomes available, you can start to introduce namespaces into your own PHP applications.

Listing 1. Example of a namespace

Web 2.0 features

Depending on how you use PHP and what your scripts look like now, the language and syntax differences in PHP V6 may or may not affect you as much as the next features, which are those that directly allow you to introduce Web 2.0 features into your PHP application.

SOAP

SOAP is one of the protocols that Web services "speak" and is supported in quite a few other languages, such as the Java programming language and Microsoft® .NET. Although there are other ways to consume and expose Web services, such as Representational State Transfer (REST), SOAP remains a common way of allowing different platforms to have interoperability. In addition to SOAP modules in the PHP Extension and Application Repository (PEAR) library, a SOAP extension to PHP was introduced in V5. This extension wasn't enabled by default, so you have to enable the extension or hope your ISP did. In addition, PEAR packages are available that allow you to build SOAP clients and servers, such as the SOAP package.

Unless you change the default, the SOAP extension will be enabled for you in V6. These extensions provide an easy way to implement SOAP clients and SOAP servers, allowing you to build PHP applications that consume and provide Web services.

If SOAP extensions are on by default, that means you won't have to configure them in PHP. If you develop PHP applications and publish them to an ISP, you may need to check with your ISP to verify that SOAP extensions will be enabled for you when they upgrade.

XML

As of PHP V5.1, XMLReader and XMLWriter have been part of the core of PHP, which makes it easier for you to work with XML in your PHP applications. Like the SOAP extensions, this can be good news if you use SOAP or XML because PHP V6 will be a better fit for you than V4 out of the box.

The XMLWriter and XMLReader are stream-based object-oriented classes that allow you to read and write XML without having to worry about the XML details.

Things removed

In addition to having new features, PHP V6 will not have some other functions and features that have been in previous versions. Most of these things, such as register_globals and safe_mode, are widely considered "broken" in current PHP, as they may expose security risks. In an effort to clean up PHP, the functions and features listed in the next section will be removed, or deprecated, from PHP. Opponents of this removal will most likely cite issues with existing scripts breaking after ISPs or enterprises upgrade to PHP V6, but proponents of this cleanup effort will be happy that the PHP team is sewing up some holes and providing a cleaner, safer implementation.

Features that will be removed from the PHP version include:

magic_quotes
register_globals
register_long_arrays
safe_mode

magic_quotes

Citing portability, performance, and inconvenience, the PHP documentation discourages the use of magic_quotes. It's so discouraged that it's being removed from PHP V6 altogether, so before upgrading to PHP V6, make sure that all your code avoids using magic_quotes. If you're using magic_quotes to escape strings for database calls, use your database implementation's parameterized queries, if they're supported. If not, use your database implementation's escape function, such as mysql_escape_string for MySQL or pg_escape_string for PostgreSQL. Listing 2 shows an example of magic_quotes use.

Listing 2. Using magic_quotes (discouraged)

After preparing your PHP code for the new versions of PHP, your code should look like that in Listing 3.

Listing 3. Using parameterized queries (recommended)

                 prepare("INSERT INTO USERS (USERNAME) VALUES ?"); $statement->execute(array($_GET['username'])); ?>

Now that support for magic_quotes will be completely removed, the get_magic_quotes_gpc() function will no longer be available. This may affect some of the older PHP scripts, so before updating, make sure you fix any locations in which this functions exists.

register_globals

The register_globals configuration key was already defaulted to off in PHP V4.2, which was controversial at the time. When register_globals is turned on, it was easy to use variables that could be injected with values from HTML forms. These variables don't really require initialization in your scripts, so it's easy to write scripts with gaping security holes. The register_globals documentation (see Resources) provides much more information about register_globals. See Listing 4 for an example of using register_globals.

Listing 4. Using register_globals (discouraged)

If your PHP code uses global variables, you should update it. If you don't update your code to get prepared for newer versions of PHP, consider updating it for security reasons. When you're finished, your code should look like Listing 5.

Listing 5. Being specific instead (recommended)

register_long_arrays

The register_long_arrays setting, when turned on, registers the $HTTP_*_VARS predefined variables. If you're using the longer variables, update now to use the shorter variables. This setting was introduced in PHP V5 — presumably for backward-compatibility — and the PHP folks recommend turning it off for performance reasons. Listing 6 shows an example of register_long-arrays use.

Listing 6. Using deprecated registered arrays (discouraged)

If your PHP code looks like that shown in Listing 6, update it to look like that in Listing 7. Shut off the register_long_arrays setting if it's on and test your scripts again.

Listing 7. Using $_GET (recommended)

safe_mode

The safe_mode configuration key, when turned on, ensures that the owner of a file being operated on matches the owner of the script that is executing. It was originally a way to attempt to handle security when operating in a shared server environment, like many ISPs would have. (For a link to a list of the functions affected by this safe_mode change, see Resources.) Your PHP code will be unaffected by this change, but it's good to be aware of it in case you're setting up PHP in the future or counting on safe_mode in your scripts.

PHP tags

Microsoft Active Server Pages (ASP)-style tags — the shorter version of the PHP tags — are no longer supported. To make sure this is not an issue for your scripts, verify that you aren't using the <% or %> tags in your PHP files. Replace them with and ?>.

FreeType 1 and GD 1

The PHP team is removing support for both FreeType 1 and GD 1, citing the age and lack of ongoing developments of both libraries as the reason. Newer versions of both of these libraries are available that provide better functionality. For more information about FreeType and GD, see Resources.

ereg

The ereg extension, which supports Portable Operating System Interface (POSIX) regular expressions, is being removed from core PHP support. If you are using any of the POSIX regex functions, this change will affect you unless you include the ereg functionality. If you're using POSIX regex today, consider taking the time to update your regex functions to use the Perl-Compatible Regular Expression (PCRE) functions because they give you more features and perform better. Table 1 provides a list of the POSIX regex functions that will not be available after ereg is removed. Their PCRE replacements are also shown.

Table 1. ereg() functions and their PCRE equivalents

ereg() function	Similar preg() function
`ereg()`, `eregi()`	`preg_match()`
`ereg_replace()`, `ereg_replacei()`	`preg_replace()`

PHP V5.3

Some of the features mentioned here have also been ported to PHP V5.3, which is scheduled to be released during the first quarter of 2008. You may want to upgrade to V5.3 and start using these features now, so that when you move to V6 of PHP, it'll be less of a jump. The following list of features have been back-ported to V5.3:

Namespaces
XMLReader and XMLWriter in core by default

About the author

Nathan Good lives in the Twin Cities area of Minnesota. Professionally, he does software development, software architecture, and systems administration. When he's not writing software, he enjoys building PCs and servers, reading about and working with new technologies, and trying to get his friends to make the move to open source software. He's written and co-written many books and articles, including Professional Red Hat Enterprise Linux 3, Regular Expression Recipes: A Problem-Solution Approach, and Foundations of PEAR: Rapid PHP Development.

Facebook looks to speed up PHP

dhiraj.patra@gmail.com (dhiraj patra) — Wed, 15 Jun 2011 02:30:21 PDT

The internally-developed HipHop for PHP source code transformer is being offered via open source

Technologists at Facebook on Tuesday are releasing a source code transformer intended to boost the performance of PHP.

In development for the past two years, the technology, called HipHop for PHP, has been used to reduce the CPU usage on Facebook Web servers by an average of about 50 percent, said Haiping Zhao, senior server engineer at Facebook.

[ InfoWorld reported on PHP 6 highlights, including internationalization, that were detailed at a technical conference late last year. ]

"The project has had a tremendous impact on Facebook. We feel the Web at large can benefit from HipHop, so we are releasing it as open source this evening in hope that it brings a new focus toward scaling large, complex Web sites with PHP," Zhao said in a statement on the Facebook Developers page.

The technology is not complete and users need to be comfortable with HipHop before trying it out, said Zhao.

HipHop, he said, technically is not a compiler. It features a code transformer, a reimplementation of PHP's runtime system and a rewrite of some common PHP extensions to boost performance optimizations.

"HipHop programmatically transforms your PHP source code into highly optimized C++ and then uses g++ to compile it," Zhao said. "HipHop executes the source code in a semantically equivalent manner and sacrifices some rarely used features -- such as eval() -- in exchange for improved performance."

PHP, Zhao said, offers benefits in terms of programmer productivity, as do other scripting languages such as Perl, Python and Ruby. But scripting languages are known to be less efficient in terms of CPU and memory usage, he said.

"Because of this, it's been challenging to scale Facebook to over 400 billion PHP-based page views every month," Zhao said.

HipHop allows developers to keep the best aspects of PHP while taking advantage of performance of C++, said Zhao.

"In total, we have written over 300,000 lines of code and more than 5,000 unit tests. All of this will be released this evening on GitHub under the open source PHP license," Zhao said.

The CEO of PHP tools maker Zend Technologies questioned how much of HipHop was Facebook-specific.

"It will be interesting to learn what HipHop concepts apply to the broad PHP community and what are specific to Facebook," said Andi Gutmans, of Zend. "We have always adapted to changes within the PHP runtime, whether these changes were made by us or by the community and will be glad to continue doing so. We believe it is important to continue to fold in new ideas and innovations into the community-based runtime."

This story, "Facebook looks to speed up PHP," was originally published at InfoWorld.com. Follow the latest developments in software development at InfoWorld.com.

Paul Krill is an editor at large at InfoWorld, focusing on coverage of application development (desktop and mobile) and core Web technologies such as HTML5, Java, and Flash.

Adobe, Zend combine Flash and PHP development

dhiraj.patra@gmail.com (dhiraj patra) — Wed, 15 Jun 2011 02:29:33 PDT

Flash Builder 4.5 for PHP helps developers build apps for Web, desktop, and mobile systems, including Apple's iOS devices. But you can use Eclipse with plug-in available along with Flex sdk to compile in Eclipse itself.

Zend Technologies and Adobe Systems today announced Flash Builder 4.5 for PHP, which enables developers to use PHP and Flash development skills to build rich Internet applications for mobile, Web, and desktop platforms.

The product provides an IDE combining Adobe's Flash Builder 4.5, for ActionScript-based Flash client development, and Zend Studio 8, for server-side PHP capabilities. Accentuating the use for mobile deployments, the two vendors said applications can be delivered to Google Android, Research in Motion BlackBerry Tablet OS, and Apple iOS systems. For iOS, the IDE exports the applications into native code, rather than run in an the AIR (Adobe Integrated Runtime) software, which Apple prohibits on iOS. Android apps are also exported to a native package.

[ Adobe is backing Android tablets with Flash Player 10.2. | Keep up on key mobile developments and with InfoWorld's Mobile Edge blog and Mobilize newsletter. | Follow Paul Krill on Twitter. ]

Flash Builder 4.5 for PHP, said Zend CEO Andi Gutmans, "makes it very easy for PHP developers to also build mobile apps, and it makes very easy for mobile developers to build server-side apps. We're coming at this from both angles." Applications themselves can be built on Windows or Mac clients.

"Developers will now be able to use one tool, one framework, and one common code base and build apps that run on Android, BlackBerry, and iOS," said Dave Gruber, Adobe group product manager. Flash Builder 4.5 for PHP is due by May 11, with the premium edition, featuring network tracking and memory and performance profilers, priced at $799. A standard edition lacking these features will cost $399. Adobe and Zend are making the announcement concurrently with Adobe's rollout of its Adobe Creative Suite 5.5 product line.

This article, "Adobe, Zend combine Flash and PHP development," was originally published at InfoWorld.com. Follow the latest developments in business technology news and get a digest of the key stories each day in the InfoWorld Daily newsletter. For the latest developments in business technology news, follow InfoWorld.com on Twitter.

Paul Krill is an editor at large at InfoWorld, focusing on coverage of application development (desktop and mobile) and core Web technologies such as HTML5, Java, and Flash.

Cloud computing underwhelms PHP developers

dhiraj.patra@gmail.com (dhiraj patra) — Wed, 15 Jun 2011 02:27:16 PDT

Developers still see it as the future, but they think it is currently overhyped and vendor-driven

While technology vendors continue to pound home the message of cloud computing, PHP developers Tuesday viewed the concept as overhyped and were not in agreement on its benefits.

Developers at the ZendCon 2010 PHP conference in Santa, Clara, Calif., heard Zend Technologies CEO Andi Gutmans tout the company's cloud computing plans, which involve developing Zend PHP Cloud Platform. During his presentation, however, developers appeared mostly underwhelmed when Gutmans asked if cloud computing was game-changing or just hype. Afterward, developers gave cloud computing mixed reviews.

[ Oracle discussed its cloud plans on Monday . | Stay on top of the latest app dev news with the Developer World newsletter. ]

"I guess I have a feeling that 10, 15 years from now, maybe we'll all be using this stuff, but right now, it's entirely pushed by vendors," said Phillip Winn, back-end developer for games builder Tapulous.

"I don't see value in it," Winn said. "I don't have a strong opinion. I don't care. It doesn't affect me."

Winn recalled a former employer who thought cloud computing could be used to cut costs and reduce staff levels. "Economically, it ended up not making any sense for them," said Winn.

Cloud computing, said attendee Chuck Hudson, founder of Aduci, a consulting firm, has been the subject of some hype. "But there's definitely some opportunity there to leverage cloud computing," with developers able to rapidly develop systems and for enterprises to save on infrastructure and maintenance costs, Hudson said.

Rather than view cloud computing as a potential job-killer, Hudson sees it as a chance for IT persons to expand horizons. "I think it's more an opportunity for people in their current roles to learn the new technology and apply it. So I think it's just retooling your toolset."

Cloud computing, said Joseph Munowenyu, computer programmer at Valley City State University, in North Dakota, is "where everything is headed." At consulting firm Atos Origin, the company does not yet use cloud computing, said Atos developer Chris Campbell. "It's something we've been looking at." But he also saw "an element of hype" to the concept.

After his presentation, Gutmans acknowledged people could be "a bit tired of hearing about [cloud computing] because there's so much talk about it." But customers are nonetheless interested in leveraging its benefits, Gutmans said. Zend Cloud Platform will feature portable and native cloud services, application platform monitoring, cluster management, application deployment, configuration management, and IDE integration.

Within the same building complex as ZendCon, attendees at the Cloud Computing Conference & Expo conference Tuesday were more upbeat about cloud computing, as would be expected.

"We're definitely interested in cloud computing and right now, I'm on a research project where we're actually using the Amazon Web Services [cloud] environment to do all of our research work," said Jim Cannaliato, vice president of technology at SAIC.

Another attendee noted his company's growing use of cloud computing. "We've got some bits and pieces, so we're not fully cloud-enabled, but that's the direction we're heading," said Sadri Behbahany, senior director of IT at Wacom, which makes tablet input devices.

This article, "Cloud computing underwhelms PHP developers," was originally published at InfoWorld.com. Follow the latest developments in business technology news and get a digest of the key stories each day in the InfoWorld Daily newsletter.

Read more about cloud computing in InfoWorld's Cloud Computing Channel.

Paul Krill is an editor at large at InfoWorld, focusing on coverage of application development (desktop and mobile) and core Web technologies such as HTML5, Java, and Flash.

Google releases video chat source code

dhiraj.patra@gmail.com (dhiraj patra) — Wed, 15 Jun 2011 02:22:50 PDT

Google has released the code for WebRTC, a voice and video codec for the Web

Google has released the source code for a technology that it hopes developers will use to embed real-time video and voice chat functionality in their Web applications.

Google acquired the technology, called WebRTC (Web Real Time Communication), when it purchased VoIP (Voice over IP) software developer Global IP Solutions in 2010, for approximately $68.2 million. The company said it would open source the technology early last month.

[ Track the latest trends in open source with InfoWorld's Open Sources blog and Technology: Open Source newsletter. ]

WebRTC is a set of voice and video signal processing technologies, which can be accessed by developers through HTML tags and JavaScript APIs (application programming interfaces).

Today, Internet audio and video chat services from companies such as Skype are chiefly proprietary, accessible through plug-ins and client downloads. Last month, Microsoft agreed to purchase Skype for $8.5 billion.

Google wants third-party developers to use the voice and video engines to create chat applications that can be run directly from within a browser. Global IP Solutions has built WebRTC-based mobile clients for Android, Windows Mobile and the iPhone. Ericsson Labs built a videoconference prototype with the technology as well.

The move to open source WebRTC echoes a similar move Google made when it acquired video compression provider On2 Technologies in 2010. Google subsequently released On2's VP8 video codec as open source to provide a royalty-free alternative to the widely used H.264 standard.

Google is working with other browser developers, such as Mozilla and Opera, in hopes they will support the technology in their browsers. The company is also participating in W3C (World Wide Web Consortium) and IETF (Internet Engineering Task Force) projects for creating real-time communication Web standards. WebRTC is based on the W3C's Web Applications 1.0 API.

The source code is available under a royalty-free BSD (Berkeley Software Distribution)-style license.

Google did not immediately respond to requests for comment.

Joab Jackson covers enterprise software and general technology breaking news for The IDG News Service. Follow Joab on Twitter at @Joab_Jackson. Joab's email address is Joab_Jackson@idg.com

Building Semantic Web CRUD operations using PHP

dhiraj.patra@gmail.com (dhiraj patra) — Wed, 25 May 2011 03:54:24 PDT

When developing a Web application, it's standard practice to create a database structure on which server-side code is placed for the logic and UI layers. To connect to the database, the server-side code needs to do some basic creating, updating, deleting, and — most importantly — reading of records. As databases behind Web applications are typically relational databases, these CRUD operations are done using the well-known language, SQL. However, as Web development is increasingly occurring through object-oriented programming (OOP), the model is changing.

The Resource Description Framework (RDF) is a perfect way to describe objects while maintaining the meaning of that data. Simple Protocol and RDF Query Language (SPARQL — pronounced "sparkle") is the language typically used to query against that data, as it syntactically matches the structure of RDF itself. Both RDF and SPARQL are technologies within what has been dubbed the Semantic Web stack.

To fully embrace the Semantic Web idea, you can apply traditional Web-development techniques to RDF data using SPARQL. This article shows how to use a simplified Model-View-Controller (MVC) design pattern, the PHP server-side scripting language, and SPARQL for connecting to RDF — as opposed to using SQL on a relational database system.

SQL and SPARQL CRUD operations

Prerequisites

This article assumes a basic understanding of SQL, PHP, and Web application development. An understanding of Semantic Web is also beneficial. To run the create, update, and delete commands on Semantic Web-based data, you need a Semantic Web data store that supports the SPARQL/Update specification.

It's worth taking a look at the similarities and differences between CRUD operations when developed in SQL and SPARQL. Listing 1 shows the SQL code for a read operation.

Listing 1. SQL for the read operation

SELECT realname, dob, location FROM UserTable  WHERE realname = "John Smith";

Compare that SQL-based code with the SPARQL-based code shown in Listing 2. These are two read operations because they're the easiest to understand, implement, and explain. This is true for both SQL and SPARQL.

Listing 2. SPARQL for the read operation

     PREFIX foaf:   PREFIX rdf:  SELECT ?uri ?name ?dob ?location FROM  WHERE { ?uri rdf:type foaf:Person ; foaf:name "John Smith" ; foaf:birthday ?dob ; foaf:location ?location . } ;

Your first thought when comparing the two listings is likely to be that the SPARQL version clearly has many more lines than the SQL version. That is true, but don't be tricked into thinking that the SQL is necessarily simpler and cleaner. SPARQL, depending on the engine that you run it against, can be completely distributed through something known as the linked data effect. In addition, it allows you to have dynamic schemas because of its interlinked object-oriented perspective, in contrast to SQL's strictly relational perspective. If you were to split relational database tables into as many islands of data, you would actually have many more lines of SQL in comparison to SPARQL — not to mention that the SQL would be full of those nasty JOIN descriptors.

The first two lines of the SPARQL are the PREFIX declarations. According to Semantic Web theory, everything — whether an object or a data graph source (also an object) — has a Uniform Resource Identifier (URI). The PREFIX lines are simply applying a temporary label to some URIs — in this case, the Friend of a Friend and RDF schemas. The benefit here is that you can use the PREFIX declarations later in the query instead of having to use the full URIs.

The next line of the SPARQL code describes the query request. It's essentially the same as the SQL statement, except for the additional request for the URI. Take note of the use of question marks (?) to indicate that the term is a variable.

The FROM statement describes where to grab data. It's the same in SQL and SPARQL, except that in SPARQL, the data source name is a URI, rather than a string denoting a physical location on your computer or network.

The WHERE statements are quite different from each other because with SPARQL, you must specify which schemas to use to fetch data. Once again, if you tried to do this using traditional methods, you would need a lot more than plain SQL: You'd need to use the PHP, the Java™ programming language, or some other server-side language to do checking between data sources. It is reasonably clear what the lines of SPARQL do, which includes ensuring that the data being retrieved is only of the type Person. SPARQL fetches a name and a location while doing some pattern matching to find the right John Smith.

Create

CRUD operations in SPARQL are typically a bit more shrouded in mystery than the read operation. However, they can be done. To begin, the create operation inserts a new record or object into the table or graph.

Listing 3. SQL for the create operation

     INSERT  INTO UserTable (realname, dob, location)  VALUES ("John Smith", "1985-01-01", "Bristol, UK");

Now, compare the SQL-based code in Listing 3 with the SPARQL-based code in Listing 4 for the same create operation.

Listing 4. SPARQL for the create operation

     PREFIX foaf:   PREFIX rdf:  INSERT  INTO GRAPH   (?realname, ?dob, ?location)  {  rdf:Type  foaf:Person ;   foaf:name "John Smith" ;   foaf:birthday  <1985-01-01T00:00:00> ;  foaf:location "Bristol, UK"  }

Once again, notice that the PREFIX lines work exactly as they do in the read operation with SPARQL. The INSERT INTO works similarly to SQL, but again, this is URI-based rather than string-, table-, and name-based, which allows the operation to be done across HTTP. You must also specify the schema again. Here, it's slightly easier to understand than in the read operation, as you can have practically any kind of property so long as it is compatible with the schema. This is a benefit and a beauty of the distributed dynamically extensible objects formalism RDF provides.

Delete

If you create, at some point, you are probably going to want to delete. For instance, users may want to delete their account on your site (obviously unfortunate that they want to leave, but they may have valid reasons). Listing 5 provides the SQL code for a typical delete operation.

Listing 5. SQL for the delete operation

     DELETE FROM UserTable  WHERE realname = "John Smith"

Now, compare the SQL-based code in Listing 5 with the SPARQL-based code in Listing 6.

Listing 6. SPARQL for the delete operation

     DELETE  FROM GRAPH  { ?predicate ?object }

The fundamental difference between the SQL and the SPARQL code is that the SQL deletes a row in a table, whereas the SPARQL deletes "all triples" relating to the "John Smith" object denoted by http://www.example.org/graph/johnsmith#me. This difference is the result the graph-based nature of the RDF model.

Update

Many Web applications allow users to update their information. The UPDATE operation is what makes that possible. Listings 7 and 8 demonstrate how to code this in SQL and SPARQL.

Listing 7. SQL for the update operation

      UPDATE UserTable SET location = "Weston-super-Mare, UK" WHERE realname = "Joanne Smith"

Now compare the SQL-based code in Listing 7 with the SPARQL-based code in Listing 8 for the update operation.

Listing 8. SPARQL for the update operation

     PREFIX foaf:  MODIFY   DELETE {?uri foaf:location ?location}  INSERT {?uri foaf:location "Weston-super-Mare, UK"} WHERE { ?uri foaf:name "Joanne Smith" }

UPDATE with SPARQL may seem incredibly silly, but it's completely valid when you understand that you aren't updating a relational table row — you're updating one very specific relationship within a graph. The easiest way to do this without attaining multiple locations is to delete and insert. The MODIFY keyword is used to establish the connection to the right graph.

Connecting to SQL and SPARQL database systems

To execute the above SQL and SPARQL statements, you must connect to the system somehow. Different systems, obviously, have different connection methods. One common method is to connect to a generic database using Open Database Connectivity (ODBC) drivers, which are often included in current versions of Mac OS X and Linux® systems, and are installable on other operating systems such as Windows®. ODBC essentially provides a simple generic API to connect to an SQL database of your choice. Interestingly, ODBC also works with some Semantic Web data stores such as OpenLink Virtuoso. However, most other Semantic Web data stores require some custom connection procedure or a custom-made generic connection system such as RDF2Go (at the time of writing, RDF2Go is only for Java technology) that work with a variety of systems such as Seseme and Jena. An alternative to consider if your data is going to be exposed over HTTP is a SPARQL connection method over HTTP, which makes your data "Linked Data"-ready and can be completely distributed. Because the range of connection methods for SQL and SPARQL vary, it isn't feasible to cover these in any detail here.

SQL and SPARQL through PHP

After selecting a connection method, the traditional next step is to establish common operations in PHP. For a customized system, this is usually done using SQL strings with PHP variables injected and passed to it through function parameters. The function will then connect to the database and execute this transaction. The proposal here is to do exactly the same for a SPARQL-RDF connection as would be done for an SQL-RDBMS connection.

So, take a gander at another code comparison — this time using the PHP language — starting with read, then going on to create, delete, and update, as with the code comparisons above. Use a hypothetical query execution function called query_execute, which takes in a string representation of the SQL/SPARQL statement.

Read

First up is the simple read operation. Variables can be injected into the query using string concatenation in PHP.

Listing 9. SQL for the read operation

     function readUserInfo($realname) {     $sqlstatement = "SELECT realname, dob, location FROM UserTable WHERE     realname = \"" + realname + "\";";     return query_execute($sqlstatement);     }

Now, compare the SQL-based PHP code in Listing 9 with the SPARQL-based PHP code in Listing 10 for the humble read operation.

Listing 10. SPARQL for the read operation

      function readUserInfo($realname) {     $sqlstatement = "PREFIX foaf:      PREFIX rdf:  SELECT ?uri ?name ?dob ?location  FROM  WHERE  { ?uri rdf:type foaf:Person ;  foaf:name \"" + $realname + "\" ;  foaf:birthday ?dob ; foaf:location ?location . } ;";     return query_execute($sparqlstatement); }

As you can see, the above function has been developed in such a way that the function name and parameters are identical, which means that you could start using the SPARQL version straightaway. Plus, if you're using an ODBC system, you won't need to worry about return types changing.

Create

As above, so below. The following PHP methods inject variables into a string to run a dynamic query. Listing 11 shows how to do that with a create operation.

Listing 11. SQL for the create operation

      function createUserInfo($realname, $dob,     $location) {     $sqlstatement = "INSERT INTO UserTable (realname, dob,     location) VALUES (\"" + $realname + "\", \"" + $dob + "\", \"" +     $location + "\");"; return query_execute($sqlstatement); }

Now compare the SQL-based PHP code in Listing 11 with the SPARQL-based PHP code in Listing 12 for the create operation

Listing 12. SPARQL for the create operation

      function createUserInfo($uri, $realname,     $dob, $location) {     $sparqlstatement = "PREFIX foaf:      PREFIX rdf:  INSERT INTO GRAPH      (?realname, ?dob, ?location)      {      " + $uri + " rdf:Type     foaf:Person ;     foaf:name \"" + $realname + "\" ;     foaf:birthday         <" + $dob + ">> ;         foaf:location \"" + $location + "\}" return query_execute($sparqlstatement);     }

For simplicity, the SPARQL version of this function includes a URI parameter, although it is simple enough to do some additional string concatenation to make the function declaration identical to the SQL.

Delete

Use injection through concatenation in PHP to perform the delete operation. Please note, as mentioned in the previous section, that different variables pass into the SQL and the SPARQL versions. Listing 13 shows the SQL code for the delete operation.

Listing 13. SQL for the delete operation

      function deleteUserInfo($realname) {     $sqlstatement = "DELETE FROM UserTable WHERE realname = \"" + John Smith + "\"";         return query_execute($sqlstatement);  }

Now, compare the SQL-based PHP code in Listing 13 with the SPARQL-based PHP code in Listing 14 for the delete operation.

Listing 14. SPARQL for the delete operation

      function deleteUserInfo($uri) {     $sparqlstatement = "DELETE FROM GRAPH      {<" + $uri +     "> ?predicate ?object }";      return query_execute($sparqlstatement);  }

Once again, for simplicity, the SPARQL version of the function takes in a URI, rather than the real name. You could use the DELETE SPARQL statement with a WHERE clause to find the data by name rather than URI, which would enable you to have an identical function header to the SQL version.

Update

Updating a record is fairly simple in both SQL and SPARQL through PHP. Just be aware of the different structures that relational databases and RDF provide. Listing 15 shows the SQL code for the update operation.

Listing 15. SQL for the update operation

      function updateUserInfo($realname, $location)     {         $sqlstatement = "UPDATE UserTable SET location = \"" + $location + "\" WHERE realname = \"" + $realname+ "\";";             return query_execute($sqlstatement);      }

Now compare the SQL-based PHP code in Listing 15 with the SPARQL-based PHP code in Listing 16 for the update operation.

Listing 16. SPARQL for the update operation

      function updateUserInfo($realname,     $location) {      $sparqlstatement = " PREFIX foaf:  MODIFY  DELETE {?uri foaf:location ?location}  INSERT {?uri foaf:location \"" + $location + "\"} WHERE {      ?uri foaf:name \"" + $realname + "\"     }         ";         return query_execute($sparqlstatement);     }

The function declarations in the SQL and SPARQL versions are identical. As a result, swapping from SQL to SPARQL is simple.

Although it's quite easy to move from a data source with an SQL endpoint to a data source with a SPARQL endpoint, there are two important areas you need to be aware of: levels of abstraction and the similarities and differences between SQL and SPARQL. You want to avoid that trapped feeling that comes from thinking that one language is practically identical to another. So it's best to understand a language's limitations while at the same time exploiting the language's features — in particular, the various syntax sugar and graphical representations provided by different languages.

Levels of abstraction

The example code in this article is strongly coupled to the database structure. In theory, there is only a certain level of loose coupling that SQL and RDBMS can cope with before table structure reorganization must occur. However, this is not the case with SPARQL and RDF. With SPARQL, your coupling with data can be very abstract because of the distributed but interlinked nature of the RDF. The reusability of the examples in this article could potentially be improved by increasing their abstractness. However, for our purposes, simple closely coupled functions are used to exemplify the similarities and differences between SPARQL and SQL.

As you can see from the example code, there are many similarities between SQL and SPARQL. The differences come in when understanding the Web-based, graphical, and object-oriented nature of RDF and how that filters into the SPARQL language. As a simplified rule of thumb, you can imagine the triple structure in RDF and SPARQL as basically representing, in order, the unique primary key of a row (the subject), the attribute/column name (the predicate or relationship) and the cell data that is based on the row and column (the object). In addition, SPARQL can take full advantage of HTTP communication, and, therefore, data can be (but doesn't have to be) distributed over intranets, extranets, and the wider Internet.

Why move from SQL to SPARQL?

There are many reasons why you would want to move from SQL to SPARQL. The details extend beyond the scope of this article, but you could be motivated by the following points:

You want a more distributed data solution.
You want to expose your data on the Web for people to use and link to.
You may find Node-Arc-Node relationships (triple) easier to understand than relational database models.
You may want to understand your data in a pure object-oriented fashion to work with an OOP paradigm (PHP V5 and later supports OOP).
You want to build generic agents that can connect to data sources on the Web.

Of course, there are also reasons why you may not want to move away from SQL, and they are probably perfectly valid reasons. SPARQL is an additional method of querying, not necessarily an immediate replacement of SQL. The same goes for relational data and Semantic Web-based data. These are not replacements. Instead, it's best to think in terms of merging newer and older techniques to produce a hybrid system that can handle and be handled by older legacy systems and the current and future systems.

curtsy: Daniel Lewis

Is This Web 3.0?

dhiraj.patra@gmail.com (dhiraj patra) — Fri, 31 Dec 2010 01:43:18 PST

Not everyone agrees on exactly what Web 2.0 entails. As with all great buzzwords and concepts, people are already predicting what Web 3.0 will be. Will rich internet applications dominate it?

RIAs are still in their infancy, but when done right they're incredibly powerful tools. When Google launched Google Maps a few years ago, it opened people's eyes to the fact that web browsers can do much more than merely display pictures and text.

Currently, there are four mainstream mechanisms being used to develop RIAs.

AJAX/JavaScript: AJAX is a web development technique for using JavaScript with XML to create a rich internet application by dynamically and asynchronously exchanging data in the background without having to refresh the page. Google Maps and Gmail demonstrated what could be done with simple existing technologies like JavaScript and XMLHttpRequest. Google, Microsoft and Yahoo! all now promote their own AJAX toolkits to assist in building AJAX-rich media functionality.

Flash/Flex: The first horse in the RIA race was Flash. Adobe/Macromedia with its Flash/Flex infrastructure is still the leader in online video. Combining the programming capabilities of Flex makes an incredibly powerful toolset for creating internet applications. Flash has strong penetration and when used effectively can enhance your website.

Silverlight/.NET: Microsoft is barreling ahead with Silverlight, a browser plug-in to deliver interactive web applications that should be taken seriously. The company launched Silverlight earlier this year and is promoting it heavily to its large partner development network. Silverlight is delivered to a browser via XAML, which is a text-based markup language. This makes it easier for search engines to scan Silverlight vs. Flash.

OpenLaszlo: Finally, even though you don't see it much, there's an open-source platform for RIAs called OpenLaszlo. Initially developed as a proprietary system by Laszlo Systems, it was made open source in 2004. Not wanting to be left out of the RIA race, IBM--consistent with its embracing of Linux and other open source--has helped propel OpenLaszlo. The company worked with Laszlo Systems to use the open source Eclipse development platform with OpenLaszlo. Applications for OpenLaszlo can be run in Flash or in DHTML.

One current issue with Flash is that while search engines can index it, they don't index it as well as with text because Flash is a binary compiled file. That's why most websites aren't entirely created in Flash. Accessibility and keyboard navigation can be issues with these rich applications as well. If you don't have a mouse or can't use one, then you'll have problems with these technologies. Also, while the plug-ins have sizable browser penetration, they're problematic for some users.

What It Means for You
What does all of this mean for business owners in the Web 2.0 era? For the tech entrepreneur it means new opportunities. Many traditional client server applications are being pressured to move their applications to the web. Entrepreneurs can potentially displace client server apps with new innovative web applications. For other entrepreneurs, you have to evaluate your business and what specific benefits you can get from adding rich features to your website.

Ever Evolving
There will be other emerging technologies in the RIA area. The combination of these rich features will help trends like social networking continue to evolve. We'll likely see many websites with more drag-and-drop-type features in the next few years. The online/offline office also will continue to develop as predominant internet companies compete with Microsoft Office for the next generation office applications. Web applications will continue to become more robust and feature rich than ever before.

courtsy: Frank Bell

NASA updated to MySql

dhiraj.patra@gmail.com (dhiraj patra) — Thu, 25 Nov 2010 21:21:02 PST

The NASA Acquisition Internet Service (NAIS) (http://nais.nasa.gov/) is responsible for providing the general public with information regarding contract opportunities with the revered space organization. A network of servers interconnecting 12 of NASA's field installations, NAIS is the only means for obtaining acquisition information for contracts ranging between $25,000 and $500,000. Saving NASA and its partners roughly $4 million annually, the NAIS model has been so successful that it has been adopted by the U.S. FedBizOpps program (http://www.eps.gov/) as a means for providing access to contracting opportunities for the entire U.S. Government. Furthermore, NAIS supports several thousand users, and receives on average 300,000 hits each month.

Given NAIS' mission-critical purpose at NASA, quite a few heads turned when they announced the successful conversion of the NASA Acquisition Internet Service database backend from Oracle to MySQL. Restructuring of Oracle licensing agreements would have left NAIS facing a serious budgeting dilemma. As a result, the NAIS team began searching out a more cost-effective database solution. The obvious choice? Open Source. And within the Open Source arena, the NAIS team settled upon what they considered to be the most robust database product available: MySQL.

Asked what aspects of MySQL were most appealing, NAIS director Jim Bradford responded with three, paraphrased here:

Cost: Because the total cost of MySQL is limited to the cost of technical support, given that MySQL is available for free download and use in most cases.
Support: Due to the large developer community which can be found on the Internet. Although NASA has used direct support from the MySQL developers infrequently, he stated that "they were very helpful and responsive when needed". Furthermore, NAIS developer John Sudderth stated in an article discussing the switch that the cost for official support was about 1 percent of the technical support expenditure for Oracle (http://www.gcn.com/vol19_no33/enterprise/3275-1.html).
Compatibility: MySQL can easily interface with most SQL-compliant applications through ODBC.

Perhaps a fourth advantage to making the switch to MySQL could be attributed to performance. "We noticed an increase in [speed of] performance since the change and have not experienced any problems with the product.", says NAIS Computer Systems Analyst and project leader Dwight Clark stated in an article for Federal Computer Week (http://www.fcw.com/fcw/articles/2000/1204/pol-nasa-12-04-00.asp).

courtsy: W.J. Gilmore

MySQL and "LAMP" Save istockphoto.com $900K

dhiraj.patra@gmail.com (dhiraj patra) — Thu, 25 Nov 2010 21:18:51 PST

Istockphoto.com is the biggest royalty-free stock photo community in the world, and its sister company, istockpro.com, is home to a host of illustrious professional photographers. Every week, approximately 5,000 photographers upload more than 2,500 photos (2.5 GB) to MySQL® -- the world's most popular open source database -- and approximately 1,250(1.25 GB) are accepted and posted to istock Web sites. More than 200,000 customers, including corporations, advertising and public relations agencies, and individuals access these photo databases and download 20-30 GB daily for a variety of uses. The MySQL database tracks every photo submitted and manages the permissions and billing, all for the fraction of the cost of traditional database systems.

"We operate a classic LAMP system," says Patrick Lor, executive vice president. "MySQL enables us to grow our business at a rate of 15 to 30 percent a month.

A traditional database would have required at least a million dollars in funding for design, hardware, and all of the other costs associated with such solutions. We still wouldn't have gained the flexibility and stability that MySQL provides. With the LAMP approach, we've built a business based on sweat and ideas, and are growing it exponentially. And, it only cost about $100,000 to implement.

According to Lor, istockphoto.com has a unique billing system that saves the company substantial costs associated with invoicing. In this model, users pay a $10 fee and then download photos against that sum. With each download, the user is issued a receipt. When the $10 runs out, users simply make another deposit. The MySQL database monitors the entire process.

Istockpro.com, the other istock site, operates somewhat differently. Professional photographers submit their photos, which are then posted to the Web site. Users then pay by credit card. MySQL tracks permissions and transactions, and provides some minimal accounting features to the photographers. Again, email receipts are issued, avoiding many of the costs typically associated with invoicing.

Prior to moving to an open source solution, istock Web sites relied on Cold Fusion. Lor states that, in addition to costs associated with this product, they were working with a version that they thought needed more work before it could help achieve their goals.

We realized that MySQL and other open source products opened more options for us, says Lor. The talent pool was more varied and the costs were certainly lower. More importantly, open source provides stability that is critical to our operations. Traffic is king in this business, and if we can't reliably support our photographers and our customers, we're out of business.

Lor says that his company also jumped on what it saw as a trend toward using open source solutions for the enterprise, with unexpected results. The increasing legitimacy of open source solutions enables istock to approach much larger partners, such as Adobe Systems, Inc., than would otherwise be possible.

After all, we're using the same database that Google and Yahoo! rely on, Lor says. That means that our choice of database is an asset, and not a liability when we go after partners and new business. It helps us grow.

MySQL helps istock grow in other ways, as well. According to Lor, the 250,000-strong customer database records comprise active users who frequently ask for new features. MySQL helps accommodate these requests, enabling Lor and his team to make changes on the fly, in most cases within an hour or two.

Additionally, the istockphoto site is particularly active, with photographers - and their photographs - changing on a daily basis. MySQL tracks and manages these updates seamlessly.

When you're growing as rapidly as istock, scalability becomes mission-critical. Over the last year, the istockphoto configuration has grown from three to 10 Intel processors running Apache and Unix. This database comprises 250 GB of data, with 115 tables and 7.7 million records.

The istockpro database comprises 500 GB and runs on six Intel processors. It supports 41 tables and 2.7 million records.

MySQL is such an integral part of our business, that it literally allows us to exist, says Lor. The fact that we can grow as quickly as we do is also attributable in large part to MySQL and the open source community.

courtsy: mysql

Face Book Open Source Technologies

dhiraj.patra@gmail.com (dhiraj patra) — Thu, 28 Oct 2010 00:11:49 PDT

Introduction

Facebook has been developed from the ground up using open source software. Developers building with Platform scale their own applications using many of the same infrastructure technologies that power Facebook.

Platform

Our Platform engineering team has released and maintains open source SDKs for Android, C#, iPhone, JavaScript, PHP, and Python.

Developer tools

codemod assists with large-scale codebase refactors that can be partially automated but still require human oversight and occasional intervention.

Facebook Animation is a JavaScript library for creating customizable animations using DOM and CSS manipulation.

flvtool++ is a tool for hinting and manipulating the metadata of FLV files. It was originally created for Facebook Video.

Online Schema Change for MySQL lets you alter large database tables without taking your cluster offline.

PHPEmbed makes embedding PHP truly simple for all of our developers (and indeed the world) we developed this PHPEmbed library which is just a more accessible and simplified API built on top of the PHP SAPI.

phpsh provides an interactive shell for PHP that features readline history, tab completion, and quick access to documentation. It is ironically written mostly in Python.

Three20 is an Objective-C library for iPhone developers which provides many UI elements and data helpers behind our iPhone application.

XHP is a PHP extension which augments the syntax of the language such that XML document fragments become valid expressions.

XHProf is a function-level hierarchical profiler for PHP with a simple HTML-based navigational interface.

Infrastructure

Apache Cassandra is a distributed storage system for managing structured data that is designed to scale to a very large size across many commodity servers, with no single point of failure.

Apache Hive is data warehouse infrastructure built on top of Hadoop that provides tools to enable easy data summarization, adhoc querying and analysis of large datasets.

FlashCache is a general purpose writeback block cache for Linux. It was developed as a loadable Linux kernel module, using the Device Mapper and sits below the filesystem.

HipHop for PHP transforms PHP source code into highly optimized C++. HipHop offers large performance gains and was developed over the past two years.

Scribe is a scalable service for aggregating log data streamed in real time from a large number of servers.

Thrift provides a framework for scalable cross-language services development in C++, Java, Python, PHP, and Ruby.

Tornado is a relatively simple, non-blocking web server framework written in Python. It is designed to handle thousands of simultaneous connections, making it ideal for real-time Web services.

Engineers contribute to

Apache Hadoop provides reliable, scalable, distributed computing infrastructure which we use for data analysis.

Cfengine is a rule-based configuration system that is used to automate the config and maintenance of servers. Facebook uses Cfengine to maintain host configs and to automate many janitorial operations on our production tiers.

memcached is a distributed memory object caching system. Memcached was not originally developed at Facebook, but we have become the largest user of the technology.

MySQL is the backbone of our database infrastructure. You can find our patches on Launchpad and learn more about how we use it on the MySQL@Facebook page.

PHP is an incredibly popular scripting language which makes up the majority of our code-base. Its simple syntax lets us move fast and iterate on products.

Varnish serves billions of requests every day to Facebook users around the world. Whenever you load photos and profile pictures of your friends, there's a very good chance that Varnish is involved.

Mirror

We host a public mirror for projects such as Apache, Centos, CPAN, Fedora, GNU, Mozilla, MySQL, and much more...

PHP for Android Project Launched

dhiraj.patra@gmail.com (dhiraj patra) — Tue, 07 Sep 2010 22:08:18 PDT

irontec have just launched an open source project to bring PHP to Android platform. PHP for Android project (PFA) aims to make PHP development in Android not only possible but also feasable providing tools and documentation. The project already have an APK which provides PHP support to Android Scripting Environment (ASE). To get started you can follow the screencast below :

APK and source code both available at http://phpforandroid.net. Minimum requirement to get PHP for Android running is Android 1.5 phone or emulator. There is even an unofficial ASE build with PHP 5.3 support included. Now Rasmus can get an Android phone and start scripting on mobile.

Think Different

Zend Framework 2.0.0beta1 Released

Build A Web 2.0 Voting Widget With Flex

Getting Flex Up and Running

Going to AMF

Flex Basics

Getting Flex Up and Running

Going to AMF

How To Optimize Websites

What Determines Website Page Speed?

1. Minimize the number of HTTP requests

2. Optimize and correctly display images

3. Minify HTML, CSS, and Javascript

4. Use a Content Delivery Network (CDN)

5. Gzip and compress components

6. Choose over @import

7. Put stylesheets at the top

8. Put scripts at the bottom

9. Utilize browser caching

10. Use CSS Sprites

Whew! Still reading?

Work smarter, not harder

Differences between PHP4 and PHP5

Usability of RIA with Flex

User Interface Design Principles

Principles applied: examples

Usability for Rich Internet Applications

What’s an RIA?

Challenge #1: Deciding How Much Richness to Add

Challenge #2: Interactive Page Elements

Challenge #3: Refreshing Part of the Page

Challenge #4: Breaking the Page Model

Review Usability Best Practices

1. Visibility of system status (Feedback)

2. Match between system and the real world (METAPHOR)

3. User control and freedom (NAVIGATION)

4. Consistency and standards (CONSISTENCY)

5. Error prevention (PREVENTION)

6. Recognition rather than recall (MEMORY)

7. Flexibility and efficiency of use (EFFICIENCY)

8. Aesthetic and minimalist design (DESIGN)

9. Help users recognize, diagnose, and recover from errors (RECOVERY)

10. Help and documentation (Help)

Interview with Dries Buytaert, Creator of Drupal By David Peterson | April 28, 2010 | Web Tech

Difference between Drupal and Joomla

The Survey

The Results

Drupal Users Love Drupal, Joomla Users Love Joomla

Drupal Better for Extensibility and Large Sites

Joomla Easier for the Non-Geeks

Which Web CMS is Better?

Benefits of PHP Programming in Custom Web Development

Tips for Learning Simple Php

Flash Builder for PHP 4.5.1 Gets iOS Support

PHP Frameworks

The expenditure of PHP web development decrease for PHP developers

PHP.Net: 5.3.7 Upgrade Warning

If PHP Were British

A Slap in the Face

Getting Started

Abbreviations

Eloquence

Spelling

Manners

Class

The Sun Never Sets ...

Thanks

The future of PHP

What is Unicode?

Facebook looks to speed up PHP

The internally-developed HipHop for PHP source code transformer is being offered via open source

Adobe, Zend combine Flash and PHP development

Flash Builder 4.5 for PHP helps developers build apps for Web, desktop, and mobile systems, including Apple's iOS devices. But you can use Eclipse with plug-in available along with Flex sdk to compile in Eclipse itself.

Cloud computing underwhelms PHP developers

Developers still see it as the future, but they think it is currently overhyped and vendor-driven

Google releases video chat source code

Google has released the code for WebRTC, a voice and video codec for the Web

Building Semantic Web CRUD operations using PHP

Prerequisites

Is This Web 3.0?

6. Choose over `@import`