chad's blog http://2tbsp.com/blog/1/atom/feed 2007-09-30T00:23:19-07:00 How to Remove a Workspace in Eclipse under OS X http://2tbsp.com/node/93 2008-05-02T13:50:33-07:00 2008-05-03T10:28:03-07:00 chad The other morning, before I had my morning coffee, I fired up Eclipse and when prompted to select my Workspace, I entered my password and hit return. Still in a haze, I wondered why I was looking at the default Workspace. After restarting and seeing my password in the selected Workspace I finally woke up. D'oh!

]]> The other morning, before I had my morning coffee, I fired up Eclipse and when prompted to select my Workspace, I entered my password and hit return. Still in a haze, I wondered why I was looking at the default Workspace. After restarting and seeing my password in the selected Workspace I finally woke up. D'oh!

So where the heck is this Workspace list stored? I couldn't find the list under preferences. There wasn't a hidden settings file in my home directory. I then started poking around in /Applications/eclipse. Ah ha! Here's the setting file that contains recent workspaces.

  1. /Applications/eclipse/configuration/.settings/org.eclipse.ui.ide.prefs

Opened this file up and deleted the workspace from the RECENT_WORKSPACES. I had to make sure that I didn't remove to many line feeds (\n) which separate each workspace. I'm not sure why eclipse stores these preferences in the Applications folder. Why isn't this information stored in my home directory?

Oh well. I may never make this mistake again, but you never know. Hope this helps someone else out there.

]]> YUI Rollover Part 2: Improving JavaScript Performance and Scalability http://2tbsp.com/node/92 2008-05-01T16:14:33-07:00 2008-05-01T16:27:40-07:00 chad In my previous article we traded in old school JavaScript habits for unobtrusive methods and the Yahoo! User Interface Library (YUI). The YUI's Event and DOM extensions greatly simplify basic DOM scripting tasks. Let's build on this foundation and improve the rollover script's performance and scalability.

]]> In my previous article we traded in old school JavaScript habits for unobtrusive methods and the Yahoo! User Interface Library (YUI). The YUI's Event and DOM extensions greatly simplify basic DOM scripting tasks. Let's build on this foundation and improve the rollover script's performance and scalability.

Thanks to Nick and Dirk for their comments on event listeners impact on script performance. Nick points out the fact that JavaScript performance will degrade as more buttons are added to the example rollover menu. The use of a DOM scripting technique called event delegation can greatly reduce performance hits sustained through the assignment of event listeners.

Improve Performance through Event Delegation and Bubbling

The current version of the rollover script loops through the menu container and assigns event listeners to each button. Assigning listeners to child elements this way can, and will, have a negative impact on performance.

Illustration of the DOM bubbling effect

credit: Senocular.com

Let's use event delegation to simplify things. Event delegation leverages an inherit browser behavior called "event bubbling". By default, when an event happens to an element's descendents, the event "bubbles up" through the DOM to the parent.

This means that we can assign event listeners to the menu rather than every button it contains. In our rollover example we can reduce the number of event listeners from 3 to just 1. Wow! We've just cut the work required to assign listeners by 66%. You can see that the performance savings of event delegation add up quickly.

We'll use the same HTML markup and CSS from the previous example. 

  1. <div id="menu">
  2.   <div class="btn">
  3.     <a href="#">Link 1</a>
  4.     <p>Description for link 1</p>
  5.   </div>
  6.   <div class="btn">
  7.     <a href="#">Link 2</a>
  8.     <p>Description for link 2</p>
  9.   </div>
  10.   <div class="btn">
  11.     <a href="#">Link 3</a>
  12.     <p>Description for link 3</p>
  13.   </div>
  14. </div>

Here's the updated script using the YUI's Event and DOM extensions. The script now uses Event's handy getTarget() method which captures the target of the current event. 

  1. <script type="text/javascript">
  2. // Create the menu object
  3. var roll = {
  4.   // The rollover function
  5.   over : function(e) {
  6.     // Capture the current target element
  7.     var elTarget = YAHOO.util.Event.getTarget(e);
  8.     // Step through this section of the DOM looking for a btn 
  9.     // in the target's ancestory, stop at the menu container
  10.     while (elTarget.id != 'menu') {
  11.       // If we're over a btn, turn it on and stop
  12.       if (YAHOO.util.Dom.hasClass(elTarget, 'btn')) { 
  13.         YAHOO.util.Dom.addClass(elTarget, 'btn-over');
  14.         break;
  15.       // Keep looking one level up
  16.       } else {
  17.         elTarget = elTarget.parentNode;
  18.       }
  19.     }
  20.   },
  21.   // Reset menu styles
  22.   out : function(e) {
  23.     var btns = YAHOO.util.Dom.getElementsByClassName('btn', 'div', this);
  24.     YAHOO.util.Dom.removeClass(btns, 'btn-over');
  25.   }
  26. };
  27. // Assign event listeners to just the menu
  28. YAHOO.util.Event.on('menu', 'mouseover', roll.over);
  29. YAHOO.util.Event.on('menu', 'mouseout', roll.out);
  30. </script>

Take a look at the functioning example.

Allow for Growth

The updated rollover script gives us a big improvement in performance, but it doesn't scale at all. The script includes hardcoded references to a single menu. What if we want to add additional menus?

First, let's update the stylesheet to use classes, instead of an ID, to target and style rollover menus.

  1. .rollover { 
  2.   font: 85% Arial, Helvetica, san-serif;
  3. }
  4. .rollover .btn, .rollover .btn-over {
  5.   background-color: #e7e7e7;
  6.   border-width: 2px;
  7.   border-style: solid;
  8.   color: #666;
  9.   float: left;
  10.   margin: 0 5px;
  11.   width: 150px;
  12. }
  13. .rollover .btn {
  14.   border-color: #999;
  15. }
  16. .rollover .btn a, .rollover .btn-over a { 
  17.   color: #fff;
  18.   background-color: #999;
  19.   display: block;
  20.   padding: .3em .5em;
  21.   text-decoration: none;
  22. }
  23. .rollover p { 
  24.   clear: both;
  25.   padding-top: 1em;
  26. }
  27. .btn p {
  28.   padding: 0 .5em;
  29. }
  30.  
  31. /* Rollover styles */
  32. .rollover .btn-over {
  33.   border-color: #666;
  34.   color: #000;
  35. }
  36. .rollover .btn-over a {
  37.   background-color: #666;
  38. }

Next, apply the rollover class to a menu, or two.

  1. <div id="menu1" class="rollover">
  2.   <div class="btn">
  3.     <a href="#">Link 1</a>
  4.     <p>Description for link 1</p>
  5.   </div>
  6.   <div class="btn">
  7.     <a href="#">Link 2</a>
  8.     <p>Description for link 2</p>
  9.   </div>
  10.   <div class="btn">
  11.     <a href="#">Link 3</a>
  12.     <p>Description for link 3</p>
  13.   </div>
  14.   <p>Here's a menu.</p>
  15. </div>
  16.  
  17. <div id="menu2" class="rollover">
  18.   <div class="btn">
  19.     <a href="#">Link 3</a>
  20.     <p>Description for link 3</p>
  21.   </div>
  22.   <div class="btn">
  23.     <a href="#">Link 4</a>
  24.     <p>Description for link 4</p>
  25.   </div>
  26.   <div class="btn">
  27.     <a href="#">Link 5</a>
  28.     <p>Description for link 5</p>
  29.   </div>
  30.   <p>Here's another menu.</p>
  31. </div>

The script now needs to include a method for adding event listeners to each of the rollover menus. This task is handled by menu.init() which is run once the page is loaded. The only other change is the use of the rollover class to stop our walk of the DOM. 

  1. <script type="text/javascript">
  2. // Create the menu object
  3. var roll = {
  4.   // Assign event listeners to all rollover menus, 
  5.   // Isn't getElementsByClassName wonderful?!
  6.   init : function() {
  7.     var menus = YAHOO.util.Dom.getElementsByClassName('rollover', 'div');
  8.     YAHOO.util.Event.on(menus, 'mouseover', roll.over);    
  9.     YAHOO.util.Event.on(menus, 'mouseout', roll.out);
  10.   },
  11.   // The rollover function, only change is using className instead of ID
  12.   over : function(e) {
  13.     // Capture the current target element
  14.     var elTarget = YAHOO.util.Event.getTarget(e);
  15.     // Step through this section of the DOM looking for a btn 
  16.     // in the target's ancestory, stop at the menu container
  17.     while (elTarget.className != 'rollover') {
  18.       // If we're over a btn, turn it on and stop
  19.       if (YAHOO.util.Dom.hasClass(elTarget, 'btn')) { 
  20.         YAHOO.util.Dom.addClass(elTarget, 'btn-over');
  21.         break;
  22.       // Keep looking one level up
  23.       } else {
  24.         elTarget = elTarget.parentNode;
  25.       }
  26.     }
  27.   },
  28.   // Reset menu styles
  29.   out : function(e) {
  30.     var btns = YAHOO.util.Dom.getElementsByClassName('btn', 'div', this);
  31.     YAHOO.util.Dom.removeClass(btns, 'btn-over');
  32.   }
  33. };
  34.  
  35. // Initialize all rollover menus when the page loads
  36. YAHOO.util.Event.on(window, 'load', roll.init);
  37. </script>

And here's the working example of the rollover script that scales.

Conclusion

So there you have it. A few simple examples illustrating how to improve performance and scalability in JavaScript. These are basic examples and hopefully they'll help you refactor your scripts to meet your site's needs. I highly recommend reading Peter-Paul Koch's explanation of mouse events and event order in the DOM and how each browser handles them. They helped me tremendously.

]]> Introduction to Unobtrusive JavaScript, DOM Scripting, and the Yahoo! User Interface (YUI) Library http://2tbsp.com/node/91 2008-04-24T22:07:15-07:00 2008-05-06T16:01:18-07:00 chad If you know JavaScript but have yet to make the leap to unobtrusive JavaScript, read on. I'll demonstrate how to upgrade a traditional DHTML rollover to an unobtrusive script and then to a script that leverages the Yahoo! User Interface Library's (YUI).

]]> If you know JavaScript but have yet to make the leap to unobtrusive JavaScript, read on. I'll demonstrate how to upgrade a traditional DHTML rollover to an unobtrusive script and then to a script that leverages the Yahoo! User Interface Library's (YUI).

What is Unobtrusive JavaScript and DOM Scripting?

Rather than hardcoding event handlers as HTML attributes, unobtrusive JavaScript assigns them using the DOM. Well-structured, valid HTML is a prerequisite to DOM scripting. Documents should declare a DOCTYPE, they should validate against the DOCTYPE, and presentational styles should be applied with CSS (read "should" as "life will be easier for everyone if you do"). Use a few targeted CSS ID and class selectors to define page layout. Don't go overboard on defining selectors, remember, descendent selectors are your friend.

I'll use a simple text-based rollover for demonstration purposes. In a perfect world, with perfect browsers, this effect would be created using the CSS pseudo hover class but, as you've probably guessed, it doesn't work in Internet Explorer 6. Here's a screenshot of what we're building.

The Rollover, Obtrusively Old School Style

First, the style sheet. Nothing wrong here as long as these are stored in an external CSS file.

  1. #menu { 
  2.   font: 85% Arial, Helvetica, san-serif;
  3. }
  4. #menu .btn {
  5.   background-color: #e7e7e7;
  6.   border-color: #999;
  7.   border-style: solid;
  8.   border-width: 2px;
  9.   color: #666;
  10.   float: left;
  11.   margin: 0 5px;
  12.   width: 150px;
  13. }
  14. #menu .btn a { 
  15.   color: #fff;
  16.   background-color: #999;
  17.   display: block;
  18.   padding: .3em .5em;
  19.   text-decoration: none;
  20. }
  21. #menu p {
  22.   padding: 0 .5em;
  23. }

Next the markup. The old school technique involves writing the rollover script functions and triggering them from event attributes. More complex actions required more and more stuff muddying up what was a perfectly readable HTML document. 

  1. <div id="menu">
  2.   <div id="btn1" class="btn" onmouseover="rollOver('btn1')" onmouseout="rollOut('btn1')">
  3.     <a href="#">Link 1</a>
  4.     <p>Description for link 1</p>
  5.   </div>
  6.   <div id="btn2" class="btn" onmouseover="rollOver('btn2')" onmouseout="rollOut('btn2')">
  7.     <a href="#">Link 2</a>
  8.     <p>Description for link 2</p>
  9.   </div>
  10.   <div id="btn3" class="btn" onmouseover="rollOver('btn3')" onmouseout="rollOut('btn3')">
  11.     <a href="#">Link 3</a>
  12.     <p>Description for link 3</p>
  13.   </div>
  14. </div>

Finally, the JavaScript. A function to set styles on mouseover and another to restore the original styles on mouseout. If you change a color in the stylesheet, you'll have to change it here too.

  1. <script type="text/javascript">
  2. // Apply rollover styles
  3. function rollOver(el) {
  4.   // Get the elements
  5.   var thisBtn = document.getElementById(el);
  6.   var thisLink = thisBtn.getElementsByTagName('a');
  7.   // Change their styles
  8.   thisLink[0].style.backgroundColor = '#666';
  9.   thisBtn.style.borderColor = '#666';
  10.   thisBtn.style.color = '#000';
  11. }
  12. // Reset styles
  13. function rollOut(el) {
  14.   // Get the elements
  15.   var thisBtn = document.getElementById(el);
  16.   var thisLink = thisBtn.getElementsByTagName('a');
  17.   // Change their styles back again
  18.   thisLink[0].style.backgroundColor = '#999';
  19.   thisBtn.style.borderColor = '#999';
  20.   thisBtn.style.color = '#666';
  21. }
  22. <script>

Make the Script Less Obtrusive

Let's clean things up a bit. Strip those event handlers from the button containers. 

  1. <div id="menu">
  2.   <div class="btn">
  3.     <a href="#">Link 1</a>
  4.     <p>Description for link 1</p>
  5.   </div>
  6.   <div class="btn">
  7.     <a href="#">Link 2</a>
  8.     <p>Description for link 2</p>
  9.   </div>
  10.   <div class="btn">
  11.     <a href="#">Link 3</a>
  12.     <p>Description for link 3</p>
  13.   </div>
  14. </div>

Now, make a few CSS adjustments and additions to define the hover styles where they belong, in the style sheet.

  1. #menu { 
  2.   font: 85% Arial, Helvetica, san-serif;
  3. }
  4. #menu .btn, #menu .btn-over {
  5.   background-color: #e7e7e7;
  6.   border-width: 2px;
  7.   border-style: solid;
  8.   color: #666;
  9.   float: left;
  10.   margin: 0 5px;
  11.   width: 150px;
  12. }
  13. #menu .btn {
  14.   border-color: #999;
  15. }
  16. #menu .btn a, #menu .btn-over a { 
  17.   color: #fff;
  18.   background-color: #999;
  19.   display: block;
  20.   padding: .3em .5em;
  21.   text-decoration: none;
  22. }
  23. #menu p {
  24.   padding: 0 .5em;
  25. }
  26.  
  27. /* Rollover styles */
  28. #menu .btn-over {
  29.   border-color: #666;
  30.   color: #000;
  31. }
  32. #menu .btn-over a {
  33.   background-color: #666;
  34. }

With that done, hook it all up with the script.

  1. <script type="text/javascript">
  2. // Attach event listeners to the buttons
  3. function findButtons() {
  4.   var menu, btns, i;
  5.   // Get the menu element to access the btn divs
  6.   menu = document.getElementById('menu');
  7.   btns = menu.getElementsByTagName('div');
  8.   for (i=0; i<btns.length; i++) {
  9.     // Attach event listeners for rollovers to the btns
  10.     if (/btn/.test(btns[i].className)) { 
  11.       btns[i].onmouseover = function(){roll(this);};
  12.       btns[i].onmouseout = function(){roll(this);};
  13.     }
  14.   }
  15. }
  16. // Attached to the buttons and ready to roll
  17. function roll(o) {
  18.   // btn is our off state, so turn it on
  19.   if (o.className == 'btn') {
  20.     o.className = 'btn-over';
  21.   // Otherwise, turn it off
  22.   } else {
  23.     o.className = 'btn';
  24.   }
  25. }
  26. // Initialize the rollover
  27. window.onload = function() {
  28.   findButtons();
  29. }
  30. </script>

Everything is now in its proper place. No more JavaScript in the HTML and styles aren't defined in the JavaScript. This will be much easier to maintain.

Unobtrusive, the YUI Style

YUI is one of the many JavaScript libraries that have gained attention in recent years. Some say it's too big and bulky and that may be true in certain cases, like creating a simple rollover. But it's rare in our Web 2.0 world that a site's only JavaScript-powered feature is a rollover. YUI is my current JavaScript framework of choice because along with being feature-rich, it's well documented, tested, and supported.

So here's the rollover script powered by the YUI's Yahoo! Global Object, and DOM and Event extensions. 

  1. <script type="text/javascript" src="http://yui.yahooapis.com/2.5.1/build/yahoo-dom-event/yahoo-dom-event.js"></script>
  2. <script type="text/javascript">
  3. // Create a menu object, put everything we need into it
  4. var menu = {
  5.   // Initialize the menu rollover
  6.   init : function() {
  7.     // Get the btn elements
  8.     btns = YAHOO.util.Dom.getElementsByClassName('btn', 'div', 'menu');
  9.     // Assign event listeners to the btns
  10.     for (var i=0; i<btns.length; i++) {
  11.       YAHOO.util.Event.addListener(btns[i], 'mouseover', menu.roll, i);
  12.       YAHOO.util.Event.addListener(btns[i], 'mouseout', menu.roll);
  13.     }
  14.   },
  15.   // First, turn 'em all off, then turn one on
  16.   roll : function(e, i) {
  17.     YAHOO.util.Dom.removeClass(btns, 'btn-over');
  18.     YAHOO.util.Dom.addClass(btns[i], 'btn-over');
  19.   }
  20. };
  21. // Initialize the menu
  22. YAHOO.util.Event.on(window, 'load', menu.init);
  23. </script>

The YUI version basically works just like the unobtrusive version. Yahoo! provides hosted versions of all the YUI extensions, just add a link to yahoo-dom-event.js. With the help of the Yahoo! Global Object and DOM and Event extensions, it's easy to grab button elements and assign event handlers that trigger the roll function. The main difference here is that everything is neatly encapsulated into the menu object. The YUI's getElementsByClassName and remove/addClass methods make DOM scripting a breeze.

Take a look at the final product.

Conclusion

Hopefully these basic examples serve as a kick in the rear for those clinging to those old school ways. Now that you have the basics of event handling down, I'll show you how to improve the scripts performance through event delegation and how to make it scalable to power multiple rollover menus.

]]> Subversion Administration: Separate an SVN Repository into Individual Projects http://2tbsp.com/node/88 2008-03-20T21:02:15-07:00 2008-03-22T08:50:26-07:00 chad I've been using Subversion since the Gallery Project switched to it from CVS a few years back. I decided to install Subversion to manage my freelance projects last year and am getting up to speed on repository administration. I flip-flopped for a while on whether to keep projects in a single or separate repositories. I initially decided to keep everything in one repository, but later decided to separate them out. Fortunately, the svnadmin and svndumpfilter utilities make it relatively simple to separate repositories into individual projects.

]]> I've been using Subversion since the Gallery Project switched to it from CVS a few years back. I decided to install Subversion to manage my freelance projects last year and am getting up to speed on repository administration. I flip-flopped for a while on whether to keep projects in a single or separate repositories. I initially decided to keep everything in one repository, but later decided to separate them out. Fortunately, the svnadmin and svndumpfilter utilities make it relatively simple to separate repositories into individual projects.

My goal is to create two new projects from folders stored in the trunk of a single repository. My repository's history isn't complex—it doesn't contain tags or branches yet. You'll need to put a bit more thought into how to deal with existing tags and branches.

My current svn root layout is: 

  1. /svnroot
  2.     /branches
  3.     /tags
  4.     /trunk
  5.         /project1
  6.         /project2

The desired layout is: 

  1. /svnroot
  2.     /project1
  3.         /branches
  4.         /tags
  5.         /trunk
  6.     /project2
  7.         /branches
  8.         /tags
  9.         /trunk

The basic steps to separate these repositories are:

  1. Dump the current repository
  2. Separate folders in the dump to separate files with svndumpfilter
  3. Create new repositories
  4. Load the filtered dump files into the new repositories
  5. Cleanup the new repository layout, move files from trunk/projectN to trunk/
  6. Delete the original branches, tags, and trunk repositories from svnroot

I'll use tmp as working directory to dump and filter files.

Dump the current repository

  1. svnadmin dump /svnroot/originalproject &gt; /tmp/original.dump

Separate folders to separate files with svndumpfilter

  1. cat /tmp/original.dump | svndumpfilter --drop-empty-revs --renumber-revs include trunk/project1 &gt; /tmp/project1.dump
  2. cat /tmp/original.dump | svndumpfilter --drop-empty-revs --renumber-revs include trunk/project2 &gt; /tmp/project2.dump

The key here is the include option which targets the project folder(s). There's also an exclude option that might come in handy if you're trying to remove one folder from a group of many. The --drop-empty-revs and --renumber-revs options remove commit log messages for other folders and renumber the remaining revision numbers.

Create new repositories

  1. svnadmin create /svnroot/project1
  2. svnadmin create /svnroot/project2

Load the filtered dump files into the new repositories

  1. svnadmin load /svnroot/project1 &lt; /tmp/project1.dump 
  2. svnadmin load /svnroot/project2 &lt; /tmp/project2.dump

Cleanup new repository layout, move files from trunk/projectN to trunk/

Each repository layout now looks something like: 

  1. /svnroot
  2.     /project1
  3.         /branches
  4.         /tags
  5.         /trunk
  6.             /project1
  7.                 file1
  8.                 ...
  9.                 fileX

But they should look like: 

  1. /svnroot
  2.     /project1
  3.         /branches
  4.         /tags
  5.         /trunk
  6.             file1
  7.             ...
  8.             fileX

Subversion doesn't allow wildcard gobling, so it's impossible to do something like: 

  1. svn move trunk/project1/* trunk/

It was possible to edit path information in the project dump files before loading them, but it seemed easier to check out a working copy of each, move things around, and then commit the changes. 

  1. svn checkout file :///svnroot/project1 /tmp/project1
  2. cd /tmp/project1/trunk

Now, a little shell work to move things around. Thanks Tigris! PLEASE NOTE: Use this at your own risk. Back up your repository before trying the following or be ready to use svn revert. 

  1. for i in /tmp/project1/trunk/project1/*; do svn mv $i /tmp/project1/trunk; done
  2. svn commit -m "Moved all project files to trunk"
  3. svn remove /tmp/project1/trunk/project1
  4. svn commit -m "Removed obsolete project1 folder after moving its contents to trunk"

Lather, rinse, repeat.

At some point I'll probably back track and write a post on installing and configuring Subversion with MacPorts but that's it, at least for now.

]]> Notes on Choosing a PHP Framework: A Comparison of CakePHP and the Zend Framework http://2tbsp.com/node/87 2008-02-15T15:05:17-08:00 2008-03-20T20:19:19-07:00 chad UPDATE:Parlez vous Français? Guillaume Rossolini has created a French translation of this article.

Are you considering using a PHP framework for your next project? If so, this article's for you. I've narrowed down my choices to CakePHP and the Zend Framework and have documented my findings here.

]]> UPDATE:Parlez vous Français? Guillaume Rossolini has created a French translation of this article.

Are you considering using a PHP framework for your next project? If so, this article's for you. I've narrowed down my choices to CakePHP and the Zend Framework and have documented my findings here.

Four or five years ago I began researching PHP application frameworks. At the time, the pickings were very slim, especially when compared to those available to Java developers. On the advice of an ex-Coldfusion developer, I settled on the PHP port of Fusebox, the de facto Coldfusion framework. Fusebox 3 provided a convenient set of loose conventions for structuring applications, organizing code, naming files, and controlling flow. It served my development team well and applications we built with it are still up and running.

I took a two-year "break" from development and upon my return I found more PHP frameworks than you can shake a stick at. Now I need to find a solid MVC-based framework and after reading dozens of articles and completing a few tutorials, I've narrowed my focus to CakePHP and the Zend Framework.

Before going further, let it be known that my point of view is that of someone with plenty of application development experience but without a formal IT or CS degree. I can't go on about the merits of one design pattern vs. another. I do, however, understand the need for convention, the advantages of modularity, and the efficiency of easily repeatable processes.

Please note that symfony, Prado, Code Ignitor, and many of the other PHP frameworks all look quite capable of meeting most project needs. If you're a fanboy of another framework, please don't espouse it's merits here. I am, however, interested in hearing about your general experience in learning a framework, particularly in the context of your professional background.

Here's a comparison and a few conclusions after spending a bit of time with both CakePHP and the Zend Framework. Please note that my quality scale range is: poor, fair, good, excellent.

Feature Comparison of CakePHP and the Zend Framework
Feature
CakePHP Zend Framework Notes
License