Some of key features:

• Autodetects the mobile device
• jQuery mobile (v. 1.1.0)
• Homepage slider (http://swipejs.com/)
• Almost all pages styled

Installation is simple, just copy downloaded files, (app, skin) after that go to administration and do some Magento magic. Magento already have browser detection, you only need to create rule. In our case we dropped table support because most of them will display normal desktop view store. Here is rule:

iPhone|iPod|BlackBerry|Palm|Googlebot-Mobile|mobile|mobi|Windows Mobile|Safari Mobile|Android|Opera Mini|Fennec

You can add any other browser to this Expression, just point your device to http://whatsmyuseragent.com/ and find out user agent name of device browser. And this is how it looks in administration

Using expressions

We need to mention that theme is independent from main store theme, all files which are edited don’t “break” default Magento markup we are only using power of HTML5 and one of the new cool feature “custom data attributes“.

Simply, the specification for custom data attributes states that any attribute that starts with “data-” will be treated as a storage area for private data (private in the sense that the end user can’t see it – it doesn’t affect layout or presentation).

Short explanation by John Resig

And here is our example for store header:

</pre>
<div data-role="header" data-position="inline" data-theme="c">
<h1><a href="<?php echo $this->getUrl('') ?>" data-icon="home">
<img src="<?php echo $this->getLogoSrc() ?>" alt="<?php echo $this->getLogoAlt() ?>" /></a></h1>
<!--?php echo $this----->getChildhtml('top-user');?></div>
<pre>

We don’t have any local hosted files regarding to jQuery because it is much easier to edit and place the newest version of js.

					<![CDATA[<script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js"></script><script type="text/javascript">jQuery.noConflict();</script>]]>
					<![CDATA[<script type="text/javascript" src="http://code.jquery.com/mobile/1.1.0/jquery.mobile-1.1.0.min.js"></script>]]>
				<![CDATA[		<link rel="stylesheet" href="http://code.jquery.com/mobile/1.1.0/jquery.mobile-1.1.0.min.css" />]]>
            skin_jsjs/swipe.js

Ah, if you need more info about jQuery mobile framework go to: http://jquerymobile.com/.

Swipe JS, http://swipejs.com/,

Swipe is a lightweight mobile slider with 1:1 touch movement, resistant bounds, scroll prevention, and completely library agnostic. .

Ok, we made simple approach, create static block, named Slider with ID slider and place this code

</pre>
<div style="display: block;"><img src="{{media url=" alt="" /></div>
<div style="display: none;"><img src="{{media url=" alt="" /></div>
<div style="display: none;"><img src="{{media url=" alt="" /></div>
<div style="display: none;"><img src="{{media url=" alt="" /></div>
<pre>

If is there no needs for homepage slider just removed it from local.xml (from line 44).

For styling pages, we cover most of them but there is always more space to improve some part of Magento interface.

For demo and download go to our demo store http://imobile.inchoo4u.net with your smartphone, emulate in browser (change user agent), visit @ github, or just scan this QR code.

So if you have any suggestion, issues, trouble just comment below, enjoy

One of these things is forcing php CLI to use my custom php.ini file on server.

Let me start this story from beginning …

Situation was that we took managed dedicated server for my Symfony2 project installation to be used as production server. I have no root access there (it’s level 2 managed server), but I always have possibility to ask support to enable me some things that I need inside my project’s account.

Of course, during the testing server configuration with my project I asked support to enable local php.ini file inside my account, so I can change setting as necessary without every time sending mail to support and waiting their response.

So, I got my local php.ini in which I first needed to remove shell_exec function from disabled functions – used in my custom command for handling database backups with cron job (independently and slightly different from default backups handling in control panel)

Yeah, I removed the function from php.ini and made custom command for back up and restore my data using php console command (Symfony2 shell).

Then I noticed that shell_exec is not working from php CLI. It’s still disabled ….
When I add shell_exec function in controller and run the code via web browser, it is working, but within SSH: php console backup create not working and it says that “shell_exec function is disabled for security reasons”…

Luckily, my colleague @Tomas Novoselic was near and thanks to him that this agony was not took too long. (He is hardcore Linux user … )

If you want to force specific php.ini file to be used with Php CLI, you just have to add path to php.ini file that you want to use inside command, so instead of:

$ php console backup create

you should use something like this:

php -c /home/divineof/etc/php.ini console backup create

… and that solved my problem…

In meantime, I found one more elegant solution, considering that I am using bash shell with SSH:
Inside root installation of my hosting account, there is hidden file called ‘.bashrc’, so I opened it and entered inside:

# .bashrc

# Source global definitions
if [ -f /etc/bashrc ]; then
	. /etc/bashrc
fi

# User specific aliases and functions

alias php='php -c /home/divineof/etc/php.ini'

After defining alias for php command, I am able to write again like this:

$ php console backup create

… and it works now!

That’s all from me for today …

Maybe someone will say: this is a crazy idea. Why would someone want to do that?
Maybe it really is crazy, but I would say: why not?

What is TWIG? TWIG is new generation php templating engine made by Sensio Labs. It is used in their new project Symfony2 as main templating engine provided with framework.
As official page says:

Fast: Twig compiles templates down to plain optimized PHP code. The overhead compared to regular PHP code was reduced to the very minimum.
Secure: Twig has a sandbox mode to evaluate untrusted template code. This allows Twig to be used as a template language for applications where users may modify the template design.
Flexible: Twig is powered by a flexible lexer and parser. This allows the developer to define its own custom tags and filters, and create its own DSL.
It is not necessary to explain in detail why will someone (me) want to use that as wordpress templating engine, but one of the main reasons is that I want to rewrite some messed up php template for WP to better code organized one, and at the and I want it to be with cleaner code as possible.
I don’t like very much when is necessary to mix up php tags and functions inside HTML code to make it work.
After some thinking about TWIG and how to implement it in my WP installation I got idea:
I will make plug in for WP that will provide all necessary stuff to start using TWIG with WP.

First I created the plugin folder named wp_twig_engine.I put folder named ‘lib‘ downloaded from twig-project site in there. So I had the twig library almost prepared for using.
Now I had to find some appropriate wordpress hook to inject my code into wordpress application logic. After some investigating and testing, I found that it will be possible to use the ‘init‘ hook and register autoloaders for TWIG library and my custom class in the same function, so I can reach my code from inside template folder later.

Main plugin file: wp-twig.php

<?php

/*
  Plugin Name: WordPress Twig templating engine
  Version: 1.0
  Plugin URI: http://inchoo.net
  Description: Engine for creating twig templates for wordpress
  Author: Darko Goleš
  Author URI: http://inchoo.net/author/darko.goles/
 */
//Main twig library autoloader file
require_once dirname(__FILE__) . '/lib/Twig/Autoloader.php';
//My custom class made, I also want it to be autoloaded
require_once dirname(__FILE__) . '/Wp_TwigEngine.php';

function twigAutoLoad() {

    Twig_Autoloader::register();
    Wp_TwigEngine_Autoloader::register();
}

add_action('init', 'twigAutoLoad');
?>

Just to show you how to autoload my custom class with that (of course I got idea from original twig autoloader and just changed the code to fit my needs:

<?php
/*
Wp_TwigEngine.php
  Author: Darko Goleš
  Author URI: http://inchoo.net/author/darko.goles/
*/
class Wp_TwigEngine_Autoloader {

    static public function register() {
        ini_set('unserialize_callback_func', 'spl_autoload_call');
        spl_autoload_register(array(new self, 'autoload'));
    }

    static public function autoload($class) {
        if (0 !== strpos($class, 'Wp_TwigEngine')) {
            return;
        }

        if (file_exists($file = dirname(__FILE__) . '/../' . str_replace(array('_', "\0"), array('/', ''), $class) . '.php')) {
            echo($file);
            exit;
            require $file;
        }
    }

}

And that’s it from the plugin side for now. Just have to implement it in the template folder. That is additional theme for another article.

FYI that links inside content look like this:

<a type="amzn"> “Jerusalem the Golden” performed by Rupert Gough–Malcolm Archer–Wells Cathedral Choir</a>

When links was formed like that, our site could never pass HTML validation, and also we had some click-able non-functional links in our content. It would be very hard work to parse every article inside database and remove that links from our content, because we have much content that would need checking and fixing.

I found the good plug-in that parses that links into proper formed links and making our links work, but there was one more problem to solve with that:

With regular Amazon API, like this new plug-in does, links are parsed with some included Javascript files that are linked directly from Amazon.com and small chunk of calling Javascript are included inside page to make it work.

But, what is happening when my colleagues develop iPhone application that reads content from web site’s rss feed are trying to make this links functional? They have to manually include all of this Javascript inside iPhone application and run that script locally from device.

I don’t think that is the best solution for us. So decided to make some own wordpress plug-in that will build that links with php and show them already parsed on web page and also inside feed to avoid Javascript parsing.

Here is the code:

<!--?php /*   Plugin Name: Amazon ASIN links parser   Plugin URI: http://www.surgeworks.com   Description: Plugin that parses Amazon links with ASIN code and converts them to full Amazon affiliate url without javascript   Version: 1.0   Author: Darko Goleš   Author URI: http://inchoo.net/author/darko.goles/   License: Surgeworks - all rights reserved.  */ define('DVO_LOCATIONS_PLUGIN_PATH', dirname(__FILE__)); define('DVO_LOCATIONS_PLUGIN_URL', get_option('siteurl') . '/wp-content/plugins/' . basename(DVO_LOCATIONS_PLUGIN_PATH)); include(dirname(__FILE__) . '/simple_html_dom.php'); //Adding filter into content add_filter('the_content', 'parseLinks'); function parseLinks($content) { 	/*if(is_feed()) 	{*/ 		$html = new simple_html_dom(); 		$html--->load($content);

		$ret = $html->find('a[type="amzn"]');

		foreach($ret as $val)
		{
			if(isset($val->asin))
			{
				$asin = $val->asin;
				$linktext = $val->plaintext;

				$newLinkStr = buildURL($asin,$linktext,'divine-office-20');

				$val->outertext = $newLinkStr;
			}

		}

		$content = $html->save();

	/*}*/
    return $content;
}

function buildURL($asin, $linktext, $affiliate)
{
	return '<a href="http://www.amazon.com/dp/' . $asin . '/?tag=' . $affiliate . '">' . $linktext . '</a>';
}

For parsing I used the SimpleHtmlDOM library that can be found on web for free download.

Now when displayed, Amazon links looks like this:

http://www.amazon.com/dp/B0000542GQ/?tag=divine-office-20

Feel free to use this code to make own plugin for AMZN links with ASIN code.

Cheers

Basics About Git Branching

Well, I’ve noticed that some Git users that have just switched from SVN didn’t know that every single one of Git repositories contain at least one branch called “master”. And all commits to Git repository, if you don’t work with branches are pushed to it, by default. I say this because if you’ve used SVN, branches are considered as high-end knowledge, and in Git – it’s considered almost as the basic knowledge (it comes just after you learn how to use commit -> push -> pull loop).

So, to conclude this introduction – since everything you do with Git is on some branch, you should learn how tho use them in your advantage.

The Creation

Fist of all, go to console, navigate to your repository, and type this:

git branch -a

You should see something like this:

* master

Make sure you have at least one file inside your repository (project) directory and make sure it’s added to repository. If it isn’t, create sample file “test.txt” and do the following:

git add test.txt
git commit -m "Added test.txt to repo"

And now, let’s create our first branch manually:

git branch mybranch
git checkout mybranch

With first command git branch mybranch we’ve created a new branch called mybranch, and at this point you’ve created your first “tree” of branches. At that point, you’ve copied “local repository state” to new branch. And with second one, you’ve switched to work on your new branch.

And with this, I’ll conclude “The Creation” part of this article. Moving on to the fun part:

The Work

Let’s say we created our local branch for testing. When we’re done, we’ll merge it back to master branch, if we’re satisfied with our work, and if not, we’ll simply delete it.
So, just to be sure, after you type in:

git branch -a

You should see this:

  master
* mybranch

This means there are currently two branches “master” and “mybranch”, and we’re currently working on latter.
Now, let’s edit our test.txt file. Just add a line of text that’s saying “mybranch – first line” with your favorite text editor.
Back on to the “Git stuff” again. We’ll commit our changes to our current branch (mybranch):

git commit -a -m "mybranch - first commit"

Note: “-a” i our last commit just commits files that have been edited, in our case, test.txt.

To get a clearer picture, just write this to console:

git log -1

After it executes, you should see last commit’s author, date and message. It should be yours with message “mybranch – first commit”.
Moving on:

git checkout master
git log -1

We’ve just switched back to master branch and looked at last commit’s info. Message should go like this “Added test.txt to repo” – from our initial commit when we added the test.txt file at the beginning of this article.

Now, let’s say we’re satisfied with our work on test branch we called “mybranch”, and we want to merge it back to master, and move on with development. Since we just switched to master branch, just do the following:

git merge mybranch

Note: with this command, we’re merging branch called “mybranch” into branch we’re currently in (“master” branch)

If you followed everything to the letter, you should see a success message in your console. If not, you’ve already reached next part of this article:

The Problem

Well what if we edited same file on both branches and tried to merge them? We’d ge a merge conflict. Git will tell us there’s a problem, and we need to look into the file while it’s in the MERGING phase, resolve the conflict, re-add the file and commit merge. After that, it’s resolved.

I know this sounds complicated, but let’s move on with our example. While we’re in “master” branch, edit out test.txt file, and add new line of text – “line two”, and save it. Just after that execute the following:

git commit -a -m "Edited file on master"
git checkout mybranch

First line committed current state of files (our line we added) to “master” branch, and second line just got us back to “mybranch” branch. Open our sample file again, and you shouldn’t see our second line. Add a new line here as well – “line three”. Commit the change with following command:

git commit -a -m "Edited file on mybranch"

Switch back to master, and try to repeat the merge:

git checkout master
git merge mybranch

You should get the “Automatic merge failed” message, in file called “test.txt”. If so, you’ve done everything right. Then, in console, you can notice that you’re on “master|MERGING” branch. This is state in repository where you need to resolve the conflicts, re-add the files, and commit the merge to finish. So open the file, keep what you need after the merge, save it and execute the following:

git add test.txt
git commit -m "First conflict resolved"

You might notice you’re back on “master” branch (not “master|MERGING”). This means you’ve done it. You managed to do the following:

• create a branch
• edit files on both branches
• cause the conflict
• resolve the conflict

And now on to the last part:

The conclusion

Although all of this might seem like an overkill for something simple, it really isn’t. Even if you use console instead of some GUI tool, all of this is done under 1 minute, when you get used to it. And in return, you can isolate your work from your colleagues to work without messing into each other’s code.

I hope I was clear, and that this article will be of some help for beginners.

Feel free to comment.

Introduction

First of all, here’s the one and only goal:

Allow developers to work with Git as they did before it.

I’ll be explaining the logic through console approach because of clean informations you get, and you’ll get yourself familiarized with Git project workflow.

First, take a look at this:

Ok, I really haven’t show any rocket science here. I just show you a graphic that represents any repository. But it’s important to understand that only when each developer pushes his commits to shared repository, it will be available to his colleagues developers to pull them.

And you must know the difference between local and remote (shared) repository.

And now, take a look at this one:

Now, this is the best graphic I found that would in brief and yet comprehensive way show the workflow between the developer and remote repository. Don’t worry if you think that it’s too complicated, or if you’re scared of commands. It’s pretty simple.

Commands logic and flow

Like (almost?) with any other repository, Git is cyclic. It means nothing but you pull the changes from others, do your changes, commit them, and finally push them to repository for others. Then, you just repeat the process.

On to the fun stuff:

Start point commands

Well, regarding the commands, I’ll go through them by example as follows, as simple as possible (working on master branch only):

//This will get me updated on current online repository status
$git pull origin master

Then, I’ll create my index.php in the document root, and add content to it, and go to console to add my file to the local repository:

//This will add file to my local repository
$git add index.php

Then, I’ll make a commit with new file:

//This will add file to my local repository
//And leave amessage "index.php added"
$git commit -m "index.php added"

Finally, I’ll push my index.php with its contents to remote repository as follows:

//Push to the repository origin, on branch master
$git push origin master

And there you go. Your first file added to Git. And as I wrote before, you now just need to repeat the process.

A bit longer list of commands

git add – adds a file to local repository

git commit – it will “save” current state of files locally, and prepare them for git push

git push – it will collect all of your current commits that havent been commited and push them to remote repository

git pull – combination of git fetch and git merge

git fetch – it fetches the remote changes to your local repository, but it doesn’t change your current source contents

git merge – it’s used for merging 2 branches into one, if theres no need for 2 anymore

git branch <new-branch-name> – creates a branch with name “new-branch-name”

git checkout or git co – used for switching between branches

git diff – if you fetch the changes from remote, you can then see the difference between your code current version and last one on remote

git status – shows you the current status of your repository (like changed / added / deleted files)

git log -n – shows you the n last commit messages with some other data

Conclusion

I haven’t gone into depth of project setup, I just wanted to show everyone how to use basic console commands. And I hope someone will find something useful in here!

Cheers!

git help <command-name> – it will show you the official documentation of selected command

Head 1: Windows

Just follow these 5 steps:

1. Go to this address, and download msysgit, after the download install it with default settings
2. Open Git Bash that you just installed (Start->All Programs->Git->Git Bash)
3. Type in the following: ssh-keygen -t rsa (when prompted, enter password, key name can stay the same)
4. Open file your_home_directory/.ssh/id_rsa.pub with your favorite text editor, and copy contents to your Git repository’s keys field (GitHub, beanstalk, or any other repository provider), under your account.
5. Be sure that you don’t copy any whitespace while copying public key’s content (id_rsa.pub)

Note: your_home_directory is either C:\Users\your_username (on Windows Vista / 7), or C:\Documents and Settings\your_username (on Windows XP)

Head 2: Mac

Follow these 5 steps:

1. Start the terminal
2. Navigate to your home directory by typing: cd ~/
3. Execute the following command: ssh-keygen -t rsa (when prompted, enter password, key name can stay the same)
4. open file you’ve just created ~/.ssh/id_rsa.pub with your favorite text editor, and copy contents to your Git repository’s keys field (GitHub, beanstalk, or any other repository provider), under your account.
5. Be sure that you don’t copy any whitespace while copying public key’s content (id_rsa.pub)

Head 3: Linux (Ubuntu)

Follow these 5 steps:

1. Open console
2. cd ~
3. ssh-keygen -t rsa (when prompted, enter password, key name can stay the same)
4. open file /home/your_username/.ssh/id_rsa.pub with your favorite text editor, and copy contents to your Git repository’s keys field (GitHub, beanstalk, or any other repository provider), under your account.
5. Be sure that you don’t copy any whitespace while copying public key’s content (id_rsa.pub)

Head 4: Additional info

When you create private / public SSH keys on your machine (that’s what you did in above steps), it’s not enough. You need to give your public key to the repository in order to pair the Git server with your local machine (that’d be steps 4. and 5. above).

Most of the popular repositories will give you web interface access to the application, and here’s how it looks like on beanstalk when you did all you needed, for example:

After this step, you’re ready to start using Git.

Head 5: Conclusion

I hope this wasn’t to complicated to follow, and also I hope it was helpful to someone!

Cheers!

First of all, what do I mean by “quite heavy”. Well, imagemagick as my example is great image manipulation tool, but it takes quite a lot of CPU power compared to gd library that PHP uses. And if you have a site that has something around 50 users at the same moment who use imagemagick in the same time, with poor server they’ll mots probably create a mini DDOS attack on you, non intentionally. A solution for Linux based servers is “CPU limit”.

About CPU limit

CPU limit is open source Linux based solution that gives you option to limit each process’s (by PID) CPU power consumption in percentage. So for example, you can always limit your apache to 2% of CPU, and MySQL to let’s say 10%. Its pretty much straightforward, so you can fit your needs.

Installation process on Ubuntu

There are few steps to complete this tasks, so here they are in right order:

First, 2 packages are needed, and you can install those with following commands:

sudo apt-get install cpulimit
sudo apt-get install gawk

Next step is to create Daemon for CPU limit:

#!/bin/bash
# ==============================================================
# CPU limit daemon - set PID's max. percentage CPU consumptions
# ==============================================================

# Variables
CPU_LIMIT=20       	# Maximum percentage CPU consumption by each PID
DAEMON_INTERVAL=3  	# Daemon check interval in seconds
BLACK_PROCESSES_LIST=   # Limit only processes defined in this variable. If variable is empty (default) all violating processes are limited.
WHITE_PROCESSES_LIST=   # Limit all processes except processes defined in this variable. If variable is empty (default) all violating processes are limited.

# Check if one of the variables BLACK_PROCESSES_LIST or WHITE_PROCESSES_LIST is defined.
if [[ -n "$BLACK_PROCESSES_LIST" &&  -n "$WHITE_PROCESSES_LIST" ]] ; then    # If both variables are defined then error is produced.
   echo "At least one or both of the variables BLACK_PROCESSES_LIST or WHITE_PROCESSES_LIST must be empty."
   exit 1
elif [[ -n "$BLACK_PROCESSES_LIST" ]] ; then                                 # If this variable is non-empty then set NEW_PIDS_COMMAND variable to bellow command
   NEW_PIDS_COMMAND="top -b -n1 -c | grep -E '$BLACK_PROCESSES_LIST' | gawk '\$9>CPU_LIMIT {print \$1}' CPU_LIMIT=$CPU_LIMIT"
elif [[ -n "$WHITE_PROCESSES_LIST" ]] ; then                                 # If this variable is non-empty then set NEW_PIDS_COMMAND variable to bellow command
   NEW_PIDS_COMMAND="top -b -n1 -c | gawk 'NR>6' | grep -E -v '$WHITE_PROCESSES_LIST' | gawk '\$9>CPU_LIMIT {print \$1}' CPU_LIMIT=$CPU_LIMIT"
else
   NEW_PIDS_COMMAND="top -b -n1 -c | gawk 'NR>6 && \$9>CPU_LIMIT {print \$1}' CPU_LIMIT=$CPU_LIMIT"
fi

# Search and limit violating PIDs
while sleep $DAEMON_INTERVAL
do
   NEW_PIDS=$(eval "$NEW_PIDS_COMMAND")                                                                    # Violating PIDs
   LIMITED_PIDS=$(ps -eo args | gawk '$1=="cpulimit" {print $3}')                                          # Already limited PIDs
   QUEUE_PIDS=$(comm -23 < (echo "$NEW_PIDS" | sort -u) <(echo "$LIMITED_PIDS" | sort -u) | grep -v '^$')   # PIDs in queue

   for i in $QUEUE_PIDS
   do
       cpulimit -p $i -l $CPU_LIMIT -z &amp;   # Limit new violating processes
   done
done

If you wish to auto-start the Daemon on PC start, you have to do the following 3 steps:
Step 1:

sudo chmod 700 /usr/bin/cpulimit_daemon.sh

Step 2: Now save this to /etc/init.d/cpulimit:

#!/bin/sh
#
# Script to start CPU limit daemon
#
set -e

case "$1" in
start)
if [ $(ps -eo pid,args | gawk '$3=="/usr/bin/cpulimit_daemon.sh"  {print $1}' | wc -l) -eq 0 ]; then
    nohup /usr/bin/cpulimit_daemon.sh >/dev/null 2>&1 &
    ps -eo pid,args | gawk '$3=="/usr/bin/cpulimit_daemon.sh"  {print}' | wc -l | gawk '{ if ($1 == 1) print " * cpulimit daemon started successfully"; else print " * cpulimit daemon can not be started" }'
else
    echo " * cpulimit daemon can't be started, because it is already running"
fi
;;
stop)
CPULIMIT_DAEMON=$(ps -eo pid,args | gawk '$3=="/usr/bin/cpulimit_daemon.sh"  {print $1}' | wc -l)
CPULIMIT_INSTANCE=$(ps -eo pid,args | gawk '$2=="cpulimit" {print $1}' | wc -l)
CPULIMIT_ALL=$((CPULIMIT_DAEMON + CPULIMIT_INSTANCE))
if [ $CPULIMIT_ALL -gt 0 ]; then
    if [ $CPULIMIT_DAEMON -gt 0 ]; then
        ps -eo pid,args | gawk '$3=="/usr/bin/cpulimit_daemon.sh"  {print $1}' | xargs kill -9   # kill cpulimit daemon
    fi

    if [ $CPULIMIT_INSTANCE -gt 0 ]; then
        ps -eo pid,args | gawk '$2=="cpulimit" {print $1}' | xargs kill -9                    # release cpulimited process to normal priority
    fi
    ps -eo pid,args | gawk '$3=="/usr/bin/cpulimit_daemon.sh"  {print}' | wc -l | gawk '{ if ($1 == 1) print " * cpulimit daemon can not be stopped"; else print " * cpulimit daemon stopped successfully" }'
else
    echo " * cpulimit daemon can't be stopped, because it is not running"
fi
;;
restart)
$0 stop
sleep 3
$0 start
;;
status)
ps -eo pid,args | gawk '$3=="/usr/bin/cpulimit_daemon.sh"  {print}' | wc -l | gawk '{ if ($1 == 1) print " * cpulimit daemon is running"; else print " * cpulimit daemon is not running" }'
;;
esac
exit 0

Step 3:

sudo chown root:root /etc/init.d/cpulimit
//Set the ownership
sudo chmod 755 /etc/init.d/cpulimit
//Set the privileges
sudo update-rc.d cpulimit defaults
//Add script to boot

And only thing left to do is test it out. You can do that with following commands (which are self-explanatory):

sudo service cpulimit status
sudo service cpulimit start
sudo service cpulimit stop
sudo service cpulimit restart

Conclusion

Well, I not the author of those scripts, but I think it is quite useful, and I wanted to share it with all of you. So have fun with limiting your processes!

Version control systems

Great thing for both backups as well as for versioning your software. Whoever uses / has used SVN, CVS or Git knows what I’m talking about. Although backup isn’t their primary function, you can easily pull some old version, and start over if some things got too corrupted to fix.

Manual backup (“copy – paste” backup)

Some will for sure say that I’m a dinosaur just for mention it. But if you read this article so far, please read on. You won’t have one click / one command to get your version from lets say – last Tuesday. You’ll have to do at least 4 clicks to do so. And if you don’t think of some “naming convention”, you’ll most probably end up searching for your file for at least an hour, again unlike VCS solutions.

Well, since I still haven’t wrote down single reason why should anyone use manual backup over VCS, here it is:

Real life example

Personally i use Git as primary version control system, just to be clear. But also I create manual backups on daily basis (at least 1 week of versions, and after that I keep general versions). Recently there was a problem with Git merging of branches – it got corrupted. So a full time week of work of both my colleague and me (cca 80 hrs).

I took my manually created copy from day before, and replaced my local version of project on git. Did some Git’s HEAD modifications, and committed as last version. Combined with great IDE which has local version control system of its own, I’ve managed to get my branch working as it was when it got corrupted in 45 minutes.

Conclusion

Some of you will perhaps still say that I could do this or that, but I disagree. Mainly because I work in a company that bills per hour, and this would mean that either the client would get billed 8 hours more for same amount of functionality (from business side – impossible) or in my bosses head I’ve cost him 8 billable hours (this would have happen). And if I had to recreate a week of work – I cant even imagine that.

I hope you now understand the importance of manually created backup copies. And I hope at least some of you will make a practice of this.

Cheers!

Since I used Array store I modeled my data into an array.

 var vari = Ext.util.JSON.decode(results.responseText);

//names of the fields
Ext.each(vari.fields, function(ell, ind) {
                names[ind] = vari.fields[ind],
                i_total++
            });

//data to be shown
Ext.each(vari.results,function(el,i){
                values[i] = vari.results[i],
            });

//input element count
Ext.each(vari.flag, function(el, i) {
                if (vari.flag[i] == "I") in_elem++;
            });

Now that we got our data the way we want it we need to put it in a store:

var store = new Ext.data.ArrayStore({
                autoDestroy: true,
                autoload:false,
                data:values,                       //values need to be array of arrays if youre using ArrayStore
                totalProperty: vari.total,
                fields: names,                     // names is an array containing names of the fields
                proxy: new Ext.data.ScriptTagProxy({
                    url: 'proxylink ?>',
                    method:'POST'
                })
            });

Now let’s prepare heading for our grid:

//array col has data needed for showing of the grid and inputing data in a grid: header and dataIndex
var col=[];
Ext.each(names, function(el, i) {
                if (i + 1 == in_elem) {
                    col[i + 1] = {header:names[i], dataIndex: names[i],id:'end-row'};   //this gives the last input field an id so you can style it to separate the data
                }
                else {
                    col[i + 1] = {header:names[i], dataIndex: names[i]};
                }
            });

//making a selection model
            var sm = new Ext.grid.CheckboxSelectionModel({
                listeners:{
                    selectionchange: function(sm) {
                        if (sm.getCount()) {
                            grid.deli.enable();
                        } else {
                            grid.deli.disable();
                        }
                    }
                }
            });

            // making selection model the first column in the column model
            col[0] = sm;

            // adding the rest of the columns to the column model
            var cm = new Ext.grid.ColumnModel({
                columns: col,
                defaults:{sortable: true}
            });

And now lets make our grid:

var grid = new Ext.grid.GridPanel({
                id:'gridin',
                store: store,
                loadMask:true,
                cls:'inval',
                colModel: cm,
                sm:sm,
                //title: 'In values',
                stripeRows: true,
                viewConfig:{forceFit:true},
                //clicksToEdit:1,
                height: 365,
                width: 1080,
                columnLines:true
});

store.load({params:{start:0, limit:10}});
grid.render('sample');

And we’re done . Our dynamic grid should be shown now. Everytime you make a new request you will be able to upload new set of data, regardles of the number of columns or rows. This grid can also be editable, but that’s another story.
Cheers!

I’ve been using it for over 6 months or so and this review will be based on their 2.0 EAP. They are releasing bug fixes and features/enhancements on almost weekly bases. You can check the progress on their blog and track the change-list.

The following points are based on the app itself and not as a comparison to any other IDE on the market. Also, Im writing this mainly from a front-end developer perspective so bare with me.

1. Local history

“…Is independent of external version control systems and works with the directories of your project even when they are not under any VCS control. It applies to any structural artifacts: a project, a directory or package, a file, a class, class members, tags, or selected fragment of text.”

It works the way it’s supposed to and never fails. The moment you set up the project, like “Magento” it keeps track of all changes in the files and even folders. Once you need to compare the files with a previous version it’s a piece of cake to find the differences between files in a nice and intuitively highlighted file comparison window. Only textual files are kept inside the local history and for the files over 1MB it only tracks the very fact of the changes.

Note: PhpStrom has the version control integration built in so you can control the project through SVN, GIT, Mercurial or any other major versioning system you’re using. It even has GitHub integration off the bat.

2. Refactoring

The refactoring feature has been built in since it’s earliest versions. With the latest build of the 2.0 EAP it has some great refactoring options:

- Search for references (File)
- Rename accessors (Field)
- Rename containing file (Class, Interface)
- Rename parameters in hierarchy (Method parameter)
- Rename inheritors (Class, Interface)
- Rename Heredoc/Nowdoc delimeters

If while performing refactoring any conflicts occur, PhpStorm will display a dialog box with a problem description. At this point you can ignore, preview or cancel the action.

A more detailed description of refactoring can be found at their site or once you download the app check put the manual which has an extensive overview of features with examples.

3. Productivity

This one is a killer feature. In fact the main purpose of this app is to make your life as a web developer as easy as possible while programming full-time.
From autocompletion to numerous shortcuts and de-cluttered workspace it becomes your extension rather than just a tool. It even has a “Productivity guide” built-in so you can keep track of all of the features that you use or what’s more important what you’re not that could be of great benefit to you.

Here’s a second screenshot of all of the productivity enhancements you can find in PhpStorm.

4. Deployment

This one is a huge feature that makes my job a lot easier. Starting from setting the default server configurations and mapping the working folders, comparing local and deployed files to a great feature of optional “Automatic upload” with a neat sub-option of saving upon changing the window focus. This makes my work as streamlined as possible. Combine this with local history by checking the differences between the deployed version and the local version and your teamwork is a breeze. Supports FTP, SFTP, mounted folder and local.

5. Editor

Here’s the list of the editing features that PhpStorm currently has:

- Syntax and error highlighting. The color attributes are configurable in the Colors and Fonts | <language> page of the Settings dialog.
- File templates for the supported languages that enable creating stub classes, scripts etc.
- Live templates for creating complicated code constructs.
- Code completion.
- Code generation.
- Code folding, formatting, and highlighting.
- Zen Coding
- SASS support
- Intention actions and quick fixes.
- Possibility to view code hierarchy.
- Quick access to the API documentation.
- Using macros in the editor.
- Advanced search and replace facilities.
- Advanced means of navigation.
- Refactoring.
- Import Assistance

It’s fast, accurate and if you follow the “Productivity guide” as much as possible and of course over time you’ll be pouring code in no time. Since I’m 90% of the time editing the css and xml files I honestly couldn’t go back to anything I’ve previously used. Period.

Ivica, my team colleague uses it for 99% of time for PHP and Javascript and every now and then he gets amazed by the way the editor alone works. I hope he’ll make a review from the back-end development perspective soon

I’ll have t stop here and let you try it yourself since the more I try to be as brief as possible I keep wanting to add every other feature that this app has.

To conclude this. As in the humble beginnings of my PhpStorm usage and now after more than a half a year later, one thought remains. It’s this: The guys at JetBrains did this application (and WebStorm) with developer in mind from start to finish. Even now, they keep focused on their work to make this app a developer’s extension rather than just a product to sell.

I’d like to point out that the two most famous types of version control systems are:

• Centralized version control system – subversion (SVN)
• Distributed or decentralized version control system – Git

And that’s the big difference, others are just a small smaller things that are based upon this main fact. I won’t say that they don’t matter, au contraire, like French would say, amount of that small things is greater in volume than you’d think.

And now, enough with the “general stuff”, let’s put everything on a list.

SVN

SVN is a powerful version control tool and many companies have been using it for quite some time. Over the history, it became the most popular version control system in the world.

The “Pros”

• SVN is well-known, wide-spread solution that makes everyone comfortable.
• Its centralized repository makes tracking simpler
• There are only two basic commands (used on daily basis):

1. svn commit or svn ci. This command recursively sends your changes to the SVN server. It will commit changed files, added files, and deleted files.
2. svn update or svn up. This command syncs your local sand box with the server. If you have made local changes, it will try and merge any changes on the server with your changes on your machine.

• SVN help is more organized and to the point. Even a quick Google search will get you much more simple examples than for Git

The “Cons”

• SVN stores a pristine copy of every checked-out source file on the client side, in a subdirectory of “.svn“.
• Space requirement is much greater than with Git
• Requires Internet connection for many “daily” stuff – which makes it much slower compared to Git

Git

The “Pros”

• Stronger branching than any other Source Code Management
• Faster than SVN (in this example) – mainly because it does common tasks like “diff” locally, which include

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

• Smaller complete “filesize” of repository

The “Cons”

• Overkill on documentation (IMHO) – can’t easily find small examples
• It can get difficult to track branches and revisions

The Conclusion

Although SVN is the popular choice, I’d go with Git any day. Not because I’m geeky (and Git would fit into that perfectly), but from the developer side. The fact is that when using version control system, you’ll mainly do a “push”, “pull” and “difference”. And If it has to be directly on server, it will get lagged sometimes (depending on the changes and connection). Git’s capability to create number of “commits” locally and putting it to server with one push is great. Combined together with “difference” locally its my choice of tool. Solely on those two facts.

On the other hand – you will hear that some clients require SVN, and you’ll almost never hear that kind of request for Git – that’s true. But you can always use SVN for specifics, and Git for your comfortability on other projects. And another relevant fact – when I looked into material for this article – I almost couldn’t find an article “SVN over Git” – it was the opposite way.

To “conclude the conclusion” – small example from “real life” I found on the Internet:

For example the Mozilla repository is reported to be almost 12 GiB 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 MiB. SVN requires 30x the disk space to store the same history.

As this is exclusively my opinion, I’m very interested in yours. Please express yourselves!

Cheers!