Now moving to one of the most exciting features coming in WordPress 3.0 is custom post types, which will vastly expand WordPress’ CMS capabilities. This feature will come handy especially when using WordPress as a CMS.

WordPress Custom Post types are basically different kinds of building blocks that when put together form our website. To understand it in a better way let us create our custom post type called “place”.

Any WordPress system will have functions.php in themes folder. This is the one of our interest. To achieve the purpose you will have to add the following code at the end of the functions.php file.

function post_type_place() {
	register_post_type('place', array('labels' => array('name'=>__('Places'),'add_new_item' => __( 'Add New Place' ),'edit_item' =>__( 'Edit Place' )),
                             'public' => true,
                             'show_ui' => true,
                             'supports' => array('title','author','editor',
                                        'post-thumbnails',
                                        'excerpts',
                                        'trackbacks',
                                        'custom-fields',
                                        'comments',
                                        'revisions'),
                                        'rewrite' => false,
                                        '_builtin' => false,
    									'_edit_link' => 'post.php?post=%d',
   										'capability_type' => 'post',
   										'hierarchical' => false,'query_var' => true
                                )
                      ); 

		// add to our plugin init function
		//for single template
		global $wp_rewrite;
		$place_structure = '/place/%category%/%place%';
		$wp_rewrite->add_rewrite_tag("%place%", '([^/]+)', "place=");
		$wp_rewrite->add_permastruct('place', $place_structure, false); 

		//for displaying tags
		register_taxonomy_for_object_type('post_tag', 'place'); 

		//for displaying categories
		register_taxonomy_for_object_type('category', 'place'); 

}
// Add filter to plugin init function

If you want you can use a single page template for displaying custom post. 

//function to redirect to place page(templating system)
// Add filter to plugin init function
add_filter('post_type_link', 'place_permalink', 10, 3);
// Adapted from get_permalink function in wp-includes/link-template.php
function place_permalink($permalink, $post_id, $leavename) {
	$post = get_post($post_id);
	$rewritecode = array(
		$leavename? '' : '%postname%',
		'%post_id%',
		'%category%',
		'%author%',
		$leavename? '' : '%pagename%',
	); 

	if ( '' != $permalink && !in_array($post->post_status, array('draft', 'pending', 'auto-draft')) ) {
		$unixtime = strtotime($post->post_date); 

		$category = '';
		if ( strpos($permalink, '%category%') !== false ) {
			$cats = get_the_category($post->ID);
			if ( $cats ) {
				usort($cats, '_usort_terms_by_ID'); // order by ID
				$category = $cats[0]->slug;
				if($category == "featured") { 

					$category = $cats[1]->slug;} 

				if ( $parent = $cats[0]->parent )
					$category = get_category_parents($parent, false, '/', true) . $category; 

			}
			// show default category in permalinks, without
			// having to assign it explicitly
			if ( empty($category) ) { 

				$default_category = get_category( get_option( 'default_category' ) );
				$category = is_wp_error( $default_category ) ? '' : $default_category->slug;
			}
		} 

		$author = '';
		if ( strpos($permalink, '%author%') !== false ) {
			$authordata = get_userdata($post->post_author);
			$author = $authordata->user_nicename;
		}
		$rewritereplace =
		array(
			$post->post_name,
			$post->ID,
			$category,
			$author,
			$post->post_name,
		);
		$permalink = str_replace($rewritecode, $rewritereplace, $permalink);
	} else { // if they're not using the fancy permalink option
	}
	return $permalink;
}
add_action('init', 'post_type_place');

Update the permalinks.

The newly created post type (place) will look like this in the WordPress administrator dashboard under the links panel:

Now after creating a custom post you will want to use it. Now see the image below to understand how to add new place in WordPress.

Once you add couple of places the list view under WordPress dashboard will look something like below.

To be able to display the single-type-template using WordPress you will have to use a PHP file by the name single.php. To display newly created custom post you will have to use single-{posttype}.php. So in our case the filename would be single-place.php.

Similarly to archive the custom post use archive-{posttype}.php in WordPress. Normally, the archive-type-template use archive.php file. So in our case the archive template file name would be archive-place.php.

PHP is a great scripting language with many advantages. It provides the power to connect to variety databases (that are available with hosting providers) and easy development curve for faster development along with high response time on account of the underlying libraries compiled for performance.

A database is a crucial part of any PHP Web Service, however it is not mandatory to have one for Web Service. It is just that without it a Web Service is not that useful. It helps you store information about user query and visit information.

What are Web Services?

In a typical scenario, a visitor visits a website and uses the functionality provided by application hosted. HTTP request is send to the server from web browser and server responses are translated back by browser to display the desired result of the visitor.

But things have changed a lot with the evolution of web technologies. You don’t need to visit a website to use its service and functionality if it is providing a Web Service.

With Web Service you can exchange data between a server and a client using a standard XML format to ‘package’ requests and data so that both systems can ‘understand’ each other properly. Either a server or a client could be a Web Server, or any other electronic device you could think of for that matter.

There are different methods for providing Web Services but the most common methods are SOAP, XML-RPC and REST.

What is NuSOAP?

NuSOAP is a group of PHP classes that allow developers to create and consume SOAP web services without needing any special PHP extensions.

It stands for Simple Object Access Protocol, and it is essentially a standard for exchanging XML based data via HTTP.

Having understood Web Services and NuSOAP let’s start building our own Web Service using PHP.

Requirements: PHP 5 and above, Apache Webserver, NuSOAP library and MySQL (required in case there are database interactions)

You can download NuSOAP (version 0.7.3) from http://sourceforge.net/projects/nusoap/files/nusoap/

To understand the concept of the Web Service are going to create a ‘calculator’ Web Service and consume it too.

Create a new project ‘webservice’ on the webroot and unzip the NuSOAP file and place it in this folder.

Firstly, create a new file calc_server.php in the NuSOAP directory (for demonstration purpose I have created it in NuSOAP directory).

The PHP file will look like this:

// load SOAP library

require_once("lib/nusoap.php");

// set namespace

localhost in my case

$ns = "http://localhost/";

// create SOAP server object

$server = new nusoap_server();

// setup WSDL file, a WSDL file can contain multiple services

$server->configureWSDL('Calculator', $ns);

$server->wsdl->schemaTargetNamespace = $ns;

// register a web service method

$server->register('ws_add',

array('int1' => 'xsd:integer','int2' => 'xsd:integer'),// input parameters

array('total' => 'xsd:integer'),// output parameter

$ns, // namespace

"$ns#ws_add", // soapaction

'rpc', // style

'encoded', // use

'adds two integer values and returns the result' // documentation

);

function ws_add($int1, $int2){

return new soapval('return','xsd:integer', add($int1, $int2));

}

// implementation of add function

function add($int1, $int2) {

return $int1 + $int2;

}

//substract method

$server->register('ws_substract',

array('int1' => 'xsd:integer', 'int2' => 'xsd:integer'),// input parameters

array('total' => 'xsd:integer'),// output parameter

$ns, // namespace

"$ns#ws_substract", // soapaction

'rpc', // style

'encoded', // use

'substracts two integer values and returns the result' // documentation

);

function ws_substract($int1, $int2) {

return new soapval('return','xsd:integer',substract($int1, $int2));

}

// implementation of add function

function substract($int1, $int2) {

if($int1 > $int2)

return $int1 - $int2;

else

return $int2 - $int1;

}

//multiplication

$server->register('ws_multiply',

array('int1' => 'xsd:integer', 'int2' => 'xsd:integer'),

array('total' => 'xsd:integer'),

$ns,

"$ns#ws_multiply", // soapaction

'rpc',

'encoded',

'multiplies two integers and returns the result'

);

function ws_multiply($int1, $int2) {

return new soapval('return', 'xsd:integer', multiply($int1, $int2));

}

// implementation of multiply function

function multiply($int1, $int2) {

return $int1 * $int2;

}

// service the methods

$server->service($HTTP_RAW_POST_DATA);

Save the file. It will look like this when you browse it.

(click image to enlarge)

NuSOAP library has a very good feature of Web Service Inspection. If you open

the calc_server.php file in a browser, you will see something like this:

(click image to enlarge)

With this we have now created our own ‘calculator’ Web Service. Now, let us understand how to consume this new created NuSOAP Web Service in PHP.

Create a new PHP file, say ‘calc_client.php’ and put the following code in it.

//client code

<?php

require_once('lib/nusoap.php');

//create a parameter array to pass to the webservicefunction call

$param = array('int1'=>'15.00', 'int2'=>'10');

//define the webservice

$wsdl = "http://localhost/webservice/nusoap/calc_server.php?wsdl";

//create client object

$client = new nusoap_client($wsdl, 'wsdl');

$response = $client->call('ws_add', $param);

//print the response

print_r($response);

?>

The result is the addition of 2 numbers and it will be displayed as below:

It is that simple to create and consume Web Service using NuSOAP library. Moreover, NuSOAP library can also use XML-RPC and REST methods for Web Services.

I have shown you creation and consumption of PHP Web Service using NuSOAP library. If you want to play more with it then perhaps you might even consider adding an interface to the client for INSERTing and UPDATEing new items.

As outsourced product development is maturing new models are emerging in course to mitigate the risk. Every model has its own share of pros and cons. The outsourcer has to select to most appropriate model for his kind of software outsourcing project.

Below are some of the emerging outsourced product development models.

1. Software Product Line

An ISV targets the needs of the prospective industry or function by creating a portfolio of products with variations in features and functions. This model has a base or core product and different products in the same line offers increasing feature sets.

2. Modular Development

In this model the product is developed in the form of modules. One module is developed at a time or different modules by different team all at once.

3. Co-development

In this model ISVs’ and outsourcing partner’s team work together. It is preferred model where the technical capability and bandwidth is available on both side. Typically in this model, outsourcing vendor provides resources and product development project is managed by the ISV.

4. End-to-end Development

In this model, the outsourced product development looks after every aspect of product development. This model is preferred where outsourcing partner has technical as well as technical capabilities and product development experience. This model help ISV focus on very critical aspect of software product business boosting its productivity and profitability.

Here are the five quick steps for agile adoption.

1. Educate the organization:

Know more about agile methodology. Educate everybody related, especially those who will be the part of initial rollout. Make everybody go through a training session on agile irrespective of their knowledge about agile. This will help them develop real understanding of the key concepts in agile.

2. Pick the project:

After everybody is having good understanding about agile concepts and are on the same platform, the agile project can get started. As this would be the first agile project, risks have to be addressed at this level as soon as possible to ensure success for both project and success. The criteria for selecting the project needs to include the solution’s level of complexity, visibility, resources and integrations.

3. Execute the project:

After selecting the project based on selected criteria the team who is going to be engaged for the project has to be educated if it was not the part of earlier training session. Do the project kickoff by explaining the methodology, roles, responsibilities, timeline and deliverables. Instead of ‘scope’ think in terms of backlog, feature negotiations, the sprints, scrum meetings, demos etc.

After the completion of sprint do retrospection and try to learn and improve in next sprint.

4. Review the project:

Review the project that you just complete and note the learning that will refine other processes and projects. The process improvement will involve support functions and project execution teams. To run agile projects at the expected speed it is important that support functions responds quickly to the project sprint requirements. The processes have to evolve, which might take some time, at organizational level to support agile development projects addressing any process level conflicts.

5. Redo the steps:

IT industry is cursed with high attrition than any other industry and hence you will need to constantly train new people on agile concepts and methodologies. This will bring everybody within organization at the same level of agile approach. When you move agile concept deeper into the organization you will find yourself managing change at every level within organization. The change is difficult and you as an agile proponent will have to make it acceptable because agile is beneficial for dynamic projects, which is the need of the time.

Be realistic and good luck with your agile implementation!

By giving away these projects to community, Google is aiming to help the Eclipse Foundation with technologies that will help to enable a more comprehensive set of Java tool solutions.

The WindowBuilder framework is an extensible engine for building Java GUI development tools and will become the Eclipse WindowBuilder project. Google’s GWT (Google Web Tools) Designer Tool is built on top of the WindowBuilder engine. CodePro Profiler is a tool that Java developers can use to help identify performance and efficiency issues. It is a native Eclipse profiler built from the ground up in Eclipse.

Both these projects will fill some existing holes in Eclipse offerings in the GUI tools and profiling space. The projects that have been developed at Instantiations, acquired by Google in August this year, for the last seven years and carried forwarded at Google will jump directly on the annual release train in its first year.

The new additions to Eclipse family will make it easier for people to build applications.

Google has recently released a tool, Closure Compiler, for making JavaScript download and run faster. In true sense it is a compiler for JavaScript. It parses the JS code, analyzes it, removes dead code and rewrites and minimizes the remainder code. It also checks syntaxes, variable references and types. It also warns about common JS issues.

The Closure Compiler can be used as an open source Java application that one can run from command line. It can also be used as a simple web application or a RESTful API.

More information can be found at Closure Compiler Website.

Google has released this new format as part of its initiative to make the web faster.

The world is using the common image formats that were established over a decade ago and are based on the technology of that time. Some developers at Google decided to work on reducing the byte size of images without compromising the quality. They came up with WebP format which reduces file size of an image by further compressing the lossy images like JPEG.

Google has used an image compressor based on VP8 codec that has been open sourced by them in May 2010 for enhancing image compression. Google has applied the techniques from VP8 video intra frame coding to push the envelope in still image coding. Google has also adopted a very lightweight container based on RIFF which may allow authors to save meta data for the image.

Images and photos make up about 65% of the bytes transmitted per webpage according to Google and the new image format is going to lower it to some extent.

So far it is just a developer release but it has a vast potential considering the growing demand of applications and consumption of media on mobile.

SproutCore moves business logic to the client which completely eliminates the latency problem as your computing power, business logic and (partially) data are available at the same. SproutCore applications are full-fledged programs, written in JavaScript. Since JavaScript executes in user’s browser the servers are freed to deliver user’s data as quickly and reliably as possible to make most through cloud application.

SproutCore will change the way web applications are built and consumed by end user utilizing the most out of HTML5 technology.

SproutCore is addressing technology revolution mismatch. Two things are happening simultaneously in area of technology. Faster processors for personal computing are coming to life and applications are moving to web.

Faster processor for personal computing means faster applications and shorter response time for your local (desktop/laptop based) applications. Applications moving to web means less computing required to be performed on desktop. Because of these the end user is not able to get the complete benefit of the technology revolution since combined throughput of server computing and bandwidth has not got increased significantly.

Local applications are responsive because computing power, business logic and data are available at the same location without any dependency on network bandwidth. This is not the case with web applications. While working with web applications users have to live with latency of few milliseconds. Off late, technologies like AJAX have been used to create web pages that can update without having to reload the browser, reducing latency by few milliseconds but they still feel like websites with limitations of interactivity.

With HTML5 becoming popular with every next release of all commercial and open source browsers the world will see increasing usage of SproutCore for web development.

Today we will talk about setting up PHP Application Unit Testing Framework (PHPUnit) in Visual Studio 2010.

Lets start the fun

Step 1: Installing VS.php in Visual Studio 2010

Please follow the instructions provided in my previous post “Developing PHP Applications in Visual Studio 2010 and Team Foundation Server”

Step 2: Installing PHPUnit on your machine

2.1 Installing PEAR Package Manager

The instructions that are to be followed for installing PEAR are available on this URL:

http://pear.php.net/manual/en/installation.getting.php

All you need to remember is that the PHP installation that you need to choose is the one provided by VS.PHP guys

The default PHP folder location will be

C:\Program Files\Jcx.Software\VS.Php\2010\Php 5.3

This is where you got to install PEAR.

2.2. Installing PHPUnit

The next step is to install PHP Unit.

Follow the following URL for instrtuctions on installing PHPUnit.

http://www.phpunit.de/manual/current/en/installation.html

Please make sure that the whole action takes place on your command prompt and should happen with

C:\Program Files\Jcx.Software\VS.Php\2010\Php 5.3

being your current working directory.

Step 3: Creating a sample application

Assuming that you have gone through the previous post and now you know how to create a PHP application in Visual Studio 2010. Lets start writing some code.

Lets start by writing the Example Class that will be tested

This is a fairly straight forward class that has a function that will accept two numbers and returns the sum of the two numbers.

Step 4: Writing Test Cases for the application

Inside your project create a new folder called tests. Now your folder structure looks something like this

In the PHPUnitClassTest write the code that will test the addition function

Once the test case is written by you, its time to go to the next step and that is to run your test.

Step 5: Running your tests

PHPUnit runs from the command prompt, so get this testing done lets get to command prompt and visit the test folder where tests are written. After running the PHPUnit Command this is what you get

Bingo

So this sets up your PHP application unit testing framework (PHPUnit) environment in Visual Studio 2010.

Have Fun.

Apart from MySQL, Microsoft has also enhanced SQL migration tools for other popular databases such as Oracle, Sybase and its own Access. In January 2010 Microsoft has provided the preview of the MySQL migration tool.

Currently SQL Server Migration Assistant v1.0 supports MySQL 4.1 and above. The tool allows developers to convert/migrate tables, views, stored procedures, stored functions, triggers, cursors, DML statements, control statements and transactions. The migration from MySQL to SQL Server will become seamless with this new tool.