CodeForest - web development and programming blog

GIT vs SVN

Zvonko — Sun, 05 Feb 2012 16:08:57 +0000

Revision control, also known as version control, source control or software configuration management (SCM), is the management of changes to documents, programs, and other information stored as computer files.

Version control systems provide the ability to track (and potentially revert) incremental changes to files, reporting them to a mailing list as they are made, and can be used concurrently by many developers.

Distributed vs Centralized

To better understand the comparison of this two Version Control tools, first we must understand what is the difference between Centralized and Distributed (Decentralized) version control systems.

Distributed revision control (DRCS) takes a peer-to-peer approach, as opposed to the client-server approach of centralized systems. Rather than a single, central repository on which clients synchronize, each peer’s working copy of the codebase is a bona-fide repository. Distributed revision control conducts synchronization by exchanging patches (change-sets) from peer to peer. This results in some important differences from a centralized system:

No canonical, reference copy of the codebase exists by default; only working copies.
Common operations (such as commits, viewing history, and reverting changes) are fast, because there is no need to communicate with a central server.
Rather, communication is only necessary when pushing or pulling changes to or from other peers.
Each working copy effectively functions as a remote backup of the codebase and of its change-history, providing natural protection against data loss.

Other differences are as follows:

In DVCS there may be many “central” repositories.
Code from disparate repositories is merged based on a web of trust, i.e., historical merit or quality of changes.
Numerous different development models are possible, such as development / release branches or a Commander / Lieutenant model, allowing for efficient delegation of topical developments in very large projects.
Lieutenants are project members who have the power to dynamically decide which branches to merge.
Network is not involved in most operations.
A separate set of “sync” operations are available for committing or receiving changes with remote repositories.

DVCS proponents point to several advantages of distributed version control systems over the traditional centralized model:

Allows users to work productively even when not connected to a network
Makes most operations much faster since no network is involved
Allows participation in projects without requiring permissions from project authorities, and thus arguably better fosters culture of meritocracy instead of requiring “committer” status
Allows private work, so users can use their revision control system even for early drafts they do not want to publish
Avoids relying on a single physical machine as a single point of failure.
Still permits centralized control of the “release version” of the project

DVCS disadvantages:

As a disadvantage of DVCS, one could note that initial cloning of a repository is slower compared to centralized checkout, because all branches and revision history are copied. This may be relevant if access speed is low and the project is large enough.
Another problem with DVCS is the lack of locking mechanisms that is part of most centralized VCS and still plays an important role when it comes to non-mergable binary files such as graphic assets.

SVN

SVN or Subversion is Centralized Version Control (CVCS) tool and belongs to second generation of Version Control tools. It was developed in 2000 and at this moment maintained by Apache.

SVN is the third implementation of a revision control: RCS, then CVS and finally SVN. SVN offers VCS features (labeling and merging), but its tag is just a directory copy (like a branch, except you are not “supposed” to touch anything in a tag directory), and its merge is still complicated, currently based on meta-data added to remember what has already been merged.

GIT

GIT is Decentralized Version Control (DVCS) tool and belongs to third generation of Version Control tools.

GIT was initially designed and developed by Linus Torvalds for Linux kernel development. Every GIT working directory is a full-fledged repository with complete history and full revision tracking capabilities, not dependent on network access or a central server.

GIT is a file content management (a tool made to merge files), evolved into a true Version Control System, based on a DAG (Directed Acyclic Graph) of commits, where branches are part of the history of data (and not a data itself), and where tags are a true meta-data.

GIT over SVN

Distributed Nature

Git was designed from the ground up as a distributed version control system. Being a distributed version control system means that multiple redundant repositories and branching are first class concepts of the tool.

In a distributed VCS like Git every user has a complete copy of the repository data stored locally, thereby making access to file history extremely fast, as well as allowing full functionality when disconnected from the network. It also means every user has a complete backup of the repository. Have 20 users? You probably have more than 20 complete backups of the repository as some users tend to keep more than one repository for the same project. If any repository is lost due to system failure only the changes which were unique to that repository are lost. If users frequently push and fetch changes with each other this tends to be a small amount of loss, if any.

In a centralized VCS like Subversion only the central repository has the complete history. This means that users must communicate over the network with the central repository to obtain history about a file. Backups must be maintained independently of the VCS. If the central repository is lost due to system failure it must be restored from backup and changes since that last backup are likely to be lost. Depending on the backup policies in place this could be several human-weeks worth of work.

Access control

Due to being distributed, you inherently do not have to give commit access to other people in order for them to use the versioning features. Instead, you decide when to merge what from whom.

That is, because subversion controls access, in order for daily checkins to be allowed – for example – the user requires commit access. In git, users are able to have version control of their own work while the source is controlled by the repo owner.

Branch handling

Branches in Git are a core concept used every day by every user. In Subversion they are more cumbersome and often used sparingly.

The reason branches are so core in Git is every developer’s working directory is itself a branch. Even if two developers are modifying two different unrelated files at the same time it’s easy to view these two different working directories as different branches stemming from the same common base revision of the project.

Consequently Git:

Tracks the project revision the branch started from – this information is necessary to merge the branch back to trunk

Records branch merge events including:

Author, time and date
Branch and revision information
Changes made on the branch(es) remain attributed to the original authors and the original timestamps of those changes
What changes were made to complete the merge? These are attributed to the merging user
Why the merge was done (optional; can be supplied by the user).

Automatically starts the next merge at the last merge.

Knowing what revision was last merged is necessary in order to successfully merge the same branches together again in the future.

This is different to Subversion’s handling of branches. As of Subversion 1.5:

Automatically tracks the project revision the branch started from.

Like Git, Subversion remembers where a branch originated.

If the merging user had to modify 12 lines of code to complete the merge successfully you can’t tell what those 12 lines were, or how those 12 lines differ from the versions on the branches being merged.

In Subversion, branches and tags all are copies. Sometimes this is inconvenient, it is easy to check out the whole repository by mistake. Branch path and file path lie in same namespace but they have different semantics – this can be confusing.

Performance (Speed of Operation)

Git is extremely fast. Since all operations (except for push and fetch) are local there is no network latency involved to:

Perform a diff.
View file history.
Commit changes.
Merge branches.
Obtain any other revision of a file (not just the prior committed revision).
Switch branches.

Smaller Space Requirements

Git’s repository and working directory sizes are extremely small when compared to SVN.

For example the Mozilla repository is reported to be almost 12 Gb when stored in SVN using the fsfs backend. Previously, the fsfs backend also required over 240,000 files in one directory to record all 240,000 commits made over the 10 year project history. This was fixed in SVN 1.5, where every 1000 revisions are placed in a separate directory. The exact same history is stored in Git by only two files totaling just over 420 Mb. This means that SVN requires 30x the disk space to store the same history.

One of the reasons for the smaller repo size is that an SVN working directory always contains two copies of each file: one for the user to actually work with and another hidden in .svn/ to aid operations such as status, diff and commit. In contrast a Git working directory requires only one small index file that stores about 100 bytes of data per tracked file. On projects with a large number of files this can be a substantial difference in the disk space required per working copy.

As a full Git clone is often smaller than a full checkout, Git working directories (including the repositories) are typically smaller than the corresponding SVN working directories. There are even ways in Git to share one repository across many working directories, but in contrast to SVN, this requires the working directories to be collocated.

Line Ending Conversion

Subversion can be easily configured to automatically convert line endings to CRLF or LF, depending on the native line ending used by the client’s operating system. This conversion feature is useful when Windows and UNIX users are collaborating on the same set of source code.

It is also possible to configure a fixed line ending independent of the native operating system. Files such as a Makefile need to only use LFs, even when they are accessed from Windows. This can be adjusted in a global config and overridden in user configs. Binary files are checked in with a binary flag (like with CVS except that SVN does this almost always automatically) and such never get converted or keyword substituted.

Subversion also allows the user to specify line ending conversion on a file-by-file basis. But if the user does not check the binary flag on adding (Subversion prints for every added file whether it recognized it as binary) binary content might get corrupted.

Whilst Git versions prior 1.5.1 never convert files and always assume that every file is opaque and should not be modified. Git 1.5.1 and onwards make [line ending conversion configurable]. Git’s advantage over Subversion is that you do not have to manually specify which files this conversion should be applied to, it happens automatically (hence autocrlf).

SVN over GIT

Single repository

Since Subversion only supports a single repository there is little doubt about where something is stored. Once a user knows the repository URL they can reasonably assume that all materials and all branches related to that project are always available at that location. Backup to tape/CD/DVD is also simple as there is exactly one location that needs to be backed up regularly.

Since Git is distributed by nature not everything related to a project may be stored in the same location. Therefore there may be some degree of confusion about where to obtain a particular branch, unless repository location is always explicitly specified. There may also be some confusion about which repositories are backed up to tape/CD/DVD regularly, and which aren’t.

Access control

Since Subversion has a single central repository it is possible to specify read and write access controls in a single location and have them be enforced across the entire project.

Binary files

Detection and properties

Subversion can be used with binary files (it is automatically detected; if that detection fails, you have to mark the file binary yourself). Just like Git.

Only that with Git, the default is to interpret the files as binary to begin with. If you _have_ to have CR+LF line endings (even though most modern programs grok the saner LF-only line endings just fine), you have to tell Git so. Git will then autodetect if a file is text (just like Subversion), and act accordingly. Analogous to Subversion, you can correct an erroneous autodetection by setting a git attribute.

Change tracking

In an earlier version of git seemingly minor changes to binary files, such as adjusting brightness on an image, could be different enough that Git interprets them as a new file, causing the content history to split. Since Subversion tracks by file, history for such changes is maintained.

Partial Checkout/Bandwidth Requirements

With Subversion, you can check out just a subdirectory of a repository. This is not possible with Git. For a large project, this means that you always have to download the whole repository, even if you only need the current version of some sub-directory. In times where fast Internet connections are only available in most cities and traffic over mobile internet connections is expensive, git can cost much more time and money in rural areas or with mobile devices. This is arguably mitigated by the small size of git repositories.

In other cases, requirements other than the raw repository size provide the motivation for wanting a partial checkout, e.g. access control (you can’t restrict read access to part of the repository with Git) or directory layout requirements. There is no general solution for this problem other than to split the original Git repository into multiple repositories, then cloning one of the new repositories. (Git subprojects can mitigate some of the difficulties of managing the collection of new repositories.)

Shorter and Predictable Revision Numbers

First, as SVN assigns revision numbers sequentially (starting from 1) even very old projects such as Mozilla have short unique revision numbers (Mozilla is only up to 6 digits in length). Many users find this convenient when entering revisions for historical research purposes. They also find this number easy to embed into their product, supposedly making it easy to determine which sources were used to create a particular executable. However since the revision number is global to the entire repository, including all branches, there is still a question of which branch the revision number corresponds to.

Unless the last committed revision is recorded. Since revisions are global for a repository, the last committed revision makes it possible to determine which branch was used

As Git uses a SHA1 to uniquely identify a commit each specific revision can only be described by a 40 character hexadecimal string, however this string not only identifies the revision but also the branch it came from. In practice the first 8 characters tends to be unique for a project, however most users try to not rely on this over the long term. Rather than embedding long commit SHA1s into executables Git users generate a uniquely named tag. This is an additional step, but a simple one.

Secondly, SVN’s revision numbers are predictable. If the current commit is 435 the next one will be 436. It’s very easy then to go through a few sequential revisions to, e.g. look at differences, revert to an old revision to find when a regression was introduced, etc. Furthermore, without looking up any additional information, you know that commit 436 was done after 435. Similar actions and knowledge from git requires looking at the log.

Git provides shorthand syntax to partially compensate for this by allowing you to add any number of ^ after a revision to indicate how far back to go. e8fa9c^^^..e8fa9c, for instance, would show the history for e8fa9c and it’s 3 parent revisions. (However, it does not provide any shorthand syntax for going forward in time.)

Conclusion

Both VC systems can deliver almost everything a modern developer need. Personally I prefer GIT as it is more intuitive (to me) and faster. I think that it is even more reliable.

What do you think? What VCS are you using?

Invoicera: Great Online Solution To Streamline Your Invoicing Process

Zvonko — Thu, 12 Jan 2012 21:08:58 +0000

When it comes to operating an online business, creating invoice often creates a lot of trouble for businesses. It may appear like a trifle task but generating effective invoices is a must for an online business and it can be really troublesome.

However, if you have a flexible, robust and user friendly invoicing application at your disposal, you certainly need not worry. For an online business, it is imperative to keep all the financial records in a well organized manner. This is precisely what Invoicera is good at. Invoicera is a perfect online invoicing tool that can help your business run in a smooth and organized manner.

How Invoicera Can be an Asset To Your Company?

Interface and Usability of Invoicera

The very approach of Invoicera is quite professional and focused. It has a simple, user friendly and visually appealing interface that helps you generate thoroughly professional invoices. It is not overloaded with too many features and hence there is no cluttered look. Whatever needs to be done can be done easily using the features incorporated in a layout with minimal stuff in it. This makes it very easy to use and hence people with limited technical prowess can also use it effectively. You need not be a tech savvy person to work with Invoicera. That is the best thing about Invoicera. It is flexible enough to meet the requirements and capabilities of users.

Ensure Greater Transparency Through Reminders

In order to keep a track of the payments due, it is imperative to possess a tool that sends a reminder automatically to your customers and clients. And this is done with perfect precision with Invoicera tool. By keeping sending reminders on time, it also helps you to check out any customer who has not made payments for long and has gone into defaulters list. Through the Invoicera tool, you can check when your customers are logging in so that they cannot claim later of not being able to see the bills on time and thus delaying payments.

Sprucing Up With Your Company’s Template

You surely would like your clients to get a peek into what your company is like, even though they might be sitting at the farthest corners of the globe. For this, Invoicera endows you the opportunity to equip your Invoice with templates that can be customized and tweaked in accordance with your company’s profile and logo as well as your needs.

Some Other Useful Features of Invoicera

Multiple Languages and Currency Support: It helps in creating and sending invoices to your clients in their respective currency and language. Invoices in 11 languages can be created for your individual clients from all across the world. This will make your clients comfortable with meaningful and accurate invoices.
Customized Invoice Template: To make sure your business identity is reflected and represented through the invoices received by your clients, professionally multiple designed templates have been provided. For those who are not that much technically sound to customize their template, for those Invoicera has come up with a Template Customization Service, with which you can get your invoice/estimate template customized by their experts as per your requirements.
Magento Extension: With Invoicera’s magento extension, you can easily generate and send professional invoices to your customers with in real time as soon as they place an order on your store.
Invoicera with Google Apps: If you are a user of Google apps, then using Invoicera will create many benefits here. The application can easily be accessed through Google apps with single sign in process and further utilizing Invoicera with single Google sub-domain.
Invoice Scheduling: Scheduling of your invoice to be sent on specific date and time can be carved out. It would be sent automatically on the set date & time without any complexity. This will make your workload lighter.
Late Fees Payment: Invoicera gives you the option to charge late fees from the defaulters. It is just one click away and you can add late fee charges in the invoice and get paid in either percentage terms or in a fixed amount
Referral Program: With Invoicera’s Referral Program, you can earn 40% recurring commission for life time by simply getting your friends or your business contacts to sign up for the Invoicera’s paid subscription.

Final Thoughts

Thus, by doing deep invoicing review, I have found that overall Invoicera is a great package for all type of businesses that don’t require or need the complexness that full double-entry accounting system wants.

The user interface is simply great and eye catching, it’s very easy and quick to learn and simple to use and with the new addition to its features, it has added more value to basic invoicing functionality.

Invoicera with its multifunctional features will not only augment your invoicing process but also assist you to build a good relation with your customers.

Do you use Invoicera? Share your experience below….

Custom post fields using Advanced Custom Fields WordPress plugin

Zvonko — Sun, 11 Dec 2011 21:34:40 +0000

The time when WordPress was used mainly as a blog engine has passed and WordPress has become one of the most powerful Content Management Systems on the web.

Custom post types allows flexibility and give enormous power to WordPress. Usually, we use custom post types with built-in fields like excerpt, content editor, thumbnail etc.

But often, we need some special type of fields for dealing with customer wishes like date picker, relationships, file upload etc.

This is where Advanced Custom Fields plugin comes in.

Advanced custom fields overview

The Advanced Custom Fields Plugin gives you the tools to create your own custom edit screens. It’s a must have for any WordPress developer. Field types include: Wysiwyg, text, textarea, image, file, select, checkbox, page link, post object, date picker, repeater …

Advanced Custom Fields Plugin provides a simple to use interface allowing you to create, edit, reorder and completely customize your edit screens.

With Advanced Custom Fields Plugin it is not only possible to create new fields, but to hide WordPress’s default fields as well.

Installing the plugin

Installation is the same as for any WordPress plugin

Download Advanced Custom Fields plugin
Upload ‘advanced-custom-fields’ to the ‘/wp-content/plugins/’ directory
Activate the plugin through the ‘Plugins’ menu in WordPress
You may be prompted for a Database Upgrade. This is necessary for ACF to function. Please backup your database and click the Upgrade button

Usage

Once the plugin is uploaded and activated, go to Settings and click on the Adv Custom Fields link and then “Add New”. You can then give a name to your new set of fields (for example “Columns”) and add as many types of custom fields as you want. Currently supported types are:

Text
Text area
WYSIWYG Editor
Image
File
Select
Checkbox
Radio Button
True / False
Page Link
Post Object
Relationship
Date Picker
Repeater (it costs $25)

Advanced Custom Fields interface is very intuitive and it is very simple to add custom fields groups and assign them to what ever you want. You can decide what Pages, Posts or Custom Post Types you want to have this new set of Custom Fields. For example, you could have all Pages, or all Posts, or only a specific page (for example Home), or all posts in a certain category:

Advanced Custom Fields also lets you decide what other fields are available on the page. So you can remove the Content Editor, Slug, Author etc and control that and you new fields all from one place.

Advanced Custom Fields API

Plugin also have a powerful API for dealing with your fields. For example, to display a field on the theme inside a loop:

More about the API can be read on Plugin’s official documentation page.

Extending the plugin

Now, you may think that all this is enough. Well, for an average developer it should be. But, if you want to make some really cool types of fields, you can. That is the beauty of this powerful plugin.

I am going to show you how easy it is to make your own custom post field on a real life example. At the end of this tutorial, you can download custom post field type shown here.

The problem

Your customer wants to enter Events into WordPress and wants to select a location of the event by simply clicking on Google Map.

Making the Events custom post type

To make this work, we need a custom post type named Events in which our customer will enter data. First, let us see what data will be needed:

Title
Image
Description
Date
Time
Location – shown on Google Maps

Let’s begin by making this post type. Open your theme’s functions.php and enter this in:


function eventRegister()
{
$labels = array(
'name' => _x('Events', 'post type general name'),
'singular_name' => _x('Event', 'post type singular name'),
'add_new' => _x('Add New', 'portfolio item'),
'add_new_item' => __('Add New Event'),
'edit_item' => __('Edit Event'),
'new_item' => __('New Event'),
'view_item' => __('View Event'),
'search_items' => __('Search Events'),
'not_found' => __('Nothing found'),
'not_found_in_trash' => __('Nothing found in Trash'),
'parent_item_colon' => ''
);

$args = array(
'labels' => $labels,
'public' => true,
'publicly_queryable' => true,
'show_ui' => true,
'query_var' => true,
'capability_type' => 'post',
'hierarchical' => false,
'menu_position' => null,
'supports' => array('title', 'editor', 'thumbnail'),
'rewrite' => true,
'show_in_nav_menus' => true,
);

register_post_type('event' , $args);
}

add_action('init', 'eventRegister');

Save functions.php and go to WordPress admin dashboard. You will see newly created Custom Post type in the left hand menu. Wow, that was easy.

Click on Add Event and you will see something similar to this:

You can enter title, description and thumbnail image. Now, open your Advanced Custom Fields under Settings and click Add new. We will add other fields into field group called Events and it should look like this:

If you go to Add Event page now, you should see that you can now pick an event date and enter a time.

Wow, that was really easy. Now comes the hard part.

Making our own custom field type

Author of this great plugin has made our lives easier and give us a Class template for making our own custom field types for ACF. Download it here, unpack it and place it inside your active theme. I prefer to create a fields folder in my theme’s root and put this template in it.

Now rename this file to location.php. Open it up in your editor and rename the class, the name variable and the title:


class Location_field extends acf_Field
{
function __construct($parent)
{
// do not delete!
parent::__construct($parent);

// set name / title
$this->name = 'location'; // variable name (no spaces / special characters / etc)
$this->title = __("Location",'acf'); // field label (Displayed in edit screens)

} ...

Next, we must register this field so ACF plugin will know about it. Open your theme’s functions.php and enter this anywhere:


register_field('Location_field', dirname(__FILE__) . '/fields/location.php');

This function will register our field in the ACF. It has 2 parameters, the first is our Class name and the second is the path to the Class file.

If you go to Advanced Custom Fields Settings, you should see Location in the drop down:

Next thing we are going to do is create our Latitude and Longitude field that will be shown on edit screen and populated with values from Google Map.

For this, we will need create_field function inside our location.php file:


function create_field($field)
{
echo '';
echo '';
}

Save this file and go add Location field to field group inside ACF settings and Update. Now, go to entering new Event and you will see our Location text field. Everything is working, field gets saved to database. Basically, we recreated the text field.

Adding Google Map

Next task is to add a Google Map and some Google Map API, so when the user clicks on the map, we will get the Latitude and Longitude of that point and fill our Location field with it.

For this use, we will use admin_head function, which is great for inserting CSS and JavaScript:

function admin_head() { ?>

There is plenty of comments above in the code, so everything is self explanatory.

When you go to add new Event, you will now see a Google Map below your Location field. When you click on a map, Lat and Long coordinates will be filled into your Location field. You can even drag a marker on a map to change the location! How cool is that?

Now, all we have to do is to show this Event in our theme, along with a Google Map.

Showing the location in the theme

Actually, it is very easy to show the coordinates we entered in our event in the theme. Advanced Custom Fields has a great API for that.

To use the coordinates, just enter this inside your WordPress loop:


the_field('location');

But, I want to show this coordinates in a map. So create a single-event.php file in your theme’s folder and enter something like this (this is just the content inside a single post loop for TwentyEleven Theme):




Date of the event:  




 '' . __( 'Pages:', 'twentyeleven' ) . '', 'after' => '' ) ); ?>

Or, you can make a page with events and one map that will show all your events. What ever you want, is achievable now.

Conclusion

WordPress is a very powerful tool and stuff described above, makes it even more powerful. Your imagination is the limit.

Demo
Don’t hesitate to share your thoughts or ask a question below.

Programming for kids: PHP string manipulation and arrays

Zvonko — Mon, 21 Nov 2011 22:49:22 +0000

As I said earlier in my Programming for kids post, I started to teach my kids some basic programming stuff.

We were playing around with some word games and came up with a simple encrypting trick which I learned when I was a kid.

Basically, you type a word GERMANIKUS and substitute every character in that word with number, starting from 0.

So, G=0, E=1, R=2, M=3, A=4, N=5, I=6, K=7, U=8, S=9. After that, you write your message and substitute every character found in a word GERMANIKUS with a number and all other characters are just plain text.

For example, the word Codeforest would be COD1F1219T. Nice and interesting.

Now, my kids wanted to program a simple script that would take a message as a parameter and encrypt it using the above method. We chose PHP and started with writing down how the program should look and work. My kids were too eager to see the results, we first tried to work this out. This is the first version:






Programming for kids - string replacing




';
    echo 'Encoded message: ' . strtoupper($encodedMessage);
?>

Demo

Very simple and effective. I explained everything to my kids and they were eager to continue.

Next step was to build a form so you can enter the message to be encrypted.



Insert your message:








';
	echo nl2br(strtoupper($encodedMessage));
    }
?>

Demo

Very nice, now we have a basic encrypting mechanism. But what if we want to make this even harder to break? My older kid had an idea: we will allow user to enter a key which will be a number. If a user enters number 3, that would move number 0 (zero) to the third letter of germanikus word.

Great, let’s do it:


 $word) {
		$r[$count] = $secretWord[$key] . ' => ' . $word;
		$count++;
	}
	echo implode(', ', $r) . '
';
	$message = strip_tags($_POST['message']);
	//encode
	$encodedMessage = str_replace($secretWordArray, $codeArray, strtoupper($message));
	//decode
	$decodedMessage = str_replace($codeArray, $secretWordArray, $encodedMessage);
	echo 'Encrypted message:
';
	echo nl2br(strtoupper($encodedMessage));
	echo '
';
	echo 'Decrypted message:
';
	echo nl2br(strtoupper($decodedMessage));
}
?>

Demo

When you try this demo, you will see that if you enter 3 as a key, the fourth letter will be 0. That is ok, as we want to start counting from zero.

That’s it, my kids were delighted with this and have learned a lot about string manipulation and a little bit about arrays in PHP.

Please share your thoughts in comments below.

jQuery Mobile 1.0 Final Released

Zvonko — Thu, 17 Nov 2011 20:29:28 +0000

jQuery Mobile has been a great mobile framework from the beginning in summer of 2010. I always liked the framework for its simplicity and a plethora of documentation.

Being it on site documentation or resources and tutorials that could be found around the internet (even here you can find jQuery Mobile Tutorial: Basics and jQuery Mobile Advanced Tutorial), this framework is very well documented.

Coming out of their mouth:

Equally as important, we set out to make this framework easy for developers to get up and running fast, with a minimal learning curve.

So let’s see what is new.

ThemeRoller

ThemeRoller is a web-based tool that makes it super simple to create custom themes without writing a single line of CSS. Drag and drop colors to create your masterpiece, then share it via URL or download a ZIP file with your custom theme stylesheet, ready for production (or additional tweaking).

Yeah, it is that awesome. Enough said, go and check it out on ThemeRoller page.

The main man behind the ThemeRoller is Tyler Benzinger, a guy who was borrowed from Adobe.

When you create your awesome jQuery Mobile Theme, just download the zip archive with compressed theme file (for production) as well as the uncompressed ones (for tweaking). Inside an archive there is also an index.html file as sample of how your theme is working on jQuery Mobile elements. Awesome.

One more thing: the complete source code for the new jQuery Mobile ThemeRoller tool is open source under the standard jQuery project licenses for you to improve, remix and build into your apps. The core tool is designed to work completely client-side to make it easy to drop into your code — only the download and sharing features require a bit of PHP. Go forth and fork it on GitHub.

Performance

The team spent hours and hours optimizing the framework and gain 30-50% better performance than RC2 release. They are already working on improving touch event responsiveness, page transition and scrolling smoothness and other important factors in upcoming releases.

Resources

As I said earlier, jQuery Mobile has a huge community that has been incredibly active writing plugins and extensions, building frameworks and tools that enhance the library, and writing tons of articles and tutorials. There are now 8 books on jQuery Mobile and many more in the works.

All resources can now be found in brand new Resources page.

Other news

There are other great stuff on their pages like new documentation site, quick start guide, the oft-requested data-attribute reference, a set of global configuration test pages that let your easily preview key settings, a PhoneGap tips page, detailed documentation on the experimental touchOverflow feature, info on how to access new features of the fixed toolbars, and much more.

Since jQuery 1.7 was just recently released and has some significant changes (and improvements), only 1.6.4 is officially supported at this time. 1.7 support is planned in version 1.1.

All you need to get going is putting this 3 lines inside your HTML file:

Platforms

jQuery Mobile has broad support for the vast majority of all modern desktop, smartphone, tablet, and e-reader platforms. In addition, feature phones and older browsers are supported because of their progressive enhancement approach.

Get the full list of supported platforms

I am excited with this release, as this is a full-blown HTML 5 Mobile framework.

What do you think? Share your comments below…

jQuery UI 1.8 – The User Interface Library for jQuery – Book Review

Zvonko — Thu, 10 Nov 2011 21:09:37 +0000

I deal with jQuery a lot in my line of work and have a great amount of understanding how jQuery works as well as how jQuery UI is helping with its great widgets.

When I started reading this great book, I realized that there is plenty new things I can learn out of it.

On the very beginning of the book, there is a detailed introduction in jQuery and jQuery UI 1.8 set up. Everything is very well explained, from download to setting up a development environment, and is easily followed even by inexperienced developers.

Dan Wellman, the author, has been writing computer-related articles, tutorials, and reviews for around eight years and is rarely very far from a keyboard of some description. This is his fourth book.

The second chapter jumps into the explaining how jQuery UI works and is very detailed. The core css functionality is explained as well as theming, theme overriding, theme switching, widgets and how to create them, avoiding collisions etc.

After that book is explaining all the widgets in stunning details and great screenshots. Every single option for every widget is explained and show hot it affects the result. The detailed explaining and screenshots is what makes this book stand out.

In the last part, jQuery UI effects are explained with same amount of enthusiasm as in previous chapters. Even the advanced effects are shown like:

Blind
Clip
Drop
Explode
Fold
Puff
Pulsate
Scale
Slide

What I really like about this book is that it gave me the big picture and then gently followed me to the tiniest details in jQuery UI. All examples used in a book can really be used in a real life scenarios, and that is really something.

If you are interested in jQuery UI this book is definitely a must read. Even advanced developers can learn something out of it.

You can buy this book at Amazon: jQuery UI 1.8: The User Interface Library for jQuery or Packt Publishing

Win $50 worth of credit for Premium Themes on 4Templates.com

Zvonko — Tue, 01 Nov 2011 21:16:45 +0000

How many times did you face a problem that you developed some fancy web application, but your skills as a designer are not that fancy.

Whatever you develop, it will never succeed if it doesn’t look good.

Designing is hard and sometimes you just want to take something great looking and already finished.

That is where guys at 4Templates come in. Believe me, they got all you need: Site templates, WordPress Themes, Business Card templates and more. NAd prices below $30 guarantee that you are getting a bargain.

They even go some great Print templates.

4Templates and Codeforest are giving a chance of winning $50 worth of credit on 4Templates to two of the lucky winners.

You can then spend your credit on State of the art Premium Templates on 4Templates.

How to participate

It is really simple to participate, so hurry:

Share this post on Twitter
Leave a comment below and tell me what will you do with your $50 if you are the winner

Please, leave a valid email address in the comment, so I can contact you if you win.

The lucky 2 winners will be announced on December, 14th on this blog.

Obfuscate your e-mail address with PHP, JavaScript and CSS

Zoran Jambor — Thu, 27 Oct 2011 19:27:29 +0000

According to Wikipedia, more than 97% of all e-mails sent over the net are unwanted. That’s around 200 billion spam messages per day.

To keep this insane amount of spam out of your inbox, you should keep your e-mail safe when you display it on web. One of the ways to keep it safe is to obfuscate it. In this tutorial I’ll show you how to create a script that will do just that.

Basic requirements for such script (at least from my point of view) are:

It should function pretty much out of the box. User should work only with real e-mail; script should obfuscate and deobfuscate it on the fly.
It should show obfuscated e-mail to bots, but real one to humans; humans should not even notice that obfuscation (or deobfusaction) is taking place.
Script should work on all desktop browsers (I’m talking IE6+here) and on mobile browsers as well (at least on the ones that support JavaScript).

To handle this, we’ll create a PHP function that will take string (e-mail address) as an argument. The function will reverse the address and obfuscate it using slightly modified ROT13 algorithm.

Deobfuscation will be done with JavaScript. When user opens the page we will detect which e-mail links have been obfuscated, apply reversed ROT13 algorithm on them and direction:rtl and unicode-bidi:override CSS rules.

This way, users will see real address, but spam bots will still (even if they can parse JavaScript) see a reversed e-mail.

This will, of course, leave us with a usability problem. If user copies the address, or if he clicks it, he’ll get the reversed one. Therefore, as a last deobfuscation step, we’ll reverse the reversed address and remove added CSS rules as soon as the user hovers over the link.

Demo

E-mail Obfuscation (PHP)

Code is thoroughly commented, have a look if you’d like to know more.


//Function takes string as an argument and returns a string.
function obfuscateEmail( $email ) {

	//We will work with UTF8 characters, just to be safe that we won't mess up any address.
	$emailLetters = preg_split( '//u', $email, null, 1 );
	$obfuscatedEmail = '';

	//Reversing the string (e-mail).
	$emailLetters = array_reverse( $emailLetters );

	//Characters that are to be used when obfuscating email address.
	//If you change this, make sure you change the characters string in JavaScript as well.
	//And please note that the string must have even number of characters for this to work.
	$characters = '123456789qwertzuiopasdfghjklyxcvbnmMNBVCXYLKJHGFDSAPOIUZTREWQ';

	//Get the number of characters dynamically.
	$charactersLength = strlen( $characters ) - 1;

	//Obfuscate string letter by letter.
	foreach( $emailLetters as $letter ) {

		//Get the current letter position in the string.
		$letterPos = strpos($characters, $letter);

		//If the character is present in our string of characters,
		//we'll switch it; if not, we'll leave it as is.
		if( $letterPos !== false ) {

			$letterPos += $charactersLength / 2;

			//For letters that are in our characters string positioned
			//after the total number of characters, we'll start from beginning.
			//For example, "v" becomes "1", "b" becomes "2"
			$letterPos = $letterPos > $charactersLength ? $letterPos - $charactersLength - 1 : $letterPos; 

			//Obfuscated letter.
			$newLetter = substr($characters, $letterPos, 1);

		} else {

			//Characters that aren't in our list will be left unchanged.
			$newLetter = $letter;

		}

		//We append obfuscated letter to the result variable.
		$obfuscatedEmail .= $newLetter;

	}

	//Sign @ is a control letter. Since more than one @ sign is illegal
	//in email address, we're going to use two @ symbols to know when
	//the string has been obfuscated (and needs deobfuscation).
	//That way you can use obfuscated e-mail only in href attribute,
	//while the link text can be something entirely different.
	//An example: This is my email.
	return $obfuscatedEmail . '@';

}

After you include function into your code, obfuscation can be preformed like this:

And in a real life usage, you’d create an obfuscated e-mail link like this:

We’re adding a class obfuscatedEmail to each obfuscated link. That way it will be easy for us to find all elements that need deobfuscation.

E-mail deobfuscation (JavaScript & CSS)

Step one is to detect all obfuscated links on a page. That’s fairly easy to do; we just find all elements that have class obfuscatedEmail.


//This is written to be as general as possible; you can leave this part out and just call
//deObfuscateEmail() manually on elements that should be deobfuscated.

var obfuscatedEmails = document.getElementsByTagName('a'),
    obfuscatedEmailsLength = obfuscatedEmails.length,
    i = 0;

for( ; i -1 ) {

        deObfuscateEmail( obfuscatedEmails[i] );

    }

}

I encourage you to adjust this part to your own needs. If you have only one e-mail on the page, you don’t have to loop through all page elements. Something like this would suffice:


//PHP


//JavaScript
deObfuscateEmail( document.getElementById(‘myObfuscatedEmail’) );

Function deObfuscateEmail still hasn’t been created. We’ll get to it after we create a function that will change back e-mail letters based on ROT13 algorithm.


//This is a first layer of deobfuscation.
//Basically a reversed ROT13 algorithm.
function changeLetters(string) {

    //Helper variables.
    var currentLetter,
        currentPos,
        currentString = '',

        //Behold! The one and only counter.
        i = 0,

        //We're going to loop through the obfuscated strings characters, so this will come in handy.
        stringLength = string.length - 1,

        //Characters that will be used when deobfuscating email address.
        //Same as string in PHP obfuscate function (obfuscateEmail).
        characters = '123456789qwertzuiopasdfghjklyxcvbnmMNBVCXYLKJHGFDSAPOIUZTREWQ',
        charactersLength = characters.length;

    //Counter variable has been declared before.
    for( ; i -1 ) {

            currentPos -= (charactersLength-1) / 2;
            currentPos = currentPos < 0 ? charactersLength + currentPos : currentPos;

        } else {

            currentString += currentLetter;

        }

        //Finally, append a character to our temp string that will be returned.
        currentString += characters.charAt(currentPos);

    }

    return currentString;

}

We’ll call this function on each letter of obfuscated e-mail.

Here’s the final part of the code, the one that takes an HTML element as a parameter, checks its value and href attribute and calls changeLetters function on each of its characters.
Then it adds CSS rules to correctly show reversed address and binds mouseover event on the link, which triggers final function that re-reverses the address.


//Function that will handle email deobfuscation.
//@param element is a reference to html element that will be deobfuscated.
//Deobfuscation is done on text and on href attribute of the element.
//Nevertheless, function will work well with any element you pass in,
//even if href attribute won't be present.
function deObfuscateEmail( element ) {

    //Get the text of the element.
    var text = element.innerHTML,

        //Get href attribute. If there is no href attribute, set href value to be an empty string.
        //Regular expression is an IE Fix.
        //Namely, IE appends obfuscated email to the url (www.domain.com/com.liameym@em).
        //Therefore, the first part of the link needs to be removed (we grab just everything after the last forward slash '/').
        href = element.getAttribute('href').replace(/http:\/\/(.+)\//gi, '') || '',

        //Control variable. if the two @ symbols are present, we will perform deobfuscation,
        //if not, the string is not obfuscated and doesn't have to be deobfuscated.
        textReplace = text.search(/@.+@/),
        hrefReplace = href.search(/@.+@/),

        //This function handles the second layer of deobfuscation.
        //It is called later in the code.
        //Letters of the email are reversed (again) and css direction returned back to ltr.
        //This is called on mouseover event.
        reverseEmails = function(){

            //Only if htef is obfuscated.
            if( hrefReplace > -1 ) {

                //That's the reversing part right here.
                element.setAttribute('href', href.split('').reverse().join('') );

            }

            //Only if text is obfuscated.
            if( textReplace > -1 ) {

                //Reverse the text of the element and
                //return the direction to normal (left to right).
                element.innerHTML = text.split('').reverse().join('');
                element.style.direction = 'ltr';
                element.style.unicodeBidi = 'normal';

            }

            //Letters are replaced and the event isn't needed anymore.
            if( element.removeEventListener ) {

                element.removeEventListener('mouseover', reverseEmails, false);

            } else {

                // IE8-
                element.detachEvent('onmouseover', reverseEmails);

            }

        };
        //End variables and functions definitions.

    //href has to be processed first, because of the strange
    //IE bug that will mix the href and innerHTML values.
    if( hrefReplace > -1 ) {

        href = changeLetters(href);
        element.setAttribute('href', href);

    }

    //Change the direction of the text to show real address
    //to users, instead of an reversed one.
    if( textReplace > -1 ) {

        text = changeLetters( text );
        element.innerHTML = text;
        element.style.direction = 'rtl';
        element.style.unicodeBidi = 'bidi-override';

    }

    //Since we have a rtl text, user can't copy or click on a link.
    //Therefore we'll replace the value as soon as user hovers over the link.
    if( element.addEventListener ) {

        element.addEventListener('mouseover', reverseEmails, false);

    } else {

        element.attachEvent('onmouseover', reverseEmails);

    }

}

If we put all these pieces of code together, we will get the fully functional deobfuscation script:


(function(){

    //This is a first layer of deobfuscation.
    //Basically a reversed ROT13 algorithm.
    function changeLetters(string) {

        //Helper variables.
        var currentLetter,
            currentPos,
            currentString = '',

            //Behold! The one and only counter.
            i = 0,

            //We're going to loop through the obfuscated strings characters, so this will come in handy.
            stringLength = string.length - 1,

            //Characters that will be used when deobfuscating email address.
            //Same as string in PHP obfuscate function (obfuscateEmail).
            characters = '123456789qwertzuiopasdfghjklyxcvbnmMNBVCXYLKJHGFDSAPOIUZTREWQ',
            charactersLength = characters.length;

        //Counter variable has been declared before.
        for( ; i -1 ) {

                currentPos -= (charactersLength-1) / 2;
                currentPos = currentPos < 0 ? charactersLength + currentPos : currentPos;

            } else {

                currentString += currentLetter;

            }

            //Finally, append a character to our temp string that will be returned.
            currentString += characters.charAt(currentPos);

        }

        return currentString;

    }

    //Function that will handle email deobfuscation.
    //@param element is a reference to html element that will be deobfuscated.
    //Deobfuscation is done on text and on href attribute of the element.
    //Nevertheless, function will work well with any element you pass in,
    //even if href attribute won't be present.
    function deObfuscateEmail( element ) {

        //Get the text of the element.
        var text = element.innerHTML,

            //Get href attribute. If there is no href attribute, set href value to be an empty string.
            //Regular expression is an IE Fix.
            //Namely, IE appends obfuscated email to the url (www.domain.com/com.liameym@em).
            //Therefore, the first part of the link needs to be removed (we grab just everything after the last forward slash '/').
            href = element.getAttribute('href').replace(/http:\/\/(.+)\//gi, '') || '',

            //Control variable. if the two @ symbols are present, we will perform deobfuscation,
            //if not, the string is not obfuscated and doesn't have to be deobfuscated.
            textReplace = text.search(/@.+@/),
            hrefReplace = href.search(/@.+@/),

            //This function handles the second layer of deobfuscation.
            //It is called later in the code.
            //Letters of the email are reversed (again) and css direction returned back to ltr.
            //This is called on mouseover event.
            reverseEmails = function(){

                //Only if htef is obfuscated.
                if( hrefReplace > -1 ) {

                    //That's the reversing part right here.
                    element.setAttribute('href', href.split('').reverse().join('') );

                }

                //Only if text is obfuscated.
                if( textReplace > -1 ) {

                    //Reverse the text of the element and
                    //return the direction to normal (left to right).
                    element.innerHTML = text.split('').reverse().join('');
                    element.style.direction = 'ltr';
                    element.style.unicodeBidi = 'normal';

                }

                //Letters are replaced and the event isn't needed anymore.
                if( element.removeEventListener ) {

                    element.removeEventListener('mouseover', reverseEmails, false);

                } else {

                    // IE8-
                    element.detachEvent('onmouseover', reverseEmails);

                }

            };
            //End variables and functions definitions.

        //href has to be processed first, because of the strange
        //IE bug that will mix the href and innerHTML values.
        if( hrefReplace > -1 ) {

            href = changeLetters(href);
            element.setAttribute('href', href);

        }

        //Change the direction of the text to show real address
        //to users, instead of a reversed one.
        if( textReplace > -1 ) {

            text = changeLetters( text );
            element.innerHTML = text;
            element.style.direction = 'rtl';
            element.style.unicodeBidi = 'bidi-override';

        }

        //Since we have a rtl text, user can't copy or click on a link.
        //Therefore we'll replace the value as soon as user hovers over the link.
        if( element.addEventListener ) {

            element.addEventListener('mouseover', reverseEmails, false);

        } else {

            element.attachEvent('onmouseover', reverseEmails);

        }

    }

    //We could use native getElementsByClassName in browsers that support this method,
    //but I did a few quick tests and it seems to be slower.
    //If you have more info on performance getElementsByClassName vs getElementsByTagName + className.indexOf please let me know.
    //var obfuscatedEmails = document.getElementsByClassName('obfuscatedEmail'),

    //This is written to be as general as possible; you can leave this part out and just call
    //deObfuscateEmail() manually on elements that should be deobfuscated.

    var obfuscatedEmails = document.getElementsByTagName('a'),
        obfuscatedEmailsLength = obfuscatedEmails.length,
        i = 0;

    for( ; i -1 ) {

            deObfuscateEmail( obfuscatedEmails[i] );

        }

    }

}());

Demo Source files

Conclusion

With the amount of spam that is being sent over the internet, you surely don’t want to leave your e-mail address unattended; do everything you can to prevent it from falling in wrong (spammy) hands.

Technique that I’ve shown you here should be (if nothing else) at least a good start.

Additional readings:

Interview with Jeffrey Way

Zvonko — Wed, 26 Oct 2011 19:40:07 +0000

I always wanted to interview influential people in development world. So, I decided to ask one of the most interesting one – Jeffrey Way of Envato (they call him “The Man”).

His tutorials, books and simple approach to most difficult problems have always inspired me.

Enjoy:

Who is Jeffrey Way? Tell us something about yourself

I’m the editor of a popular web development blog, Nettuts+, and a developer evangelist for the Envato marketplaces (ThemeForest and CodeCanyon, among others). These days, whenever I can manage to find some free time, I’ve been pushing myself into the Ruby on Rails world, and have been loving every second of it.

How much time do you spend on learning new things?

Luckily, I have a job that virtually demands that I continue learning. I wouldn’t be able to run Nettuts+ otherwise. It’s perhaps the biggest blessing I’ve had. As we all know, it’s incredibly difficult to remain relevant and up-to-date in the industry; so Nettuts+ is certainly a huge help.

I’d say around 20 hours a week are spent learning, reading, etc.

I see that you are programming in Ruby and Ruby on Rails? Which do you prefer better, PHP or Ruby?

Honestly, it’s difficult to compare the two. At this point in my career, I prefer Ruby. It’s a language that was created to be as understandable as possible. PHP is a scripting language; Ruby feels like a human language. I love that!

But, at the same time, PHP was made specifically for the web; Ruby wasn’t. If I was asked to recommend a language to a beginning web designer, I’d vote for PHP.

Many people dislike Rails because they see it as being forced to follow a specific guideline for how to build web applications. I can appreciate this line of thinking, but is that so bad? The industry is complicated enough; it helps to be nudged in the right direction as much as possible. Think of it as your best judgment vs. the best judgment of an entire group of dedicated developers. I appreciate the help.

I noticed that number of your great tutorials is falling on Nettuts. I really miss the Quick tips. Why is that? No time, or working on some new projects?

Are you referring to me specifically? If so, I’m putting a great deal of energy into the next release of Tuts+ Premium, which is our subscription portion of Tuts+. I’m working on creating courses, which teach skills from the inside out.

I’m still able to get at least one article a week out on Nettuts+ though. Quick tips will continue as well!

Do you have any advice for people who try to sell items on Envato Marketplaces?

I created a screencast on this very thing. Refer here: How to become better author on Envato?

Lately, I saw some lower quality additions on CodeCanyon. Is standard going down to have as much items as you can?

No; our standards have increased consistently since the launch. We prefer quality over quantity; so if you do come across an item that you don’t feel fits our standards, definitely let us know. We’ll look into it immediately!

How is your Vegetarianism going? Do you feel better?

I’ve been a vegetarian for a couple years now, and will never turn back. It’s easily the best decision I’ve ever made in my life. I’d never want to push my opinions on others, however, if it’s something that any of your readers are considering, I can’t recommend it enough. When the meat industry is tasked with feeding billions of people on this planet, can you imagine the level of abuse that occurs behind those locked doors? Chickens who spend their entire lives in darkness and in their own feces, pigs who scream in pain… all of this is real. It’s amazing how willing we are to turn a blind eye.

Read a couple books, or watch some documentaries on the subject. If you’re going to eat meat, at least be aware of what goes on behind the scenes. Those quaint photos of farm animals and the red barn don’t exist. There’s a reason why it’s referred to as factory farming.

Do you have some free time? An how do you spend it?

Well, of course; I don’t think I’d survive otherwise. I spend much of time on the computer; so, when I do have free time, I like to get outdoors. Running, sports, etc. I live up in the mountains, so it’s particularly refreshing to go hiking whenever I have the chance.

I don’t have as much time available as I used to, but I also still enjoy a good video game. Right now, I’m counting the days until the new Zelda comes out in November.

Can you give us a sneak peak of what will be your few next steps? A new book? New project?

As I briefly mentioned above, right now, I’m working full steam on the re-launch of Tuts+ Premium. For the last few months, I’ve been creating course after course – everything from WordPress plugin development, to Phing, to CSS3. If you enjoy the style of my video tutorials, you’ll feel right at home with these courses.

Next month, I’m hoping to finish my next HTML5 book for Rockable Press. It’ll be a compilation of everything I’ve learned in the last few years on the subject.

Thanks again for this oprtunity, Jeffrey.

CakePHP 2.0 released: What’s new?

Zvonko — Wed, 19 Oct 2011 21:32:42 +0000

“CakePHP is a rapid development framework for PHP that provides an extensible architecture for developing, maintaining, and deploying applications. Using commonly known design patterns like MVC and ORM within the convention over configuration paradigm, CakePHP reduces development costs and helps developers write less code. ”

And now, it even got better. After a year and a half of coding, CakePHP 2.0 is released.

I will first talk about some cool new features and explain some of them later.

New features

Dropped PHP 4 support and we have refactored all the code to be strictly compliant with PHP 5.2+.
Use of native features like exceptions, PDO, SPL, json_encode and much more.
Embraced the PSR-0 recommendation for file naming. Now all your classes map to a file with the same name. Less things to remember!
New Error and Exception handlers provide easier to configure, and ease working with errors such as page not found, unauthorized error and lots more.
Improved I18n functions for easier multilingual development.
Support for injecting your own objects to act as CakePHP libraries, such as component, helpers and behaviors, no more excuses for modifying core files.
Console libraries rebuilt from scratch, automatic help generation, parameter checking, and colors!
New Request and Response objects for easier handling of HTTP requests.
Better session handling for easier custom engines. Put your sessions into storage systems like Memcache with less effort.
Completely refactored Auth system. It is now easier to configure and plug in your own implementations for external login services or your permissions system.
Brand new email library with support for multiple transports. With easy to use global configuration, logging, and charset support.
Dropped SimpleUnit in favor of PHPUnit. PHPUnit is the defacto testing framework for PHP with support for more options, better mock objects, and improved console output [16]
Reworked the SecurityComponent to suck less, now you can more easily protect your apps against CSRF and form tampering attacks while having fun.
Improved support for PostgreSql, SQLite and SqlServer, they are now first class citizens along with Mysql datasource.
HTML 5 form inputs support in form helper.
A Sexier default look taking advantage of new CSS 3 features.
A lot faster, almost everything is now lazy-loaded, and even on debug mode you will feel your applications flying.

CakePHP 2.0 completely dropped the PHP 4 support and is now supporting PHP 5.2.6 and above. This was expected.

Models

The model construction process has been made lighter. Model associations are now lazy loaded, applications with lots of models and associations will see great time reductions in the bootstrap process.

Now models won’t require a database connection in the construction process. The database will be accessed for the first time only when a find operation is issued or information for one of the columns is required.

Views

View will now always have the last rendered content (view or layout) accessible through $this->output. In helpers you can use $this->_View->output. Modifying this property will change the content that comes out of the view rendering.

Helpers

There are some interesting new features inside powerful CakePHP Helpers:

FormHelper now supports all HTML5 input types and custom input types. Just use the input type you want as the method on the helper. For example range() would create an input with type = range.
postLink() and postButton() Creates link/button to access some page using HTTP method POST. With this, in your controller you can avoid some action, like delete, to be accessed by GET method.
select() with multiple = checkbox, now treats the 'id' attribute as a prefix for all the generated options.
getCrumbsList() Creates breadcrumb links wrapped in
elements in HTMLHelper

Error handling

The error handling implementation has dramatically changed in 2.0. Exceptions have been introduced throughout the framework, and error handling has been updated to offer more control and flexibility.

PHPUnit

All of the core test cases and supporting infrastructure have been ported to use PHPUnit 3.5. Of course you can continue to use SimpleTest in your application by replacing the related files.

No further support will be given for SimpleTest and it is recommended that you migrate to PHPUnit as well.

Database Objects

Cake 2.0 introduces some changes to Database objects that should not greatly affect backwards compatibility. The biggest one is the adoption of PDO for handling database connections.

If you are using a vanilla installation of PHP 5 you will already have installed the needed extensions, but you may need to activate individual extensions for each driver you wish to use.

Console

CakePHP features not only a web framework but also a console framework for creating console applications. Console applications are ideal for handling a variety of background tasks such as maintenance, and completing work outside of the request-response cycle. CakePHP console applications allow you to reuse your application classes from the command line.

CakePHP comes with a number of console applications out of the box. Some of these applications are used in concert with other CakePHP features (like ACL or i18n), and others are for general use in getting you working faster.

One of the cool things is that the console app is now colorized to easier spot error messages and other critical information.

Conclusion

CakePHP 2.0 is a great step for this framework. I mentioned only the biggest features but there are even more.

I am looking forward to write some tutorials, benchmarks and reviews on CakePHP 2.0 to see how it really works in a real world examples. So, stay tuned.

What do you think of CakePHP framework? What frameworks do you use?