Ganor's Blog

Getting Started with Facebook App Development

2012-01-19T05:31:00.000-08:00

Last week I was playing with Facebook App development, getting ready to the Facebook announcement. It was quite pleasant experience, although things could be simpler. The Facebook Open Graph concept gives a nice overview on what and why this all about, so that part went very smooth. When things get technical, the Facebook Developers site turns messy. That is, all topics are covered in a 'tutorial' approach rather than an API approach like most developers are used to. Moreover, the layout of this page is definitely not intuitive as it mixes between reference and tutorial docs. That's said, the general experience was good.

To help other developers get started with Facebook app development I created a nice application which take the reader through the steps to develop applications with phpcloud.com. It was a nice exercise and it can really help with the development workflow.

The topic "Getting Started with Your Facebook App on phpcloud.com" covers :

Create an account on phpcloud.com
Create an app on Facebook
Setting up development environment
Deploy a sample Facebook app to phpcloud.com
Push updates to your Facebook app

A (Big) Dot Release

2011-12-14T21:26:00.000-08:00

Although dot releases don't get as much attention as major releases , this one should definitely get highlighted:

      "Zend is pleased to announce the release of Zend Studio 9.0.1!"

This new release focuses on improving source code editing experience, improving editor performance, smart indentation when pasting code. It also extends the code formatter so PHP comments are well structured. Working with PHPUnit made easier with the addition of smart configuration (and bootstrap) detection. Community plugins updates provide advanced features with Git, ZenCoding and Symfony2.

The changes include:

Improved editor performance for multi-line statements and auto indentation scenarios
Adjust indentation when pasting code
New code formatter rules for PHP Comments
Disable/Enable Code formatter with special @formatter:off/on tags
Git history graph
PHPUnit auto-detection of configuration (and bootstrap) file
Improved PHP Class creation for namespace code generation
Easy installation of community plugins ZenCoding and Symfony2 and Twig
Various bug fixes

Rewrite Rulez!!!

2011-12-05T23:43:00.001-08:00

While common Web frameworks provide a set of mod_rewrite rules in their default application, it is left to the developer to align these rules according to the Apache host configuration. For example if you use an alias when setting up a Symfony application then a RewriteBase directive must be added to the application rules. This is a common change that is required to keep the original list (provided by the framework) as is.

To this end a post-deployment action can be added to fix the RewriteBase directive in the '.htaccess' file. In a previous post, application deployment scripts were used to help chmod application's resources. This time I am going to use deployment hooks to modify the RewriteBase directive automatically after deploying the Symfony2Cloud application.

In the deployment script you can find this code:

<?
// get application location
$appLocation = getenv('ZS_APPLICATION_BASE_DIR');

// modify htaccess
$htaccess_file = $appLocation . '/web/.htaccess';
$explode = explode ( '/', $appLocation );
$appname = $explode [sizeof ( $explode ) - 2];

$content = file_get_contents ( $htaccess_file );
$content = str_replace ( '<application-name>', $appname, $content );
file_put_contents ( $htaccess_file, $content );
view raw            post_stage.phpThis Gist brought to you by GitHub.

In details: The application location is used to resolve its alias. Then the alias name is used to replace the .htaccess file content so instead of "RewriteBase /<application-name>

it will show up as "RewriteBase /Symfony2Cloud".

Assuming that you use Zend SDK and the following deploy command:

zend deploy application -r git://github.com/ganoro/Symfony2Cloud.git

Symfony2Cloud is now deployed and ready to use with this .htaccess:


<IfModule mod_rewrite.c>
 RewriteBase /Symfony2Cloud

    RewriteEngine On
    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteRule ^(.*)$ app_dev.php [QSA,L]
</IfModule>

Github to Zend Developer Cloud - the fast way!

2011-11-30T06:24:00.001-08:00

In previous posts I discussed several methods of building Web applications using Zend Developer Cloud and github, mainly with tools like Eclipse and Zend Studio. This time, I will show off with a new feature in Zend SDK v0.0.22 (and up) presented by Wojtek Galanciak.

With this feature only one command line is required to deploy applications from github to Zend Developer Cloud. Here is a simple example:

zend deploy application -r git://github.com/ganoro/Symfony2Cloud.git -t 0

"Symfony2Cloud" repository is hosted in my github account. Target id 0 is my Zend Developer Cloud container. This command makes sure that the applications is deployed into my Zend Developer Cloud container. As simple as that...

Read more about this command and similar use cases with the new Zend SDK. Release notes are available here.

In my next posts I am going to explain about the new repository management tools, so stay tuned.

chmod() your phpCloud Web Apps

2011-11-27T05:04:00.001-08:00

A common feedback from developers using Web Apps on Zend Developer Cloud is the ability to chmod() directories for deployed applications. For example in Joan Ging's post you can notice that one needs to use external tools (like WinSCP or Zend Studio) to chmod the logs and cache directories that are used by Symfony2, otherwise these directories are write-protected and the application fails to launch.

There are two methods to chmod application directories after the deployment stage and before launching.
So let's review the two alternatives, both of them result in the same state:

Using Deployment Scripts (during deployment phases).
Using Zend Studio (after the application is deployed)

Using Deployment Scripts

One of the new features in phpCloud is the ability to deliver hook scripts alongside the application. There are several types of scripts for each phase in the deployment process (i.e, Staging, Activation).
In the following example, chmod is executed on both logs and cache directories immediately after being executed on their parents.
First we define the "scripts" directory to contain all deployment triggers. This is done as part of the deployment descriptor file (named deployment.xml):

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<package xmlns="http://www.zend.com/server/deployment-descriptor/1.0" version="1.0">
    <name>Symfony2Cloud</name>
    <version>
        <release>1.0.0</release>
    </version>
    <appdir>data</appdir>
    <docroot>data/web</docroot>
    <scriptsdir>scripts</scriptsdir>
</package>

view raw            deployment.xmlThis Gist brought to you by GitHub.

Then we create a post_stage.php file under this directory with this content:

<?php
/* @var string holds the application (absolute) path */
$appLocation = getenv('ZS_APPLICATION_BASE_DIR');
/* chmod cache and logs */
chmod ( $appLocation, 0775 );
chmod ( $appLocation . '/app/',0775 );
chmod  $appLocation . '/app/cache/', 0775 );
chmod ( $appLocation . '/app/logs/', 0775 );
view raw post_stage.php    This Gist brought to you by GitHub.      

The complete source code for this application is available in the Synfony2Cloud project on Github.

Using Zend Studio 9.0

Once you deploy your application in Zend Studio, a connection to your container is created under the hood. You can view this connection and modify the directories permissions in the Remote System view.

1. Start by showing (or "unhiding") hidden files. This allows you to browse the ".app" directory which holds all deployed applications.
Go to Preferences > Remote Systems > Files and make sure "Show hidden files" is marked.

2. Browse to the application you want to chmod() by expanding the file tree in the Remote Systems view

3. Right click on the directory and select Properties.
4. Select the Permissions node, alter the permissions you want to allow and click Apply.

Although Alternative #2 is more flexible, I highly recommend Alternative #1 which streamlines the deployment phase and lets you adjust the code and create an automate deployment process.

What is coming up from Zend?

2011-11-02T08:18:00.000-07:00

If you have already heard about phpcloud.com and Zend Studio 9 or just trying to grasp what new developer workflows Zend is now offering, you may find the new tutorials that the Zend documentation team have put together quite useful. These tutorials take you through end to end real world scenarios and outline what can be achieved with the new tools and platform. These tutorials include:

Building Applications on the Zend Developer Cloud (link)

To create GitHub and Zend Developer Cloud accounts. These will be used to maintain a project in GitHub and to deploy on Zend's cloud platform. Github is just an example, you could use other version control system such as Git, Subversion, CVS, Mercurial.
To create a new container in the Zend Developer Cloud. The container holds your application in the cloud.
To create a new project from GitHub. You will be using an existing GitHub project to create a new project in Zend Studio.
To launch the application on the Zend Developer Cloud and debug it using Zend Studio.

A Guided Tour of Zend Application Deployment Support (link)

To create a new project from GitHub in Zend Studio: You will be provided with an existing GitHub account and project.
To work with your project's deployment.xml file: Launching a project in Zend Studio with deployment support creates a deployment.xml file. This file enables you to customize your application before the packaging process.
To create a ZPK package: Packaging your application enables you to export it to other members of the working process for testing and evaluation.

Deploying Applications to Zend Server (link)

To create an API Key. The API Key allows Zend Studio to access your server.
To create a new PHP project from SVN in Zend Studio. You will be provided with an existing SVN account and project.
To deploy your project on a remote Zend Server.
To launch your application. After creating your application, Zend Studio enables you to run your application from within the IDE and in an internal browser

Running Applications on a Local Zend Server (link)

To create a new Zend Framework project under the local server document root.
To debug your application and modify code.
To launch your application.

Customizing Zend Studio (link)

To customize Zend Studio by adding and removing the plugins you want to work with. The Welcome page includes a list of available plugins, which you can add or remove from your Zend Studio.
To register Zend Studio. Once Zend Studio is installed, all its features will be available for a 30 day trial. To enable full features after this period of time, you will need to register the product.

Eclipse Continues to Support PHP and Zend Developer Cloud

2011-10-27T15:56:00.000-07:00

The last two weeks were a-m-a-z-i-n-g! We released two major pieces that can turn Web development as easy and obvious as writing this hello world application. This time I would like to present additional important piece that the Zend team provide today to enable PHP and Web development (special thanks to @nataliabartol). Welcome the 'Eclipse-based package by Zend'. This package includes the Eclipse Platform latest release (version 3.7.1, code name Indigo-SR1), the Web Tools Source Editing plugin, the PDT plugin (latest version) and the Zend SDK plugin (this plugin enables Zend Developer Cloud). You can find the package and more information about this release here. The size of this package is ~90Mb (depending on your operating system) and users need to extract the package to run the product.

Zend is the provider of Zend Studio 9.0 and lead the Eclipse PHP Development Tools (PDT) project as well as the Zend SDK project. This Eclipse-based product will mainly be useful for developers working with PHP and their workflow includes tasks such as PHP/HTML/Javascript/CSS sources editing, debugging and deployment of Web applications.

The following two minutes demo shows a simple create-deploy-debug cycle enabled by this package:

My team will definitely consider leveraging the Zend SDK to work with more solutions available in the market providing Integrated Development Environment (IDE) for PHP Developers such as Netbeans and phpStorm, stay tuned!

If you have any questions or comments, feel free to comment below.

Pull Down an Application Created on phpCloud

2011-10-25T06:10:00.000-07:00

One of the most promising features in Zend Developer Cloud will be to deploy today's most-famous Web applications directly into your container, without being required to supply the application package. The list of pre-packed applications includes projects like Drupal, Joomla, Magento, Wordpress and a customized Zend Framework. Probably Zend will add more applications in the future (want to suggest one?)

The obvious question is, what will be the best practice for working with an already deployed application and how to pull it down to your development environment?

As a background there are two ways for managing an already deployed project, you can select either of the following options depending on your high level development workflows and your tools (ahch, ahch, Zend Studio supports both of them). One important note that is applied for both solutions - you don't need to deploy the project once again. Just modify the content and make sure it's updated properly in the cloud.

Clone Application via Git Repository

One of the Easter Eggs hidden in this already-packed deployment feature is that once an application is deployed, a git repository is created so developers can clone it and later on push their content. Use a command line tool or any development environment to clone the application. Then use push to upstream git action to update the actual remote application.

To retrieve the application Git Repository, go to you container overview page:
https://my.phpcloud.com/container/<container-name>/overview and push the "git access" button. Use your container name and password as username and password when you make any operation with this repository.

This Git repository authentication is based on secured HTTP with the following details:

URI: the path provided by Zend Developer cloud (see above)
User: container name
Password: container password

Using Zend SDK:

You can use the latest Zend SDK to clone the code to your machine by running the git clone command with your git repository parameters:

zend clone project -r <git-repository-url> -u <user> -p <password>

Using Zend Studio 9.0:
We are about to use a new feature added to Zend Studio in its latest release that enables you to clone a Git repository, start by File | New | PHP Project from Git. A wizard will show up and you will need to enter the information required for this clone operation to happen.

Follow the wizard and hit "Finish". Once your project is cloned, you can start a debug session right-clicking on the index.php file and selecting "Debug as...", supply the full URL of the application and press OK.

Don't forget to open the SSH Tunnel by right-clicking on its node that available in the Targets view and selecting "Open SSH Tunnel"

Download Application via SFTP Client

The trivial way is to use an integrated SFTP client that supports download and upload actions to the SFTP server installed on your container. Remember the following:

Authentication to the SFTP is made using the private key given the time you created the container or user. So you will need to add it to the private keys manager (in Zend Studio / Eclipse it's under Preferences > General > Network Connections > SSH2. In the General Tab, add the private key file to the text field named: "Private Keys". You don't have to specify a username and password as you use the private key.
The application content is located under the directory named .apps/http/__default__/0/<user-name>/1.0.0

Hope this tutorial helps you to configure your development environment and you take advantage of it, but if you think there is a different (better) way don't hesitate to comment below.

Test Drive Zend Developer Cloud with Zend Studio 9

2011-10-22T15:04:00.000-07:00

Zend Studio and the Zend Developer Cloud support an integration environment for projects hosted in GitHub. This allows you use the cloud to deploy, debug and modify your Web applications hosted in GitHub from Zend Studio.

This workflow includes the following tasks:

Creating accounts for GitHub and the Zend Developer Cloud
Developing a project hosted in Github with Zend Studio and the Zend Developer Cloud
Debugging your application
Automatically updating your application in real time

Prerequisites

An installed Zend Studio 9.0 (currently on beta) or above. Can be found in one of these pages:

Zend Studio 9 Beta page
Zend Studio product page

Creating an Account for Github and the Zend Developer Cloud

In order to use GitHub and the Zend Developer Cloud, you must first set up valid accounts for both.
To create a GitHub account:

Open the GitHub website at https://github.com/.
Click Plans, Pricing and Signup in the center of the welcome page. The Plans and Pricing page appears. Click Create a free account. The Signup for GitHub page appears.
Enter your account details in the requested fields, and click Create an account. Your new account page appears.
Follow the instructions on the Github homepage and create a project and repository.
For more information on creating a GitHub project go to help.github.com

To create a Zend Developer Cloud account:

Open the Zend Developer Cloud website at http://www.phpcloud.com/.
Click Login here in the top-right corner of the homepage.
Click I do not have an account. The Create a new account page appears.
Enter your account details in the requested fields, and click Register.The Thank you for creating a Zend account page appears.
Please answer the questions that appear on the page and click Finish.The Log In page appears.
Enter your account details, and click Log In.The Zend Developer Cloud welcome appears.
Click Start now to begin working!Save your Zend Developer Cloud credentials as you will need them later in this workflow.

Working with a Project hosted in Github with Zend Studio and the Zend Developer Cloud

Once you have an existing GitHub and Zend Developer Cloud account, you can use the integration features embedded in Zend Studio and Zend Developer Cloud. You can develop, test and deploy a GitHub application on the cloud through Zend Studio.To create a new container:

Go to the Zend Developer Cloud homepage and open your account and click Start Now on the welcome page.The Create Container page appears.
Enter the container name and password in the relevant fields, and click Create Container. The SSH Keypair created window appears.
Click Download private key in PEM format.Save the key on your machine as you will need to browse to it when connecting Zend Studio to your server. Your container has been created and will appear under My Containers on the homepage.

Installing the GitHub Plugin into Zend Studio

Zend Studio gives you the option to use only the plugins you need. For this tutorial, you will need GitHub.

Go to Help | Welcome to open the Zend Studio Welcome screen.
From the plugin list on the right, mark the Git and GitHub.
When prompted, restart Zend Studio .When you re-open Zend Studio, the GitHub plugin is installed.

Creating a GitHub Project in Zend Studio

To create a GitHub application in Zend Studio:

Go to File | New |PHP Project from GitHub.The Create Project from GitHub dialog appears.
Enter the project name and your GitHub authentication details in the relevant fields, and click Refresh.Your application location will appear in the Location box or in the dropdown menu.
Click Next to move to the Application Deployment dialog.
Select Zend Application Deployment and create a new target by clicking on the PHPCloud icon . The Add Target dialog box appears
Enter your Zend.com credentials and browse to your PEM key in the relevant fields, and click Test Connection.
If no errors appear, click Finish. The Application Deployment section reappears with the target you added.
Make sure the ‘Add Application Deployment Support’ checkbox is marked
Click Finish.Your application will opens in the Zend Studio workspace.

Deploying Your Application on the Zend Developer Cloud

Open your project in Zend Studio.The default file, deployment.xml, opens.

In the Testing area, click Launch a PHP ApplicationThe Launch PHP Application dialog opens with the default container you defined during the project creation selected, and your application’s URL
Click Finish and Yes when prompted about your container’s authenticity
Your application appears in your container’s page in the Zend Developer Cloud website, and opens in Zend Studio’s internal browser. Keep the internal browser with your application open as you will need it to automatically update the application.

Debugging Your Application on the Zend Developer Cloud

Open your project in Zend Studio.The default file, deployment.xml, opens.
In the Testing area, click Launch a PHP Application in Debug Mode
Your application now appears in the Debug perspective and stops at the first breakpoint.To continue the debug click .

Automatically Updating Your Deployed Project in Real Time

Zend Studio allows you to automatically update any changes you make in the source code of your application without redeploying the application from the start. Each change you make in the code will be automatically updated in your application on the server.
To automatically update your application:

In the PHP Explorer view, open your projects index.phptml file by going to application| views| scripts | index| index.phptml.The index.phptml file opens in the text editor.
Make a small textual change in the code and save the project.
Go to the internal browser of your project and click the Refresh icon .Your application updates with the changes applied.

Note: this article describes the workflow as available today for phpcloud developers. I am not sure if this will be the case in next versions, so you should get updated with the php cloud release notes. It was written by the documentation team at Zend, if you have any comment feel free to post it below.

First API released for phpcloud.com

2011-10-18T13:00:00.000-07:00

In previous post, I presented the Zend Developer Cloud Platform and some thoughts about it. It's time for me to show some pretty cool API we added for developers who want to exploit all the goodies from it. In a nutshell, the Zend Developer Cloud API enables you to authenticate, list your containers details and get a very nice information about your requests, and of course to start debugging of specific events occurred lately.

The first implementation using this API is the Zend Developer Cloud sniffer that "integrates into the PHP runtime and watches for various events such as errors, failing functions, slow scripts and database errors. This allows you to debug your application during development, helping you create a better application.". And the first implementation of this API is available under EPL at the Zend SDK source code In more details the following API is available:

```
authenticate(u, p, _success, _error)
```
Authenticate to the Zend Developer Cloud service given the username and password. Once authentication is validated, a session id is retrieved and assigned as cookie
```
list(_success, _error)
```
Lists all containers for the signed in user
```
requestSummary(containerName, requestUid, _success, _error)
```
Retrieve information about a particular request's events and code tracing. The requestUid identifier is provided in a cookie that is set in the response to the particular request.
```
downloadAmf(containerName, amf, _success, _error)
```
Download the amf file specified by codetracing identifier

startDebug(containerName, issueId, eventGroupId, _success, _error)

Start a debug session for specific issue

Better Together - Github and Zend Developer Cloud

2011-10-18T09:40:00.000-07:00

The two Cloud-based services Zend Developer Cloud and GitHub share some common traits. Although these services are loosely coupled, developers using one service can easily find interest in the other. For example the openness of the services to application developers world, the (so important) social dimension and the fact that it is just easy to use through a set of APIs and tools, make these two services fun to work with... together.

It takes four command lines to see the value (you will need to install Zend SDK first):

# clone an example 'hello tweet' project from a github repository
$ zend clone project -r git://github.com/zendcon/hellotweet.git

# define a Developer Cloud container to host your application
$ zend add target -d account-name:account-password

# set working directory
$ cd  hellotweet

# deploy the newly created application to the defined target
$ zend deploy application

The result is available as a ready to use Web application http://royganor.my.phpcloud.com/zendcon/ and since I made the container public anyone can create the same container through http://my.phpcloud.com/container/create/snapshot/royganor-snapshot-20111018054539

But there are more similarities, let's review some of them:

Identities are open and visible between developers

Applications and repositories are listed:

Social activities are available for developers who want/need continuous and fast feedback

If you are interested in more information about specific aspect of the solution, share it here and I will answer you.

Zend Launches Developer Cloud & SDK To Give Developers Access to Web Applications Market

2011-10-18T08:43:00.000-07:00

Zend, The PHP company and the place I work for the past 5 years has made some significant steps over the last year to enable Web developers to deliver scalable Web applications. As part of our strategy Zend has been full-steam ahead on creating better ways for Web developers to make application deployed on a self-served container which can be scaled up and down which have been traditionally difficult areas for PHP developers to execute effectively.

In May the Zend Server team has published a major update to the product with the ability to create application packages that consist of source code, metadata and scripts, and of course deploy applications on any number of servers. At about the same time, my team has worked to deliver tools supporting these capabilities.

Today, Zend is adding the remaining piece, again utilizing its current product line. The company today announced that it is releasing the Zend Developer Cloud and a software development kit (SDK) called Zend SDK to enable Web developer build their applications on a robust platform in a very short time. This is of interest for the very reason that this service is given for free by Zend.

When it comes to entering the PHP applications market like Wordpress, Drupal, Magento, Zend Framework apps, developers are met with a number of obstacles, including environment requirements and unstructured development tools. The advantage then, of Zend′s new platform and SDK is that now developers have streamlined workflows to develop their applications.

To demonstrate how easy it is to create Web applications with the new tools, I created a GitHub repository for a #zendcon tweeter channel https://github.com/zendcon/hellotweet and made it available on my container at http://royganor.my.phpcloud.com/zendcon/ in about a couple of minutes.

Stay tune for more posts and information about this news.

Zend Studio 9 Early Access build #262 now available

2011-09-28T07:58:00.000-07:00

In a previous post I demoed how Zend Studio 9 is going to make Web application development much easier and faster.I am pleased to announce that the Early Access (build #262) is now available so early adopters can put their hands on and tell us about their experience with the new product.

Feel free to post your feedback here or in Zend Studio forum.

For Windows (212 Mb)
For Windows without JRE (182Mb)
For Mac (172Mb)
For Linux 32-bit (173Mb)
For Linux 64-bit (176Mb)

Agile Web Applications Development with Eclipse Indigo and Zend Studio 9 Early Access

2011-09-27T08:18:00.000-07:00

It's been a couple of weeks now since the release of Eclipse Indigo and other Application Servers IDEs based on it. Now, it's time for the Eclipse PDT and Zend Studio team to refresh their products with great features that lots of Web developers will find useful such as Github support, Application deployment support, better formatting and source editing tools for PHP and JS developers.

In this short screen cast you will find a quick review of the features available for the developers working with it.

Stay tune and wait for the official release which is going to happen soon.

"git clone" and "application deploy" - Perfect Match

2011-09-14T06:05:00.000-07:00

It's amazing, you work on a pretty cool project for a couple of months now and you find out that little has been posted about it.
So here it is... meet Zend SDK. There are many interesting ideas behind this SDK but in this post I am going to focus on how to get started with it.

So... what is Zend SDK?

If you build a Web Application or even a CMS Web site in PHP you probably have asked yourself a couple of times what best practices should I use to develop, publish and discover applications written in PHP. Amazingly, in most modern platforms like Java, Ruby, Flash, Android and iOS it is common to find a dominant set of tools and workflows to streamline development processes. Things like creating application resources, deploying applications, configuring application hosts and even creating a repository of applications that allows others to discover it. However for several reasons PHP developers don't have one way to do such things, just as an example take a look at the famous PHP applications, frameworks and CMSs solutions in the market. This is exactly where the SDK is aiming.

Zend SDK includes a variety of tools that help you create, develop, publish and discover PHP Web applications.

Hence, you can find command line tool, Eclipse plugin, Hudson/Jenkins, Phing, Ant and other tools in our target environments.

Step 1: Clone your application from a Git repository

First thing first, you will need to fetch the application source code and prepare it for the target environment, to do so you can use the "clone project" command line. With this command a project from a git repository is cloned to your local machine and additional deployment descriptor resource is added that will assist you with hosting this application on targets.

zend clone project -r https://ganoro@github.com/ganoro/ExampleProject.git

Alternatively you can create a local empty project based on the MVC of Zend Framework by clicking

zend create project -n helloworld

If you have already fetched your project (with SVN, CVS or other source control version) you can just update the project with the files required to help you with the deployment process:

zend update project -d

for more information on project management, read this wiki page which goes over the alternatives and provides extra details about the possible arguments of these commands. If you haven't installed the SDK go to this page

Step 2: Add a remote target

This is the easy part, you will need a target that will host your applications. I assume you installed Zend Server 5.5 and it is accessible by your machine. If not, you will need to install it either locally or on a remote machine.

For example adding a remote target with address 10.1.2.34 with a given secret key is possible by

zend add target -h http://10.1.2.34 -k sdk.roy -s cc14b445ad6ed9041d936b7f363a8e5a525275d3960dbb373f35e97e2abcdab2

This command line will add a new target to the list with the specified API key, for more details on API keys see this page. After installing this target you can use the list target and list applications to see the results:

Example output for a listing command is (read more on targets management here):

royganor@ubuntu:~$ zend list targets -s
Available Zend Targets:
id: 0
	Host: https://10.1.2.34
	Key: Zend 	Status: connected

Step 3: Deploy your application

Now that your application is ready and your target is configured properly, we can go directly to the fun part. deploying you application to the host.

royganor@ubuntu:~$ zend deploy application

Step 4: Test it!
Now you are ready to see if the application deployed successfully by running a stats command or just going to the browser and address the application URL.

royganor@ubuntu:~$ zend list applications
Id:                     67
Application Name:       drupal
User Application Name:  http://default-server/ExampleProject
Base URL:               http:///ExampleProject
Installed Location:     /home/royganor/.apps/http/__default__/0/ExampleProject/1.0.0
Status:                 deployed
Servers:
	id:               0
	Deployed Version: 1.0.0
	Status:           deployed
Deployed Versions:	1.0.0

Step 5: What's next?
In next posts more interesting aspects of the SDK will be covered like creating repositories and publishing your applications to others.As usual if you want to. Till next time, I will really appreciate your feedback on Zend SDK

Windows Registry API for Windows (plus 64-bit)

2011-05-21T13:42:00.000-07:00

Lately I was required to provide a solution that needs access to the Windows Registry Keys. I could easily use the command line tools for this end (reg export or something like this). For some reason I found several glitches with this method, mainly around performance and parsing incompatibilities. So I decided to use this library JNIRegistry - "Windows Registry API Native Interface" (http://www.trustice.com/java/jnireg/index.shtml).

Problem is that it is only compatible with 32 bit and if you are under 64 bit Java, it won't be any good for you. So I had to compile this JNIRegistry library for 64bit. I used Visual Studio 2010 with the Microsoft SDKs 7.1 to compile it with x86_64 compiler. It was a damn nice adventure...

So if you get this error message "ICE_JNIRegistry.dll: Can't load IA 32-bit .dll on a AMD 64-bit platform" you should probably use the second one here:

1. ICE_JNIRegistry.dll for 32 bit

2. ICE_JNIRegistry for 64bit

3. The JNIRegistry library jar

Enjoy ;)

EDIT: one thing I found while using this library under 64bit. you will need to add the "WOW6432node" child if you look for a software-type key. See this article from MS http://support.microsoft.com/kb/896459.

Project Planning Thoughts on Flash Builder for PHP 4.5

2011-05-03T00:09:00.000-07:00

Wow! it was a real pleasure to take part in and lead the release of Adobe Flash Builder for PHP product. FBPHP is actually an Eclipse-based product that includes both Flash Builder and Zend Studio components and supports the development process of Web and Mobile applications that require server/client communication. It can be a real time saver for startups and large scale companies as it streamlines the process of designers, interactive designers and server side developers in a joint product by Adobe and Zend.

The following two tutorials provide a great overview of how much this product is useful and fun:

Web Application Development - http://goo.gl/EOw2d
Mobile Application Development - http://goo.gl/fRkDt

I would like to give a quick glance on what was required and achieved during the last 4 months, the team obstacles and some tasks repository analysis.

Project Goals

Provide an integrated solution to speed the development of Flex and PHP applications for the web or for mobile
Lower the barrier to entry for getting set up to use Flash Builder and Zend Studio together via an easy installation process
Streamline the process for creating Flex and PHP projects that are related to one another
Improve the data connectivity workflow for connecting Flex apps to PHP services
Enable developers to debug client-side Flex code and server-side PHP code simultaneously
Meet a tight schedule and integration deadlines for both Adobe Flash Builder and Zend Studio teams.

Quality

Features tested – Installation, Serialization, Flex Web/PHP Applications incl. run/debug, Flex Mobile/PHP Application incl. run/debug, Introspection, Remote PHP Server Support, Zend Studio regression
Platforms tested – Windows 7 32/64 bit , Vista 32/64 bit , Windows XP SP3 , MAC OSX 10.6
PHP Servers tested – Zend Server v5.1, MAMP and XAMP
Browsers tested – Firefox , Internet Explorer , Safari, Chrome
Devices tested – Motorola Droid 2, Samsung Galaxy S

Bug Repository Analysis

Powered by 6 developers and 4 quality engineers this project had an overall of 700 issues in the system including tasks, sub tasks, bugs, features and improvements. We had to go through a triage and privatization process on a daily basis and create a weekly process which enables short DEV2QA cycles. The result (below) shows that we had an intense two months of development and 2 months of quality work until we actually started the release cycle that took about a month. The release cycle gave us the ability to stabilize our product quality and make sure we have no misunderstanding with the integration level with Adobe and with the product managers of the product.

Pre-release Advisory Team

177 registered participants, 10-12 very active forum-posters.
> 400 posts to prerelease forums.
> 25 good quality bugs logged.
Most issues either fixed or had a workaround and a few enhancements suggested for future releases

Takeaways

Write your requirements and invest time in polishing and updating the docs - it's not a waste of time. It can take a month and people can start building the building blocks, but to have the solution ready on time you must have a document that represents what you are going to implement from beginning to the end.
Plan a one month quality term, this will significantly improve your predication to deliver a high-quality product. It will not reduce the stress around release cycle but it will reduce the risk in hitting the final date. During this month, developers are not allowed to contribute code to the project unless there is a specific requirement for that.
Our advisory team was very helpful, it is more than important to be responsive and just listen to what they are saying. You are not smarter than they are.
Create a positive spirit in the team and set goals that makes sense to all people.

Thanks to Adobe Flash Builder teams that was very communicative and helpful and showed us the way when integration failed.

Easter Egg for Zend/PHP Developers

2011-03-13T09:09:00.000-07:00

One among many new interesting Zend Server 5.1 features is an open "RESTful Web API that allows automation of the management and deployment of Zend Server and Zend Server Cluster Manager, and integration with other Zend or 3rd party software". It basically provides an easy way to control your deployment of Web Servers remotely and set it up correctly for your application when you scale up and down. For example one can remotely configure new Web application server, reset or even build a fully functional cluster by utilizing this new open API.

Since most of the configuration and deployment tools these days have a Java-based plugins mechanism (such as Jenkins / Eclipse) I thought it would be cool if there will be a way to extend these tools with some of the new Web API features. I am proud to introduce Zend WebAPI project that is hosted in Google Code. Zend Web API SDK for Java provides a Java API for Zend Server infrastructure services, making it even easier for developers to build applications that tap into the scalable, and reliable Zend Server product.

You can find a getting started page that explains how to work with this library. This tutorial is based on the following steps:
1. Signing up for Zend Web API Services
2. Getting your Zend Web API Security Credentials
3. View Your Zend Web API Security Credentials
4. Using the Zend Web API SDK for Java
5. To run a sample you can use this code:

/**
 * Create the credential object
 */
WebApiCredentials credentials = new BasicCredentials(KEY_NAME, SECRET_KEY);

/**
 * Creates the Web API client object
 */
final WebApiClient webApiClient = new WebApiClient(credentials, HOST);

/**
 * Retrieve system info
 */
SystemInfo systemInfo = webApiClient.getSystemInfo();

/**
 * Print license info from retrieved system info
 */
System.out.println("License order number:" + systemInfo.getLicenseInfo().getOrderNumber());

I am really anxious to see what tools we will built on top of these open API that can make a difference in the world of high availability demand from the market.

Thanks to Shahar Evron (@shevron) who has guided me through the API aspects!

If you find this useful I would be happy to get some feedback and even new contribution!

As an example for utilizing this library I created an Eclipse plugin that is used as a "remote controller" for your Zend Server

Public/Private Key Encryption with Java and PHP

2011-02-08T05:57:00.000-08:00

Lately, I was struggling with the differences between PHP and Java HMAC encryption methods. Although encryption is rarely used in my most day to day programming tasks, it can probably be useful for people who may need it in the future.

In specific HMAC-SHA256 is used "for calculating a message authentication code (MAC) involving a cryptographic hash function in combination with a secret key". An interesting scenario is that a service that is hosted in a PHP Web application Server interacts with a Java client application client that consumes this service (for example Android mobile application). Since the client knows its private key it can encrypt an agreed message so the server then can verify with the given encrypted signature and authenticate the client.

Enough with talking, let's see how it is done in Java vs. PHP with the following code snippets:


/**
 * Encryption of a given text using the provided secretKey
 * 
 * @param text
 * @param secretKey
 * @return the encoded string
 * @throws SignatureException
 */
public static String hashMac(String text, String secretKey)
  throws SignatureException {

 try {
  Key sk = new SecretKeySpec(secretKey.getBytes(), HASH_ALGORITHM);
  Mac mac = Mac.getInstance(sk.getAlgorithm());
  mac.init(sk);
  final byte[] hmac = mac.doFinal(text.getBytes());
  return toHexString(hmac);
 } catch (NoSuchAlgorithmException e1) {
  // throw an exception or pick a different encryption method
  throw new SignatureException(
    "error building signature, no such algorithm in device "
      + HASH_ALGORITHM);
 } catch (InvalidKeyException e) {
  throw new SignatureException(
    "error building signature, invalid key " + HASH_ALGORITHM);
 }
}

where HASH_ALGORITHM is defined as


private static final String HASH_ALGORITHM = "HmacSHA256";

Where in PHP, it's even simpler:


echo hash_hmac('sha256', $message, $secretKey, false);

Eclipse PDT and Zend Studio Awarded 'Best PHP IDE' in InfoWorld 2011 Technology of the Year Awards

2011-01-12T03:40:00.000-08:00

What is common to Apple iPad, Google Android, VMWare vSphere and Eclipse PDT/Zend Studio?

I have some good news for the Eclipse PDT and Zend Studio team. The InfoWorld Test Center has chosen our tools, Eclipse PHP Development Tools and Zend Studio for one of our 2011 Technology of the Year Awards (Best PHP IDE). The award is based on the ,
comparative review by Rick Grehan.

According to InfoWorld their Technology of the Year Awards, chosen annually by InfoWorld reviewers, go to the best products we tested during the prior calendar year. To be eligible to win, the product has to be reviewed by the InfoWorld Test Center, it has to be outstanding, and it has to belong to a product category that we consider extremely important. In short, Technology of the Year Award winners are rare and special.

On behalf of Eclipse and Zend, we are honored to receive this award as a confirmation of our technology vision and dedication to building the best possible IDE for the PHP community we are committed to the evolution of Eclipse PDT as more and more developers seek to add PHP to their skill set for application development in Web environment.

Congratulation to the team!

New 10 Top Zend Studio 8.0 Features (applies mostly to Eclipse PDT 2.2.1)

2010-11-02T12:06:00.000-07:00

After one and a half years of community development and Zend internal hard work, Zend Studio 8.0 is officially released today after 3 months in beta!

During the beta term I tweeted about the new features and I wanted to aggregate everything to one blog so you can all review it in one place.

New Analyze Network Usage and Performance with Zend Studio 8.0 http://yfrog.com/3dc06xp #zendcon Top Studio new features #1
New Running #php Applications on VMWare Workstation through Zend Studio 8.0 http://yfrog.com/69z0tp Top Studio new features #2
New remote server support (ftp/ssh) http://bit.ly/9ei3hf Top Zend Studio new features #3
New #phpunit configuration files support http://bit.ly/aN2w3e Studio new features #4
New jQuery Support http://yfrog.com/7f1jap Top Studio new features #5
New native installers http://yfrog.com/5i4itp Top Studio new features #6
New content assist with templates http://yfrog.com/0r5j9p Top Studio new features #7
New hover information box http://yfrog.com/6x26763202p - Top Studio new features #8
New "Inspect" action in #php editor http://yfrog.com/5j3sssp - Top Studio new features #9
Enhancements for Windows 7 http://yfrog.com/mlxu3p (thanks #mylyn) - Top Studio new features #10

I'll probably have another post about the guys at Zend and community that helped with this release, so stay tuned if you want to hear about the team.

Five (more) tips for speeding up Eclipse PDT

2010-09-07T12:53:00.000-07:00

In a previous blog post written by Zviki Cohen, five simple tips were suggested to help Eclipse PHP Development Tools (PDT) users speeding up their development environment . I want to share five more tricks that can dramatically improve your experience with Eclipse and PDT. Not only these tips help speeding up performance but also make your PHP source code more controlled.

1. Exclude non-source-code folders and manage wisely your project buildpath - Buildpath is a set of paths indicating what folders should be scanned (built) by Eclipse. If the project Buildpath includes its root (for example) then all folders that include images, javascript , style sheets and other non-source related files are listed to the scanner. Although theoretically most of these files are not actually scanned since non-PHP content types files are skipped, Eclipse keeps track on changes and make some redundant operations on these folders that may contain thousands of irrelevant files, hence perform bad .

2. Setup project include path - to optimize the include/require statements path resolving it is more than useful to make sure that the project include path settings are set correctly. Representing the actual include path is a key to make things work smoothly.

3. External libraries are not part of your code, don't keep it under your project resources - this is a classic project configuration mistake. Make sure that frameworks and external libraries are not included under your project sources, instead link it to your project as a library. Eclipse can relate to these ("static"/"read-only") frameworks differently than your ("dynamic"/"writeable") code which is under constant development. Frameworks should be scanned once and not be part of your project source code.

4. Split your project into sub-projects and modules - it makes sense you separate your core business, services, client side interface, tests and other modules into different projects that have different natures and make the components more flexible and easy to be re-used and maintained by others. Often, I see PHP projects that include dozens of thousands of flat hierarchy source code that is hard to maintain and configure.

5. Share your project configuration files with your team. Configure your project once and make sure all team members follow the same conventions and management rules. These files are located under your project root (the dot files) and can be shared in your source code repository.

To summarize things "Mastering your development environment is as important as mastering your source code" - this concept is sometimes forgotten by scripting language developer who are used to a flat hierarchy source code. Although I consider this as a major strength of scripting languages it doesn't mean that project management should be flat...

How do you like to "use" it?

2010-05-12T14:09:00.000-07:00

According to the PHP.net manual "PHP namespaces support two kinds of aliasing or importing: aliasing a class name, and aliasing a namespace name". So basically this leaves two options for the average case:

Aliasing a namespace name


namespace ns1\ns11\ns111 {
 class c1 { }
}
namespace ns2\n21 {
 use \ns1\ns11\ns111;
 $v = new ns111\c1();
}

Aliasing a class name


namespace ns1\ns11\ns111 {
 class c1 { }
}
namespace ns2\n21 {
 use \ns1\ns11\ns111\c1;
 $v = new c1();
}

While both options are useful developers will probably prefer to use the one over the other in different cases. For example if your script imports many classes declared in one namespace, only one namespace can be imported avoiding the need to import each class separately.

Option A:


use \ns1\ns11\ns111\c1;
use \ns1\ns11\ns111\c2;
use \ns1\ns11\ns111\c3;
use \ns1\ns11\ns111\c4;
use \ns1\ns11\ns111\c5;

$v = new c1(new c2(new c3(new c4(new c5()))))

Option B:


use \ns1\ns11\ns111;
$v = new ns111\c1(new ns111\c2(new ns111\c3(new ns111\c4(new ns111\c5()))))

How Eclipse PDT should complete your "use" statement?

A real cool feature in Eclipse PDT is that use statements are completed automatically for you. The question is what method should be considered:
1. Aliasing a class name
2. Aliasing a namespace name
3. Depends on the case, what are the different cases?

Vote here: http://twtpoll.com/omuaqn

Thoughts on Flash (the Eclipse way)

2010-04-11T12:39:00.000-07:00

Funny coincidence but definitely not related to Apple vs. Adobe shootout, my team was required to integrate an existing Adobe Flash application into Zend Studio 7.2.0 (an Eclipse PDT based product). Let's share this experience of integrating Eclipse and Flash:

Reusing Flash or Writing plain SWT?

It started as a simple and common requirement to provide a presentation layer for a given data source loaded into the product. Happy and enthusiastic we started designing a user friendly Eclipse perspective that provides nice diagrams and trees that present the data. Before we started to actually implement it, we were told that it would be great if we can reuse an existing Flash application that our colleges at Zend have already developed. "Adobe do this so why can't we do this?", relating to Flash Builder that is based on Eclipse and Flash. Anyway, it can save months of development and integration effort in the future.

The Good

Using a Flash application into Eclipse integrated web browser is pretty easy task. Users choose a source file in a dedicated import wizard, a new perspective is presented that includes an Eclipse view presenting the Flash application. We used a simple browser view for this end:

public class FlashView extends ViewPart {
private Browser browser;
public void createPartControl(Composite parent) {
parent.setLayout(new FillLayout());
try {
int mozilla = SWT.MOZILLA;
browser = new Browser(parent, mozilla);
refresh();
} catch (SWTError e) {
// ...
}
}
private String getText(String file)  {
return "<object classid='clsid:D27CDB6E-AE6D-11cf-96B8-444553540000' 
  codebase='http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=10,0,0,0'
  width='100%' height='100%'> 
  <param name='flashVars' value='...'> 
     <param name='src' value='myFlash.swf'> 
     <param name="wmode" value="opaque"> 
  <embed pluginspage='http://www.macromedia.com/go/getflashplayer'
  width='100%' height='100%'
  flashVars='...'
  wmode="opaque"
  src='myFlash.swf'/> 
 </object>"
}
}

And a Jetty server for serving the Flash application is launched:


public class JettyServerManager {

public static void startJettyServer(final int port) throws Exception {
final String rootPath = getJettyRootPath();
Runnable runnable = new Runnable() {
public void run() {
 server = new Server();
 SelectChannelConnector connector = new SelectChannelConnector();
 connector.setPort(port);

 try {
  server.start();
  server.join();
 } catch (Exception e) {
  // ...
 }
}
};
serverThread = new Thread(runnable);
serverThread.start();
}

public static void stopJettyServer() throws Exception {
if (server != null) {
// ...
}
}
}

The Bad

One more trick that we wanted to add in our client product is a small layer of communication between the two applications, so basically once a user clicks on a data relating to a specific workspace resource the relevant resource is opened in the editor (something like "link with editor" button).

Our first attempt used a dedicated socket to transfer these calls, but after reading the cross-domain policy we understood that another port is required. So three (!!!) different ports are opened for serving this application - the Jetty one, our communication channel and a cross-domain policy port (since the default one is 843 and Linux based OS can't open it we should have open another non-default one). We could live with it if it worked out, but after lots of testing it came out that Windows and Linux machines don't behave the same. On Windows the security port got the request and handles it right, then the actual communication port works as expected. On Linux the same workflow is expected but we got garbage content in our communication although the policy file was excepted and verified by the Flash engine.

Our next attempt used the same Jetty channel to broadcast the changes from the Flash application, once the Flash application wants to alert our product it sends a request to the Jetty (on the same port) and notify our product. This actually worked very nicely.

The Ugly

Well, let's say that Flash and SWT don't share the same look and feel and are naturally different. Usability in this case is a little awkward but tolerable.
To make sure our customers are not required to manually install a browser and then install a Flash player plugin on top of this browser we wanted to have our own XULRunner instance and flash player plugin installed. Although it seems that Adobe's Flash player license is pretty open we couldn't redistribute it in an easy way into our integrated browser as Adobe require to install it under a specific place using their installers.
One last usability shame is the case where an instance of a Flash view is opened and then Eclipse product is closed. Although the Jetty service is down as well (as expected) it should be launched again to serve the view again upon start.

The End Result

A simple import wizard that requires the stored snapshot is displayed:

Many thanks to Qiangsheng Wang and Jacek Pospychala!

ZendCon, Eclipse and the Cloud

2009-10-22T16:36:00.000-07:00

This is a wrap-up for another excellent #zendcon that took PHP one step forward this year into the enterprise world and the mainstream.

It began with several announcements about Zend Server 5.0 beta that now provides more enterprise-ready features such as code tracking tools and job queue services. It continued with an announcement of a new edition for Zend Studio 7.1 beta that is based on Eclipse PDT 2.2 with remote server and task focus programming tools integrated with the Mylyn PHP bridge. It was also the time Zend stated that it is going to invest more on making standard to interact with "the cloud" (MS, IBM, Rackspace, Nirvanix and Go-grid) with its new Simplecloud API.

Interesting points that I wanted to share:
1. Stephen O’Grady moderated a panel about the various Zend Cloud initiatives entitled Developing on the Cloud you can read his summary here.

2. This conference everyone were using Eclipse tools, it is just wonderful to see that Eclipse solutions are well adopted by the PHP community that was at first controversial about moving to Eclipse. People were also amazed by the built-in tools Eclipse provides that can be leverage by all developers such as streamline of development process features and Application life-cycle management tools.

3. Another nice conversation made with two Jetbrains developers that were really enthusiastic about their open source product that will deliver a PHP plugin really soon. I talked to them about the latest announcements (open sourcing InteliJ platform and IDE). It seems that unlike the Eclipse community Jetbrains really wants to focus on platform for development tools and will do their best to keep this goals for now. I was really impressed by the deep knowledge they have about language modeling and the methods they use internally for indexing and caching that is totally different from approaches I know in Eclipse. It will be very nice if the Eclipse community will take some time to learn some techniques from their open source project

4. Some pictures from the keynote:

So long ZendCon09!

The (Flat and Long) Type Hierarchy of Zend_Exception

2009-08-30T08:51:00.001-07:00

Trying to build the type hierarchy of the Zend_Exception class in Zend Framework using Eclipse PDT yields a long and flat list of Exceptions.

Should it be more "hierarchical-like"? I mean... the framework, with core and extra plugins?

Graduation or Maturity?

2009-07-16T00:29:00.000-07:00

This question has been puzzling me for a long time now, but maybe there is no difference at all between graduation and maturity in a lifecycle of a project?

The basic definition of a "mature project" is a project that has been in use for long enough that most of its initial faults and inherent problems have been removed or reduced by further development. On the other hand, I couldn't find consensus about the graduation step of projects. I'll take two examples from two different worlds - Java/Eclipse and PHP. As described in the proposal lifecycle of Zend Framework after a project has been recommended, the promotion step includes confirmation of unit tests and documentation in its way to graduation. It seems that the Eclipse Foundation set a few clear criteria for graduation that include adhering active community, fully operational project, and a technical review of the architecture. These two processes are so different but still I start to get a notion that graduation is not about passing criteria but only a phase that a project becomes aware of itself, and most important thing graduation is only the first step toward maturity.

Projects that pass their graduation process although have not seen widespread use yet, enjoy a core user base, are more flexible and still cannot be extensible in an easy way. Fully mature projects are projects that enjoy the publicity in a larger community and probably less flexible since many adopters already extend the previously defined API.

Anyway, the most important (and fun!) period in the lifecycle of a project is when it is graduated and starts to get all dots connected till its final maturity. This is exactly where Eclipse PDT project in, and we see more and more people that ask to extend its core capabilities.

Latest News from PHP/Zend Tooling World!

2009-07-07T11:05:00.000-07:00

The first half of the year (2009) is over and the Web world got new, structured techniques for rich Web application development tools in Zend Server and Zend Studio 7.0 based on the latest Eclipse PDT project (2.1) with features such as Server integration, smart code analysis for dynamic languages, refactoring tools and more.

Instead of writing blocks of texts describing these new exciting features I want to share with you a few screen casts created by Zend (thanks Yossi L.!) that demonstrate the new capabilities provided to Web developers who work with php as their main server side engine. If you want me to elaborate on specific screen cast comment out or let me know, I promise to add details in another post.

Enjoy ;)

Jump Starting Web Application Development Using Zend Studio & Server Integration

Code Navigation

Code Analysis and Auto-fix

PHP 5.3 Development

PHP Code Refactoring

RAD Tools

Root Cause Analysis

The Rising Star

2009-06-20T13:12:00.000-07:00

It's "Eclipse for PHP" first year in the Eclipse simultaneous release train, and yet the final release has not been released, but studying the downloads # of the forth release candidate is a very good indication of things to come - Eclipse PHP flavor is going to be the rising star of the Galileo train.

"Eclipse for PHP" package is an Eclipse flavor including the Eclipse platform, CVS, Mylyn, DLTK and Web tools platform with an addition for PHP developers - the PDT plugin.

It is also the first year Zend releases Zend Studio (7.0) right after the community edition is released. This time we align Zend commercial product with the community edition to have the same impact for both our customers and the community.

Tel Aviv Eclipse DemoCamps Galileo 2009

2009-06-16T10:18:00.000-07:00

Its time to create a buzz around the upcoming Galileo release here in my city Tel Aviv, Israel. Actually this is the first time ever this happens in Tel Aviv, and the number of attendees is really impressive, comparing to other countries around the globe.

What is an Eclipse DemoCamp?

"We are inviting individuals to organize and attend Eclipse DemoCamps around the world to celebrate the Galileo release. The Eclipse DemoCamps are an opportunity to showcase all of the cool interesting technology being built by the Eclipse community. They are also an opportunity for you to meet Eclipse enthusiasts in your city."

What's the plan?

Six presentation given by great people who volunteered to help promoting and contributing to the event.

This time Zend Technologies (the PHP company I work for ;) and the company behind PDT) helps to organize the event.

Register free here.

Two Horizons Coincide

2009-05-30T11:57:00.000-07:00

In recent years there has been an explosion of open source communities in several areas within the software mainline industry. Vertical and horizontal communities are founded. While vertical communities are specialized in one sector, horizontal ones developed with vertical links.

I am always excited to see two communities that find a common interest and collaborate together. A great (yet extreme) example of vertical and horizontal communities that converge is the Eclipse/Jetty project, starting with basic integration points the two communities are now associated as Jetty’s core is hosted by the Eclipse Foundation.

Eclipse and PHP Are Now (Officially) Best Friends!

What it takes for two horizontal communities of the size of Eclipse and PHP to be "best friends"? Except of course for motivation of these communities to be improved.

Recognition - The Eclipse community understands that PHP developers are major section of its user’s base, and therefore takes actions. At the very first days of Eclipse, PDT was available as a plug-in that could be installed over Eclipse platform and other dependencies. With the release of Galileo, Eclipse recognizes that people enter to the Eclipse world because of PHP and releases an Eclipse PHP flavor that is created exclusively for the PHP community, exactly as provided to Java, C++ and Web tools developers.

Commitment – The two communities grow together. When one makes a move, the other takes an action as well. When PHP has made the intent to deliver its new major version, Eclipse PHP Development Tools (PDT) has been adapted by supporting the new PHP 5.3 language features with an early release. Another example, since PHP is an extensible language providing a way for developers to add extensions to its core, Eclipse PDT enables those people who extend PHP to extend it as well, with API for type inference and code completion.

Adoption – According to the latest Eclipse Community Survey "Eclipse IDEs are the most popular primary development environments among respondents; Eclipse JDT (60%), Eclipse PHP Development Tools (12.6%) and C/C++ Developer Tools (6.3%)." This means that for each 5 developers that use Eclipse Java IDE, there is one Eclipse PHP developer and a half C/C++ developer. Comparing these results to the 2007 community survey where PHP was not listed among the 5 top Eclipse IDEs.

It seems that we are (close to) reaching our goals to make Eclipse and PHP best friends.

Welcome the PDTT - PHP 5.3 Code Assist Engine Tests

2009-03-09T00:29:00.000-07:00

pdtt is a clone of the popular phpt. Eclipse PDT uses this mechanism for testing its PHP 5.3 code assist engine.

Since Michael has just finished implementing the second phase for PHP 5.3 support in PDT, we can now expose unit tests and ask users to add more cases to the code assist tests reposiroty.

As written in the pdtt wiki page:

"The first thing you need to know about tests is that we need more!!! Although Eclipse PDT code assist works just great 99.99% of the time, not having a very comprehensive test suite means that we take more risks every time we add to or modify the Eclipse PDT Code Assist Engine implementation. The second thing you need to know is that if you can write PHP you can write tests. Thirdly - we are a friendly and welcoming community, don't be scared about writing to (pdt-dev@eclipse.org) - we won't bite!"

Basic Format for a pdtt file:

--TEST-- 
Tests a simple class name completion in namespace 
--FILE-- 
<? namespace My; class A{} class b{} $a = new My\| ?> 
--EXPECT-- 
type(A) 
type(B)

I guess that once we get some feedback from our members we will expose a better (automatic) way to submit pdtt files.

Enjoy ;)

Seven Things - tagged by Andi Gutmans

2009-01-03T23:25:00.000-08:00

Although till recently I thought that work and fun can't get along, Andi Gutmans is trying to prove to me, time after time, that this assumptions is completely wrong!. Yes... I've been tagged.

Seven things I want to share with you:

1. I am allergic to cats - well... at least that's what I was told when I was a kiddo, so my family had a cute dog with long hear, no cats. Now my wife insists that we should have a cat since she was grown up with cats, and I answer her that we have one cat already. Miaoo...

2. I have a super smart barber, who is a lawyer - my father, he actually replaced my mom when I was 13 years old. Curly hair is something easy to cut and I can't see any other barber since I get pretty strain by that.

3. My brother lives in Panama City with his lovely family. Last time I visited him, some guy that set next to me in the flight asked me why I use Eclipse as my development environment, I told him that I am a Java developer. He then ask me, "really? and I thought Java is dead, you should try out PHP..." :). It took me 10 minutes to convince him that I really work at Zend.

4. I am trying to figure out how to analyze X-ray images to better examine the OSA phenomena, my professor thinks it is doable at least...

5. I am very proud of my wife as she is going to be a doctor, well on 2010, and then she has more 7 years to be in residency... 2017 here we come!!!

6. I am managing 4 open source projects, 3 on Google and 1 on Eclipse. I am participating in much more.

7. My new iPhone is the most appreciated present I got from my wife. I sound like a material guy, but it just made my life much more comfortable.

Hi guys you've been tagged-

1. Kfir Karmon who is the smartest guy at Microsoft Israel Labs.
2. Yaniv Taigmanwho is going to have a knockout with his face.com startup.
3. Nick Boldt who is keeping his eyes on Eclipse PDT release engineering stuff.
4. Lior Wolf who is the most admired professor in my university ;).
5. Michael Spector, who doesn't have a blog but is the fastest coder at Zend, so he can arrange one in minutes :).

6. Philip Gabbert who met me in the last ZendCon, and became a Zend Studio fan.

And here are the rules I'm supposed to pass on to the above bloggers:

* Link your original tagger(s), and list these rules on your blog.
* Share seven facts about yourself in the post - some random, some weird.
* Tag seven people at the end of your post by leaving their names and the links to their blogs.
* Let them know they've been tagged by leaving a comment on their blogs and/or Twitter.

Zend Framework and Dojo Integration is a Knockout!

2008-11-26T14:29:00.000-08:00

A new screencast was released today showing off the slick integration between Zend Framework and the Dojo Toolkit. This screencast also demonstrated the tooling support which Zend Studio 6.1 provides for this end. The speaker demonstrates it by constructing a simple Web application that takes advantage of the new features, like code assist, navigation, easy to use of PHP and JavaScript.

This manual presents a step by step guide for getting the Web application from scratch.

ZendCon 2008 Slides

2008-09-18T10:02:00.000-07:00

Yesterday I gave a session about Rich Internet Application development, titled "PHP and AJAX made easier with Zend".

Ria Made Easier With Zend

View SlideShare presentation or Upload your own.

ZPortal is Open-Sourced

2008-08-15T03:18:00.000-07:00

The pet project I have initiated at work a while ago finally goes public.

Project's name is ZPortal and from now on it is managed under Google Code. One important fact is that the "Z" prefix indicates the framework we used to build this portal, which is Zend Framework.

As an introduction to this post I want to point on the difference between "Horizontal information" which is information that anybody has and use vs. "Vertical information" which is information that only you or your organization has. In the Enterprise2.0 era we try to take advantage of these two types of information and bring it to the user (employee) so he has much more power in his daily work. Previous solutions like Wiki are not sufficient these days as they discard the horizontal layer and lack of integration points.

So what is all about? it is about Enterprise2.0. ZPortal is a system of Web-based technologies that provides rapid and agile collaboration, information sharing, and integration capabilities in the extended enterprise. For those who are not familiar with the term Enterprise2.0 but know something about Web2.0 I recommend reading this post that compares between the two methods. Actually from a user point of view ZPortal is similar to iGoogle with small differences. First the authentication method is against Microsoft Exchange Server (it can be replaced by any authentication technique but of course this is the common way thee days) second you can add internal feeds from your company as this system runs behind the company's firewall. Third you can extend this portal to your company needs.

If I'd try to depict my environment at office I would do it like this:

Finally, I want to thank two people who are not at Zend anymore but helped allot toward this project - Seva Lapsha and Yuval Kuck.

for more details visit the new ZPortal site - http://code.google.com/p/zportal/

Eclipse PDT Bug Day

2008-05-24T10:30:00.000-07:00

According to Eclipspedia the motivation for Eclipse Bug Day is "to help foster community outreach and growth". Since there are more and more people in the Eclipse PHP Development Tools (PDT) community that start asking for diversity in the development side, Nick Boldt has suggested to help out and contribute patches to the project "if there's Zend folks willing to coach me...". Actually, I am very excited from his (and others) proposal, since it's the first time a group of people have stated that they want to contribute to PDT.

There are three more things that worth mentioning here:

I do think that PHP developers can (and should) try and contribute to this project although the core development is in Java, since trivalley this project is solely designated for them.
PHPEclipse people that did great on this project, should think about a way to integrate their work and help us so we will unite the forces on one platform.
Since people need to have some knowledge about our platform, we should supply basic design documents. The following two articles can be used for this end, ASTView and Abstract Syntax Tree.

Save the day, the bug day will be held on May 30th. Getting started bugs were tagged as "bugday" (thank you David!)

PHP and JavaScript in a Single Frame

2008-04-03T01:39:00.000-07:00

Many tutorials and blogs written about “PHP & AJAX” and “Rich Internet Application” but take no notice of a suitable development environment. Actually now days' web application tasks involve many technologies and mechanisms that come to be pretty fast a tedious work, this automatically brings many developers to search for an IDE for PHP and JavaScript.

Yesterday, I have conducted a Zend webinar, named "Developing Rich Internet Applications using Zend Studio for Eclipse". In this Webinar I presented Zend Studio for Eclipse empowered by the Ajax Tools plug-in, I went over the installation process, project management, source editing and debugging capabilities for both PHP and JavaScript including code assist, code formatter, folding elements, server-client debugging and more.

Also I have demonstrated the usage of ZF and Dojo session debugging and with the example that was given by Ralph last week. Thanks Ralph!

Also I gave a demonstration of the integrated Mozilla editor that communicated with other parts of the broser tolling (like DOM inspector, browser console, request monitor view, JavaScript Evaluator, DOM source view, CSS view and the DOM watcher).

See you next time!

EclipseCon 2008 - Here I come...

2008-03-15T09:31:00.000-07:00

It's time to pack two jeans and get the flight to San Fransisco- EclipseCon! here I come.

Though I am a speaker there, I am pretty wait to hear and see some of the Eclipse fellows. Like those from the Data tools platform and from the Web tools platform.

Also there are many sessions that I am eager to attend-
1. Getting started with RAP development - develop rich, AJAX-enabled web applications using the same development model as RCP.
2. Developing Python IDE on top of Eclipse DLTK Project - a set of frameworks designed to build full featured development environments for dynamic languages.
3. Getting Started with OSGi
4. Mylyn: code at the speed of thought
5. What can the WTP Snippets View do for me?
6. Eclipse Command Language

and a link to the EclipseCon sessions
http://www.eclipsecon.org/2008/index.php?page=introduction/

php Development Tools (PDT) Community News

2008-02-22T03:59:00.000-08:00

It's funny how differently developers act in 'release cycle' vs. 'development cycle' . While during the first we are busy with users' feedback but we lack of any intellectual challenges , the latter is calm and quite but full of energy and programming disputes. PDT version 1.1 development cycle has begun and we need an extent of "noise" from our community so we won't lose our way. You are more than welcome to advise us now.

Taken from Ohloh's Eclipse PDT page

So what's keeping us busy these days?

1. Revising Modeling Techniques – Its time to catch up Eclipse's standards. We have decides that our previous modeling technique is getting oldish. So naturally we are targeting JDT's concepts with adaptation to the php dynamic binding nature (given by the DLTK project).

2. Code Manipulation – sometimes the editor should generate new code or even rewrite an existing code. This is an excellent mechanism for such kind of tasks. Also a great advantage is that we catching up JDT's standards on these capabilities as well so many of JDT's features are quickly portable to php.

3. UI enhancements – this is the part that our community should be most happy to hear about. Since infra was enhanced , more and more UI features are available. Taking for example mark occurrences, override indicators, better code completion, fast searching, quick fixes and more.

Exit Execution Paths are marked in PDT 1.1 Editor

4. Upgrading our Dependencies – While most of Eclipse 3.4 enhancements are infra related, Web Tools 3.0 brings the Ajax tools into their editor and this is automatically brings it to the php environment. Editing, browsing, launching, code assisting, folding, and more features are now available for the JavaScript side as well.

5. Unit testing – Well... maybe it won't be an interest of any of our users but still it is worth mentioning. We have tripled our unit testing to provide stability and regression testing to PDT. It seems that it also makes the whole development cycle more fun to us!

Speaking at EclipseCon 2008

2007-12-16T09:13:00.000-08:00

It seems that PHP developers have attracted much attention from the Eclipse community. In the next EclipseCon conference I am going to make two sessions about PDT and its ecosystem.

Developing Rich Internet Application with Eclipse Tools

It's about to get a whole lot easier for AJAX and PHP developers to develop Rich Internet Applications under the Eclipse environment.

This tutorial introduces tools to develop Rich Internet Application including:

The Eclipse platform
The Web-tools platform and the AJAX Toolkit
The PHP Development tool

Content

Introduction to Eclipse and Web development environment
PHP (Server-Side) development tools
JavaScript (Browser-Side) development tools
Setting up a generic ‘hello world’ website
Developing your AJAX-PHP web-application

Extending the PDT Project

The PDT project provides a PHP Development framework for the Eclipse platform. This project encompasses all development components necessary to develop PHP and facilitate extensibility. It leverages the existing Web Tools Project in providing developers with PHP capabilities.

In the PHP world, where there are hundreds of core extensions and dozens of frameworks, we finally have an accepted development environment that enables framework and core developers to support also their own development tools.

This tutorial introduces the basics of PDT extension points and architecture as well as a case study of a well-known extension to PDT.

PDT Gets Smarty

2007-11-19T08:58:00.000-08:00

Staring from day one of PDT project, a feature request screaming "Support smarty template syntax coloring" was very popular in our bug tracking system. Twenty-three people voted for this issue, many posts were written about it in the newsgroup and users keep sending us e-mails hoping their request is going to be fulfilled in the near future.

Well... if I understand the Eclipse Foundation correctly, PDT developers shouldn't operate fast and fix these kinds of features. PDT was built only as a "PHP Development Tools framework". In the PHP world where there are hundreds of core extensions and dozens of frameworks it is impossible to support all of them.

But... a feature request is a feature request. And feature requests are meant to be resolved. Applying simple logic rules derives that - "PDT Gets Smarty".

So the growing eco-system of PDT has a new sibling called 'smartypdt' which is a project that "enables users to develop Smarty projects utilizing the power of PDT" it is a great initiative developed by William Candillon , that was guided by me and we expect Dave Kelsey to join us soon. The results are really great!!!

For now two basic capabilities are provided: syntax coloring and compilation
error analysis. This makes PDT and smartypdt the best development environment
for Smarty developers.

The idea is that frameworks and extension creators will re-use the
functionality presented in this project and provide it alongside their products
to ease the development with PHP under PDT.

The package and source code can be accessed from here - http://smartypdt.googlecode.com/

You are more than welcome to test-drive it and submit bugs, features and patches.

One community, Dozen programmers, 1186 bugs and one quest for transcendent PHP editor

2007-09-18T15:49:00.000-07:00

One community, Dozen programmers, 1186 bugs and one quest for transcendent PHP editor, By Roy Ganor

A year and a half ago, I got a confirmation e-mail from Eclipse Foundation Inc., the subject was “Welcome to Eclipse!”. I probably didn’t understand the exact meaning of this message at that time.

Today the PDT project community consists of about 30 users that are daily involved, and about 300 users that are weekly involved, and about 13,000 users that are monthly involved in the project . Remarkable! by any mean of open-source project.

Going back to the beginning of the story, the group has started developing an Eclipse based PHP editor with mixed emotions. On the one hand our current implementation that was based on Java Swing Technology, was very robust and appreciated by PHP developers (many rewards, compliment reviews and winning contests). On the other hand we saw the effect of JDT project on the Java community.

I am not going to write about the development process as it would require at least more than ten pages to cover. I will rather tell you about the community, about us (the group) and about the integration level with the Eclipse community.

So, the first question is how we grew to a large scale community? I can come up with many reasons. Starting with the need for such a product and the existing Eclipse community, to the exposure we enjoyed during the development process. But if you ask me - there is one more (and most important) reason for growing to such a scale. Any community is based on its regular users that comprise 95% of it. This is the heart of the community and we felt that we should do more for them. We observed that everything went just great till one finds a defect in the editor, he then may:
Browse to Eclipse's bug tracking system and reports about the issue.
Go to the \eclipse folder and remove it with a ‘–r’ parameter.
But the question is how to make the user choose the first option? Well the answer is quite simple. A user will report on a bug if he gets a fix ASAP, say in 24 hours. 24 HOURS?! yes, he will then continue working with the product and probably report about another issues or features. In doing so he enters the 2% of the users that are called active users. We delivered the fix as part of a nightly build that was stable enough (unit tested) to be bundled and deployed.

The integration level with the Eclipse community is another magical and interesting issue. During the process of development we encountered with an “imported” code that is written as a framework on a daily basis. Most of the time we worked with a conformist API that in any circumstances cannot be changed. In other cases we tried to contribute these framework projects and made them more flexible to us – probably this is the strength of one open-source community that is obligated to each other. One of my e-mails to WST Project leader points out that it is a “miracle” that we integrated the PHP Editor into the Web Editor. Taking for example the JSP Editor whose team is a sub-project of WST and is relatively tight coupled to the Web Editor.

PDT 1.0 is out and there are many reasons to call it the transcendent PHP editor.

(The name of this post was inspired by “Dreaming in Code”/Scott Rosenberg)

Publish "Add Feed to Your Personalized Site"

2007-01-04T11:25:00.000-08:00

Google
http://fusion.google.com/add?feedurl=rss_url

Msn Live
http://www.live.com/?add=rss_url

My Yahoo
http://add.my.yahoo.com/rss?url=rss_url

Netvibes
http://eco.netvibes.com/subscribe.php?url=rss_url;type=rss

Eclipse Plug-in Test Framework

2007-01-03T10:43:00.000-08:00

After two weeks of configuring and scripting test packages I can say that "building" a build process is a very hard task, but worth the tears!

now you can RSS: http://download.eclipse.org/tools/php/downloads/rss/updates.xml
or be a member in pdt-unit-test@eclipse.org to be updated about the test results.

Good night,
Roy

Transforming to linux-style stream

2007-01-02T13:08:00.000-08:00

Why there are differences between the platforms end of line characters? Oh yes, Never ask the WHY question on standarts, so I found my self coding a small block to overcome this mini-crisis:

// given an input stream
final InputStream is = ...;

// create a stream that behaves as a linux-style stream
InputStream linuxStream = new InputStream() {
 int previous = -1;
 int current = -1;
 int next = -1;

  public int read() throws IOException {
   if (next != -1) {// a buffered int was readen last iteration
      current = next;
      next = -1;
   } else { // else read an int from the stream
     current = is.read();
   }

    if (current == 13) {
        next = is.read();
        if (next == 10) { // encounter "\r\n" transform to "\n"
            next = -1;
        }
        current = 10;
    }
    return previous = current;
  }
}

The Future of Operating Systems

2007-01-01T11:16:00.000-08:00

Well... as I see it, there is no such thing "future to operating systems".
Hi, wait a minute, are you fooling me? how computer will work without an operating system?

They will, with a small effort one of the open-source companies will create a simple program that will first of all manage the basic hardware of a computer (I/O and memory), and second let the user the ability to browse the internet. Such kind of computers should be called "Webtops" (I know that some people use this word to describe web office-style programs but I think that like laptops/desktops, we should call small computers that designed for the net - "Webtops"). Oh ya! These computers will work fast, since they won't do any "heavy" computations.

So what you're telling me that simple and light computer program will be backup by a huge backend servers? well... yes.

There are many question here that I need to answer:
Q: Online vs. Offline work, how one should work without an internet connection?
A: Do you realy think that internet connection will not be accessible from anywhere in 10 years from now?

Q: What about security?
A: Security will be given by the server software.

TBC...

Roy Ganor,