The story so far:

• Boy meets ZDE 2.5
• ZDE grows up to 5.5
• ZDE gets replaced by new eclipse-based ZSfE/PDT
• ZDE keeps going, until one day, Boy upgrades OSX
• Boy hacks OSX, but ZDE is running on a donut
• OSX update kills ZDE for good
• Boy cries
• Boy finds Netbeans

This is the continuation of that story. In the last installment Netbeans 6.7 was a nightly build, it had gotten it’s OSX look and feel, and it was starting to get it’s remote debugging up and running.

Now, 6.8 has been out for almost 2 months, and things are really starting to gather steam. With the death of ZDE5.5 finally a reality, and PHP 5.3 code starting to become part of my work-day, I finally jumped 100% to Netbeans.

And let me tell you, Netbeans 6.8 is nothing short of amazing. Debugging with xdebug is now almost as easy as ZDE, it works instantly on 90% of my remote machines, but I have 1 cluster for which Netbeans simply *cannot* find the local source file, making it impossible to debug.

Watches, breakpoints (though, I haven’t figured out conditional breakpoints, if they are there), callstack and local variables work as you would expect (though watches/variables sometimes refuse to populate larger vars, I think this is xdebug config related). In addition, Netbeans supports arbitrary breakpoint groupings; these can be enabled and disabled as a group — very neat.

In addition, it has path mapping to help with remote/local file correlation; so it can find the local file to show the source during debugging — this stops the problem ZDE has where two files have the same basename() and it’s unable to choose the correct one.

However, a fully functional debugger is a minimum requirement. Netbeans 6.8 also has great support for PHP 5.3 (though it has some syntax support bugs), again another minimum.

So where does Netbeans shine? The single biggest answer to that, is PHPUnit support. Netbeans lets you specify your test folder, and abstracts it out of the project, so your tests are separated visually; this is a great minor addition. In addition, Netbeans can generate unit tests (this utilizes phpunit’s built-in functionality), and has a great UI for running tests.

You can run a single unit test by simply right clicking on the test and choosing Run, or you can test a whole project by right clicking on the project and choosing Test. Doing this will bring up the Test Results pane:

As you can see, it shows the number of tests, the test suite, and it’s test status; this can then be expanded to show individual test methods.

Further to this, you can have Netbeans capture code coverage information, if you have the xdebug extension installed locally. This then manifests visually in two ways; the first, is a summary:

The second, more impressive/useful way, is visually within each file:

You will also notice that this adds a set of buttons below the code, which can be used to run the test for just the current file (based on the typical phpunit file/test naming structure, I assume) and to re-run the entire test suite.

To me, this integration is phenomenal, and is changing the way I work. This is a great example of an IDE conforming to your workflow, and proving new ways to do things; rather than fighting you and requiring you to change to it’s needs and ideals.

Other things of note, Netbeans 6.8 has Symfony project integration, and 6.9 is including Zend Framework integration, if those things appeal to you — I have yet to play with either, so can’t comment on their usefulness.

I can, without doubt, confidently say, that despite the few bugs, and some still immature minor things, Netbeans is my recommendation for an IDE.

Go grab Netbeans today.

- Davey

The reason for this, is that Snow Leopard only ships with Java 1.6 and 1.3 (wtf?)

$ ls -al
total 47
drwxr-xr-x  12 root   wheel  408 Aug 30 22:08 .
drwxr-xr-x  11 root   wheel  374 Aug 29 10:27 ..
lrwxr-xr-x   1 root   wheel    5 Aug 29 10:26 1.3 → 1.3.1
drwxr-xr-x   3 root   wheel  102 Jul 20 19:35 1.3.1
lrwxr-xr-x   1 root   wheel   10 Aug 29 10:26 1.5 → CurrentJDK
lrwxr-xr-x   1 root   wheel   10 Aug 29 10:26 1.5.0 → CurrentJDK
lrwxr-xr-x   1 root   wheel    5 Aug 29 10:26 1.6 → 1.6.0
drwxr-xr-x   7 root   wheel  238 Aug 29 10:26 1.6.0
drwxr-xr-x   8 root   wheel  272 Aug 29 10:27 A
lrwxr-xr-x   1 root   wheel    1 Aug 29 10:27 Current → A
lrwxr-xr-x   1 root   wheel    3 Aug 29 10:26 CurrentJDK → 1.6

As you can see, except for the 1.3 JDK, everything else symlinks to 1.6.0. Now, ZDE will not run with 1.3, and is broken in 1.6, so how do you fix this?

The answer, can be found here: http://wiki.oneswarm.org/index.php/OS_X_10.6_Snow_Leopard

I am replicating it here, as it looks like it’ll be a temporary problem for them and is likely to disappear.

Update (9/13/2009): See this post for details on getting the Java 1.5 binaries from Apple themselves.

It essentially comes down to this: Grab the Java 1.5 JDK from Leopard (original) and then tell OSX to use the 32bit version by default.

This is all done through the Terminal.

So, first, grab the 1.5.0 leopard tarball and unpack (if the link below stops working, contact me for a mirror):

cd /tmp/
wget http://www.cs.washington.edu/homes/isdal/snow_leopard_workaround/java.1.5.0-leopard.tar.gz
tar -xvzf java.1.5.0-leopard.tar.gz

Next, move the folder to the standard JVM location on OSX (this will require your user password):

sudo mv 1.5.0 /System/Library/Frameworks/JavaVM.framework/Versions/1.5.0-leopard

Then remove the current 1.5.0 symlink and point a new one to our new 1.5.0-leopard directory.

cd /System/Library/Frameworks/JavaVM.framework/Versions/
sudo rm 1.5.0
sudo ln -s 1.5.0-leopard 1.5.0

Next (and this isn’t in the original document), set permissions:

sudo chown -R root:wheel ./1.5.0-leopard

Finally, open up the Java Preferences app in /Applications/Utilities, and in the Java Applications section, drag the “J2S2 5.0 32bit” version to the top.

After doing all this, restart ZDE and the selection bug is gone!

- Davey

I think, however, I have solved the issue.

Simply edit /Applications/Zend/ZendStudio-5.5.1/bin/runStudio_mac.sh and make the following change:

java -Xms16m -Xmx256m -cp ZendIDE.jar:MRJToolkitStubs.zip:sftp.jar:axis.jar:commons-discovery-0.2.jar:commons-logging-1.0.4.jar:javaxzombie.jar:jaxrpc.jar:saaj.jar:wsdl4j-1.5.1.jar:jhall.jar:../docs/help.zip com.zend.ide.desktop.Main

becomes:

/System/Library/Frameworks/JavaVM.framework/Versions/1.5/Home/bin/java -Xms16m -Xmx256m -cp ZendIDE.jar:MRJToolkitStubs.zip:sftp.jar:axis.jar:commons-discovery-0.2.jar:commons-logging-1.0.4.jar:javaxzombie.jar:jaxrpc.jar:saaj.jar:wsdl4j-1.5.1.jar:jhall.jar:../docs/help.zip com.zend.ide.desktop.Main

This just explicitly makes it use JVM 1.5, which is, after all, what it was built for.

Once I did this, it became snappy again, and seems to be far less crash-prone, hurrah!

- Davey

This argument currently only supports one value which is the constant LIBXML_NOEMPTYTAGS. This option makes sure that you do not end up with <tag /> but instead, <tag></tag>. This can make things easier if you need more predictable text to perform other changes on later.

However, in playing around with the option, I noticed that my markup changed somewhat significantly in size (it’s a large document). Some further playing yields that the following six uses of DomDocument->SaveXML() yield different results:

  is a non-breaking space character (in HTML  ). ext/dom Defaults to UTF-8

<?php
$dom = DOMDocument::loadXML("<xml><test />&#xA0;</xml>");

echo   $dom->saveXML();
/*
Default behavior, entities stay as entities, no encoding added to the XML prolog
<?xml version="1.0"?>
<xml><test/>&#xA0;</xml>
*/

echo $dom->saveXML($dom->documentElement);
/*
Entities are transformed to output charset, no XML prolog
<xml><test/>[nbsp char]</xml>
*/

echo $dom->saveXML($dom);
/*
Entities are transformed to output charset, encoding added to the XML prolog
<?xml version="1.0" encoding="UTF-8"?>
<xml><test/>[nbsp char]</xml>
*/

echo $dom->saveXML($dom->documentElement, LIBXML_NOEMPTYTAG);
/*
Entities are transformed to output charset, no XML prolog, tags expanded
<xml><test></test>[nbsp char]</xml>
*/

echo $dom->saveXML($dom, LIBXML_NOEMPTYTAG);
/*
Entities are transformed to output charset, encoding added to the XML prolog, tags expanded
<?xml version="1.0" encoding="UTF-8"?>
<xml><test></test>[nbsp char]</xml>
*/

echo $dom->saveXML(null, LIBXML_NOEMPTYTAG);
/*
Entities stay as entities, no encoding added to the XML prolog, tags expanded
<?xml version="1.0"?>
<xml><test></test>&#xA0;</xml>
*/
?>

Just something to keep in mind next time you’re fooling around with the DOM.

- Davey

The problem with mailing lists is that they are a free for all, it doesn’t matter who posts, everybody at every level gets to see the post.

In the real world, communications pass through a hierarchy of people, escalating as necessary, passing from person to person up the chain.

This means that, given enough time, any mailing list starts to have a large noise:signal ratio, at least for any given person’s take on the list;
they want to read what they want to read, and don’t need to be distracted ignoring the stuff they don’t want to read.

Solving the Problem

There is an unspoken — some what hap-hazard — hierarchy among the community, which with some thought, I believe, could be defined, refined
and utilized to our advantage. As an example:

  - Active internals contributors with access to internals CVS (contributions of code and useful discussions)
  \
   - Active internals contributors without access to internals CVS (patch submitters, useful discussions)
   - Inactive internals contributors with access to internals CVS (previous contributions of code and useful discussions)
     \
      - Active non-internals, PHP contributions (docs, phpweb, PEAR)
      - Active community leaders
      - Active project leaders
      - Active linux distro maintainers
       \
        - General Users with a high understanding
          \
           - Genernal users with little understanding (newbies)

If we take each of these, and assign them a number:

L1  - Active internals contributors with access to internals CVS (contributions of code and useful discussions)
    \
L2   - Active internals contributiors without access to internals CVS (patch submitters, useful discussions)
L2   - Inactive internals contributors with access to internals CVS (previous contributions of code and useful discussions)
       \
L3      - Active non-internals, PHP contributions (docs, phpweb, PEAR)
L3      - Active community leaders
L3      - Active project leaders
L3      - Active linux distro maintainers
         \
L4        - General Users with a high understand
            \
L5           - Genernal users with little understanding (newbies)

Now, what if, at any level, you could only see (by default) 1 level below you (and all levels above you). For example: L1 can see L2, L2 can see L3 etc.

This immediately means that you only see stuff that might be relevant to you; however, as a community, we then lose the ability for newcomers to contribute good ideas; because they would start out with zero karma. To help solve this issue, we adjust karma based on responses:

Scenario

• A L3 user posts something of interest
• A L2 user see’s the post and replies, the reply is L2
  • This bumps the original post up to L2 as well
• A L1 see’s the post now, and can then participate in the discussion if they choose

In this case, only the thread in question is bumped up, however given enough L2/L1 (weighted) direct responses over different threads, a L3 user can gain karma and eventually become a L2 user (and obviously this applies to anyone moving up the chain)

In this way, threads (and by this mechanism, users also) can organically make their way up the tree as they gain traction, are discussed at each level and moved up.

I believe it would be possible to have a ”’single”’ mailing list that could span everything from internals right down to php-general, but this is probably not desired! It would however allow the users of any list to, regardless of their experience in the tree, contribute without weighing down the list.

Features

• Karma tree seeded by current “social” climate
  • based on CVS access level, activity in a sliding timescale, community contributions etc
  • Some manual work will be needed on this
• Weighted responses, a L2 responding to a L3, will move it to L2, but 3 L2’s or 1 L2 and 1 L1 responding would move it to L1, for example.
• Adjustable threshold. Perhaps some magnanimous internals contributor likes to help out newbies, he can choose to see the whole tree, or perhaps just 3 levels down
• Championing — it should be possible for a user to champion someone to quickly move them up the ladder, for example a L2 can bring a L5 up to L3, so their peers can see stuff, this is bringing the user up, not the thread
• Continued tweaking of karma based on CVS access and contributions
• Personal filters, you can add users (of any level) from whom you would like to see threads, helping the movement of stuff up the tree, skipping levels

In this way, we can, in some ways, automate the karma, and in someways advance it through our own choices; creating a hierarchy based on merit and trust.

Final Thoughts

• Some smart filtering, so that “You’re an idiot” responses don’t elevate a thread would be good
  • That, or just handle it biologically — Don’t respond to people in negative ways
• Implementing this as a ML (in terms of interaction) is likely the only way to get some of the higher internals folks using it, a web interface [for the messages] just won’t fly
• Personal filters would be handled at master.php.net or maybe a new web interface for this

Now, obviously, this is a huge undertaking; certainly not one any single person could complete on their own… but it’s food for thought.

- Davey

Most developers mistake the word environment for the word “technology” or “software”. For example, you develop in a “JSP environment”, or a “LAMP environment”. This is a crucial mistake that is made time and time again, and unfortunately, it hurts companies because the decision makers either make the same mistake, or they listen to those making the mistake.

I’ve said numerous times, that you can use any language to do anything. Yes, there are practical limits, using C to write a dynamic website isn’t a great idea, nor is using PHP for password cracking. Each language has it’s own strengths and weaknesses; good developers however, know what these are and work with their strengths and work around their weaknesses. This post isn’t going to focus much on languages; I figure everybody reading has already chosen PHP and knows why.

What I will say is this: Ruby, Python, PHP, Perl, Java and .NET all bring the same capabilities to the table (some things are easier in some, and some more difficult in others). You can create any solution you want in each of these languages, in an efficient, well thought out, well developed way. Yahoo! could be written in Python. How do we know this? because Google uses it. Microsoft uses .NET for it’s web presence, and while you might not like to use it, it still stands up to more stress than most of the websites on the internet.

With this in mind, I then would say that the language capabilities themselves, are the least important factor in choosing your environment.

This then brings me neatly to what else that environment encompasses. These, to me, fall into three categories. People, knowledge and penetration.

Access to People

To put it bluntly, if you can’t find the people to write your code, you’re screwed. While you may know what you’re doing, and you have enough people now: your team will need to grow. If you can’t find people around you to hire, then what?

There are estimates that for every 100 PHP developers, there are 42 Perl developers, there are 12 Python developers and 4 Ruby developers. (see: here)

Some will say that this is because there is a lot of bad PHP developers. I will agree to a point, but that point is that there are just so damn many, that there are still more great developers to pick from than with other languages.

Access to Knowledge

While this one is more subjective, I believe that the sheer number of PHP developers generate far more useful knowledge from which to learn, cherry pick ideas and utilize them. Add to that the extensive number of books, and our excellent php|architect magazine; as well as the training and teachings provided by MTA, Zend and ibuildings, we have more going for us than most every other language with, I think, the exception of Java in terms of professionally backed learning.

Market Penetration

Simply put, the availability of PHP as a platform is there from the cheapest virtualhost, to the most expensive dedicated systems. It has gained wide acceptance from smaller companies, because it is cheap and reliable, and from enterprise companies such as IBM, Oracle and even Microsoft because they see that the ability is there for PHP to operate in that space and a huge number of developers willing to make that happen.

Conclusion

No other language can claim this trifecta, sure, there are a lot of .NET and Java developers, but a lot that goes on happens behind closed doors in big enterprises, and the knowledge is not shared. And while this isn’t true of Python, or Ruby, they lack in numbers and knowledge comparatively. This is why I choose PHP.

- Davey

Today, a friend asking me if it was possible to get a prepared statement back from PDO with the values placeholders replaced, finally caught me in a moment where I could do something about it.

I wrote a thin PDO wrapper class that will [imperfectly, I'm sure] return the completed query.

It supports bound parameters, values and the array key->value methods of passing in values to prepared queries. You can see the code and examples below:

<?php
class PDOTester extends PDO {
	public function __construct($dsn, $username = null, $password = null, $driver_options = array())
	{
		parent::__construct($dsn, $username, $password, $driver_options);
		$this->setAttribute(PDO::ATTR_STATEMENT_CLASS, array('PDOStatementTester', array($this)));
	}
}

class PDOStatementTester extends PDOStatement {
	const NO_MAX_LENGTH = -1;

	protected $connection;
	protected $bound_params = array();

	protected function __construct(PDO $connection)
	{
		$this->connection = $connection;
	}

	public function bindParam($paramno, &$param, $type = PDO::PARAM_STR, $maxlen = null, $driverdata = null)
	{
		$this->bound_params[$paramno] = array(
			'value' => &$param,
			'type' => $type,
			'maxlen' => (is_null($maxlen)) ? self::NO_MAX_LENGTH : $maxlen,
			// ignore driver data
		);

		$result = parent::bindParam($paramno, $param, $type, $maxlen, $driverdata);
	}

	public function bindValue($parameter, $value, $data_type = PDO::PARAM_STR)
	{
		$this->bound_params[$parameter] = array(
			'value' => $value,
			'type' => $data_type,
			'maxlen' => self::NO_MAX_LENGTH
		);
		parent::bindValue($parameter, $value, $data_type);
	}

	public function getSQL($values = array())
	{
		$sql = $this->queryString;

		if (sizeof($values) > 0) {
			foreach ($values as $key => $value) {
				$sql = str_replace($key, $this->connection->quote($value), $sql);
			}
		}

		if (sizeof($this->bound_params)) {
			foreach ($this->bound_params as $key => $param) {
				$value = $param['value'];
				if (!is_null($param['type'])) {
					$value = self::cast($value, $param['type']);
				}
				if ($param['maxlen'] && $param['maxlen'] != self::NO_MAX_LENGTH) {
					$value = self::truncate($value, $param['maxlen']);
				}
				if (!is_null($value)) {
					$sql = str_replace($key, $this->connection->quote($value), $sql);
				} else {
					$sql = str_replace($key, 'NULL', $sql);
				}
			}
		}
		return $sql;
	}

	static protected function cast($value, $type)
	{
		switch ($type) {
			case PDO::PARAM_BOOL:
				return (bool) $value;
				break;
			case PDO::PARAM_NULL:
				return null;
				break;
			case PDO::PARAM_INT:
				return (int) $value;
			case PDO::PARAM_STR:
			default:
				return $value;
		}
	}

	static protected function truncate($value, $length)
	{
		return substr($value, 0, $length);
	}
}

$pdo = new PDOTester('sqlite::memory:');
$pdo->query('CREATE TABLE foo (bar TEXT, baz TEXT, num NUMERIC, empty TEXT)');
$query = $pdo->prepare('SELECT * FROM foo WHERE bar = :bar AND baz = :baz');

// Test with passed in array
echo $query->getSQL(array(':bar' => 'foo', ':baz' => 'bat')) . PHP_EOL;

$query = $pdo->prepare('SELECT * FROM foo WHERE bar = :bar AND baz = :baz AND num = :num AND empty=:empty');

// Test with bound params and values
$bar = 'bar';
$baz = 'baz';
$num = '0.1';
$empty = 'empty!!';

// Bind Param
$query->bindParam(':bar', $bar);

// Bind Value
$query->bindValue(':baz', $baz);

// Bind With types
$query->bindParam(':num', $num, PDO::PARAM_INT);
$query->bindParam(':empty', $empty, PDO::PARAM_NULL);

echo $query->getSQL() . PHP_EOL;

// Change the vars
$bar = 'foo';
$baz = 'bat';
$num = '2.6';
$empty = 'blah!';

echo $query->getSQL() . PHP_EOL;

// Bind with length
$query->bindParam(':bar', $bar, PDO::PARAM_STR, 2);

echo $query->getSQL() . PHP_EOL;
?>

This results in the following output:

SELECT * FROM foo WHERE bar = 'foo' AND baz = 'bat'
SELECT * FROM foo WHERE bar = 'bar' AND baz = 'baz' AND num = '0' AND empty=NULL
SELECT * FROM foo WHERE bar = 'foo' AND baz = 'baz' AND num = '2' AND empty=NULL
SELECT * FROM foo WHERE bar = 'fo' AND baz = 'baz' AND num = '2' AND empty=NULL

Hopefully, this will help you get a somewhat better idea of what’s going on

- Davey

 Simply download and unpack the ZIP file (2.7MB) and then in NetBeans, choose Tools » Plugins, click the Downloads tab, and then Add Plugins… 

 In the file picker, just select all, and click Open. Next, click Install

 In a world where everything “Just Works”, that would be it. But unfortunately, on OSX, it’s sometimes not. While the plugin appears to function fine, when you to make it grab tickets, you will get a wonderful uncaught exception dialog.

 By default, OS X Leopard does not have the Java 6 (1.6) environment, so check if you have it. You can do so by looking to see if you have /System/Library/Frameworks/JavaVM.framework/Versions/1.6, if not you will need to grab Apples Java for Mac OS X Update 1 (57MB), Update 2 (136.4MB) and Update 3 (3MB) 

 Finally, even if you have Java 1.6, you will probably need to modify your NetBeans config to use it. This can be found in /Applications/NetBeans/NetBeans$ver.app/Contents/Resources/NetBeans/etc/netbeans.conf.

Open up this file, and look for: 

netbeans_jdkhome=/System/Library/Frameworks/JavaVM.framework/Versions/1.5/Home

And change it to:

netbeans_jdkhome=/System/Library/Frameworks/JavaVM.framework/Versions/1.6/Home

Once this is done, just re-start NetBeans.

Next, go to Window » Cube°n » Task Repositories, and a new pane will appear in the bottom left under your Project/Files/Services pane. Right click in the new pane and choose New Task Repository; choose Trac Repository and give it an Alias (a name), and the rest of the information it needs.

Choose Validate Connection and then Finish. If you encounter an SSL error, see the Cube°n FAQ.

Finally, you can add queries to grab whatever collection of tickets you would like. You use the TracLinks query syntax which means you can create complex filters.

I have a filter for My Active Tickets, “owner=USERNAME&status!=closed|testing” and one for each milestone so I can see and accept tickets that are not mine, “milestone~=iris&owner!=USERNAME&status!=closed|testing”

Working with Tasks

One of the biggest benefits of working with Cube°n [and Mylar] is the ability to associate a context with them; that is your open files, and other related tickets. To do this, simply click the Activate button. Once this is done, any currently open files are automatically associated with the ticket… or at least they would be if you were using Java. *sigh*

Still, it’s a start. Hopefully the guys at Cube°n will fix this oversight soon enough, and us lowly PHP developers will get in on the fun.

They are already working on some neat features, such as allowing you to commit to RCS using the task context (i.e. close a task, and commit all associated files), as well as associating debugger breakpoints and watches with the task; allowing you to make those task specific, even when two separate issues touch the same files. Both of these features would be great, making sure you don’t forget to commit a related file, and imagine being able to go back to a task 6 months later because a related issue has come up and having all your original files and debugging settings immediately available.

- Davey

I can take each of the requirements and do a single post per requirement with a writeup about it in detail for each of the 4 IDEs — then I was thinking for each new IDE I try, I can hit those same points. Or I can write up specifically on a single editor at a time, covering all of the requirements and I will also then review anything else about the editor etc.

I’d like to do a single post on the cross-platform technologies in play (Java Vs XUL) and on the Eclipse and Netbeans platforms (outside of any PHP plugins), but these fall outside of the scope of the original intention of reviewing the IDEs.

There are several incarnations of Eclipse I would like to review: Zend Studio for Eclipse, Aptana and PHPEclipse, I think perhaps I need a comparison table for Eclipse solutions on their own

Thoughts?

- Davey

Check out the IDE Comparison

I plan to follow up the page with in-depth posts on each requirement and how each IDE matches up. Furthermore, any new IDEs I try will get a write-up on each of the requirements. Look for these in the coming weeks and months

- Davey

Update: surprisingly, it took over 2hrs to get an e-mail telling me that VIM was the perfect IDE; I expected it far sooner. VIM might be the perfect IDE for some, but not for me. Though I do use it daily as a text editor on remote systems and like it for that purpose. Also, it’s great for editing xdebug human-readable traces thanks to Derick Rethans vim syntax file.