What is a view?
The view is the presentation of your application, the part that our user sees. The view won’t do any processing (like math, checking data,…) it will just show data.

Why don’t you separate your logic and view?
I don’t know how or I don’t use a framework. Those are both often heard excuses when I ask someone why he doesn’t separate the logic and view of his application. Even when you don’t use a framework your can perfectly separate your logic from your view.

Consider the following example that is based on a real-life application. Don’t mind the code just watch what a difference it makes when you separate your logic and presentation.

And now lets look at the same piece of code again but then refactored:

The second code is much easier to read and maintain the first one, with just a minimal of effort. Lets take it a step futher.

Application structures, multitier architecture

A three tier application

One of the simplest architectures is the three tier structure. This architecture is commonly used in applications. (also take a look at MVC)

A four layer application
Often a fourth layer is added, the domain layer. By adding a domain layer we have a distinct between our business logic and the data access layer (mostly a database).

Why do we need to separate them?
There are a lot of advantages when you separate your business logic from your presentation logic.

• the code will be easier to maintain.
• the logic will be easier to read and understand because it is not mixed with presentation code.
• It is easier to reuse code if the presentation is not mixed. The layout of a application will almost always be different when writing a new application but the logic behind it can be exactly the same.
• by using different layers in your application each layer can be developed by another team simultaneously.
• you will be able to completely change the domain layer to retrieve data from another source then the database without touching the other layers in your application.

Conclusion
So even if you don’t use a framework it should be no problem to separate logic and presentation. It isn’t about which framework or structure you use, just use someting that brings some kind of organisation in your applications.

Click the image below to see an example of liquid scaling:

So how do I get such a result? Well with PHP GD library it would take a whole lot of code, thinking and beers to get a script that does the same without exceeding your memory_limit, with ImageMagick however it is just one simple command.

The nice thing about ImageMagick is that you can often accomplish very sophisticated image effects with just one command, you can also chain commands. Now although IM has a quite good documentation guide available you maybe just want to be able to perform basic image operations with IM without seeking your way trough the documentation all the time. Their are some PHP classes available that will make your life easier.

• PhMagick is a simple wrapper class and provides a set of methods to perform the mostly used image operations
• MagickWand is a PHP extension that allows to communicate with the IM api
• Imagick is also an extension

My personal favor is PhMagick or a home brew script, why? Well I like the idea of wrapper classes more, my code is somewhat more portable because I don’t have to install the IM extension on a server and another PHP extension to communicate with it, furthermore I think that using wrapper classes gives you more insight in IM itself, you will better understand what is going on, on the other hand you probably will spend some hours to figure out why the command is not doing what you expected it to do because you are missing a simple ! or ^ parameter option.

Personal experience on installing IM on the server
Some time ago I wanted to install IM on my new dev and live server, the dev server is running OSX and the live server is running a Fedora distribution. So the first step before I tried to install IM was to read the documentation (yeah I’m one of those guys that also actually reads the readme files and documentation of products). I followed the “Install from source” tutorial. So I started with the live server, after downloading and unpacking IM I ran the ./configure command immediately I was faced with the error “no acceptable c compiler found in $PATH”, now my Linux skills are far from topnotch, so after some googling I found out that the easiest way to fix this issue was to install GCC (GNU Compiler Collection) that already included a C compiler. After installing GCC and running the ./configure command everything went fine, IM was installed successfully. I wanted to test if it was working correctly so I tried to resize several images but again an error occurred “convert: no decode delegate for this image format”, okay perhaps I should read the documentation more carefully next time because before installing IM you should also install the image libraries that you will use. In my case this was “yum install libjpeg libjpeg-devel libpng libpng-devel libtiff libtiff-devel”, now again I needed to install IM again, not much work, but still something to remember when installing IM. On the dev OSX server installing ImageMagick was quite simple, I used a precompiled dmg and only needed to install the Apple XCode developer tools.

So to summarize:

Advantages of using ImageMagick:

• it uses less resources, forget about the memory_limit issues with PHP when using GD and large images
• it’s slighty faster (note: depending on the filetype and image size GD beats IM in speed when it comes to resizing
• Image Magick has support for more filetypes
• as I showed before, it is very simple to use
  1. exec(‘convert "’.$sSourcePath.‘" -resize ‘.$iWidth.‘x"’.$sDestinationPath.‘"’);
• Some very nice features like liquid scaling or seam carving

Disadvantages of using Image Magick:

• you need to have full access to your server, it isn’t bundled with PHP
• compiling IM can give some trouble, you shouldn’t forget to get the image libraries you want to use

Useful links

• ImageMagick website
• ImageMagick examples

• First download the installer at the Google Git OSX installer project, http://code.google.com/p/git-osx-installer/downloads/list after running the installer you are good to go.
• After this easy GUI installation it’s time to startup the terminal, although if you really are into GUI’s you can also download and install OpenInGitGui which can be found at http://code.google.com/p/git-osx-installer/wiki/OpenInGitGui. In your terminal go to the directory where your website is located and initialize a new repository here.
  
$cd site_directory
$git init

  You should now get a response like “Initialized empty Git repository in site_directory/.git/”. The next step is to add the current directory and all of its contents to the repository.
  
$git add .
$git commit -m "Initial import"

  You will now see that all files and directories are committed.

Basically this is it, nothing more to it. You could now start working with Git. Off course we can configure the Git installation just a little bit to set things right.

Basic configuration of Git, ignoring files and configuring the user settings
Whenever you will type “git status” on the current directory you will see if there are any changes that need to be committed, if so you can add them with the “commit” command like we did before. One of the first problems that you will bump into is that your cache files will also be committed. I personally don’t want to commit automatically created cache files or user content. So how can we deal with this? We can create a “.gitignore” file in the root of our project. You can find an example of the .gitignore file below.

*.cache
files

Now any file that has the *.cache extension will be ignored, also all the user content in the files directory will be ignored. This keeps our repository clean. By executing “git show” after committing the .gitignore file you will see that our ignore rules are correctly interpreted.

When you view the Git commit log of the project (“git log”) you will see that Git has already automatically used an author name and email address in the commits we did so far. These values are automatically detected by Git that examined your system configuration. You can change your name and email by executing the following commands:

$git config --global user.name Sjoerd Maessen
$git config --global user.email youremail@address.com


Taking advantage of Git
Off course we didn’t install Git just to add one project and change some basic settings. The power in any version control system is to make checkouts, revert and diff changes. Below you can find some basic commands that you will need to master.

$git checkout thepath
$git diff commitid1 commitid2
$git diff -- filepath
$git revert commitid1

The commands are pretty self explaining like all other commands of Git. If you already worked with other version control systems their is one thing to be aware of, “git revert” doesn’t behave like “svn revert” for example. “Git revert” will do a new commit to reverse a previous one, if you would like to undo your changes you should use “git checkout” instead. The things I have showed above are only small aspects of what Git is capable of. Cloning repo’s, tagging, branching, patching and resolving conflicts are all aspects that will make your life a lot easier, check them out at the Git community book

One more thing
There are some Git GUI repository browsers available that let you view who, why and when something was committed. One that is easy to setup and PHP only is viewgit, give it a try it will just run from your webserver!

http://viewgit.sourceforge.net

• filter_has_var — Checks if variable of specified type exists
• filter_id — Returns the filter ID belonging to a named filter
• filter_input_array — Gets external variables and optionally filters them
• filter_input — Gets a specific external variable by name and optionally filters it
• filter_list — Returns a list of all supported filters
• filter_var_array — Gets multiple variables and optionally filters them
• filter_var — Filters a variable with a specified filter

Pratical use

Sanitizing
“Filter input escape output” every developer knows this but it is a repetitive job but with the filter extension filterering input became a lot easier. When you correctly filter input you drastically lower the change of application vulnerabilities.

Sanitizing a single variable

Sanitizing multiple variables, same principle as above but with an array, the filter will sanitize all values inside the array

Validating an email address

Validation a complete array
Validating all your data at once with a single filter will make your code clear, all in one place and is more easy to maintain an example below.

Note: okay I did not expect that the string ’21′ would validate true against FILTER_VALIDATE_INT, after some more testing I also noticed that min_range and max_range only work with FILTER_VALIDATE_INT, when using floats or scalars the options are just ignored, so be aware!

The sanitizing examples above can be made easily more restrictive by adding flags like FILTER_FLAG_STRIP_LOW to the sanitize filter, FILTER_FLAG_STRIP_LOW will for example strip all characters that have a numerical value below 32.

Things to consider
Although the filter functions are some time available some of them aren’t flawless, at some points the documentation is missing or very unclear. Another example is the filter_var validation for IPv6 addresses. (see bug report #50117). So it is always a good thing to check if the filter is really doing what you expect it does. Write testcases before using. If you use it correctly you can write your validations in the blink of an eye, and this extension will be your new best friend.

Links
Filter functions
Filter flags

The last couple of weeks I was working on writing a mailing/newsletter system myself. One of the first questions that came up was “how do I prevent that my newsletter will be marked as spam”. Although this article has nothing to do with PHP I still like to put it in the spotlight. I will give some tips on how to avoid your mail being marked as spam, some you will know, others you won’t.

How is determined if my email is spam?
Mostly this is done by so called spam filters (server side or client side), some well known examples:

• Spam Assasin
• k9
• MessageLabs
• CleanPort

Some of them work with the Bayesian filter. This filter is one of the most accurate filters available. It will detect 98% of the spam mails by an algorithm. Essentially the filter will check if words occur a lot in spam mails but not in normal mails, if spam words occur a lot in a mail we can assume we are dealing with a spam mail. Before we can use this filter we need to build a database with legitimate words. This database is build by the filter, it monitors all outgoing mails from the user and the incoming mails. By checking which words are used in the outgoing mails from the user it can “learn” which words are legitimate. Each word will get a score, the score will represent the probability of the mail being a spam mail (the mail in which the word appears).

An example:
We take the word “casino”, let’s suppose this word occurs in 100 of the 500 spam mails and only in 5 of the 500 legitimate mails. The spam score for this word will be:

(100/500) / (5/500 + 100/500) = 0,95

Off course spam filters use a lot of other techniques too.

Tips to lower your spamscore
I hope you now have a more clear understanding of how the most spam filters work. So lets start with some tips.

• don’t use words and phrases that are often used in spam mails, for a small list see the Microsoft Junk E-Mail Filter Readme, also the use of complete phrases in capitals is killing.
• use a dedicated mailserver, why? Most filters will recognize the IP from which a mail is coming, if the mailserver IP is recognized as a server from which the filter is getting legitimate mails more often, it will work in your advantage
• Don’t send any attachments with a mailing, virus scanners aren’t too happy about them, neither are spam filters
• Send good content. Try to make the content of each newsletter as different as possible, filters will recognize texts that have occurred before. Also pay attention not to send just one big image and just a few lines of text, you will get a penalty for that one too. Find a balance between the amount of images, the size of them, and the amount of text.
• Use a real mail address from which the newsletter is coming, filters will often check the domain (using an address with a domain like hotmail, gmail, yahoo,… doesn’t count).
• Don’t use url shorteners, url shorteners like bit.ly or TinyUrl are often used by spammers

A last one, but nevertheless an important one “don’t prevent your mail being marked as spam”. Okay that sounds silly right? What I mean is that if you write a whole paragraph in your mailing about how someone can unsubscribe this will be seen as suspicious also avoid text like “this is not spam”.

More tests that will possibly increase your spam score can be found on the website of SpamAssassin. Some tests that caught my eye:

• use of the tbody html tag
• message body has many words used only once (this one increases your spam score a lot)
• Invalid date in header (wrong EST timezone)

Keep the above in mind when writing your next mailing good luck!

Consider the next example:

We could write the above like this:

Personally I think the second example is much easier to understand and a lot clearer for someone who isn’t familiar with PHP then the second one. (unfortunately my code highlight plugin thinks different though ) No braces in the code will also prevent some people to get the idea it’s to difficult to use PHP inside HTML and that integrating PHP into HTML is a task for PHP developers only. Also notice the advantage when indenting the HTML code.
Futher it helps me to distinguish in my own projects template files and controllers, models,… because of the different syntax. So when I have a a file with mixed PHP and HTML this is the preferred way for me.

Great! Let’s start using it!
Good idea but bear in mind that their are a few drawbacks:

• Not all servers allow the shorttags (check the short_open_tag entry in your php.ini file)
• Not using ; in the above example is a bad practice and should be avoided
• The most important one, their are other template engines on the market like Smarty, Dwoo, Savant, Template Blocks and a lot more that do the same thing but then easier or better (although you have minimal overhead)

Futher I should note their are some heavy discussions (still?) going on in the PHP community whether the short tags are genius or just plain evil. One thing is pretty sure now the short tags will still be available in PHP version 6.

For the complete list of the alternative syntax visit php.net

Please fill in the poll and leave a comment.

The first step: setting up a versioning system.
I chose Mercurial not because I think it’s the best, not because it’s the easiest one but just because I didn’t know anything about it yet. (and maybe a little bit because I already saw it had a prepackaged version for Windows)

Installing Mercurial was really easy it only take like 3 minutes before everything was running and I had my first repository created. I could explain what I did but actually I just followed this manual can’t get much easier then that. Because I use Netbeans as my main IDE I could start working right away, Netbeans as build in Mercurial support.

One thing I really liked about my Windows pc at work is that has Tortoise SVN installed for repobrowsing and a lot more. Now Tortoise SVN is not an option when using Mercurial, but hey there is a good alternative called Tortoise HG.

Because I mainly use OSX at home I also installed Mercurial on my Mac, again, it worked immediately.

I must say setting up a versioning system can’t get much easier then this, I expected a lot hassle but it all went very smooth, thumbs up for Mercurial!

The first step, create a simple class that we will use to request data from
We will create a class with one method that returns a string with the parameter we called it. The method will accept one parameter and will check if the value is correct.

Nothing special here, notice that we don’t throw a normal exception but return the SoapFault instead so we can handle the error clientside.

The second step, create a WSDL document

The WSDL document is a simple XML document that describes:
- the service itself
- the operations of the service
- the data types used in the service

The WSDL will describe our method getItem from our Blog service class so we can call it later on.

So how does this WSDL thing look like?

The fourth and final step, test our webservice

Its a good idea to test the webservice with a program like soapUI, it often can provide some additional information when troubleshooting. (They have a free version available on their website).

To test our webservice in PHP we can use the following code:

You should see a SOAP fault, because the id number 4 we gave to the getItem function didn’t exist in our Blog service class. Change the value to 1,2,3 or 5 and you should get a nice response back.
Another pretty neat function is $oClient->__getFunctions(); it will return all the function that are available in the webservice.

This was just a short introduction to SOAP, a lot more is possible with SOAP.
Special thanks to David Zuelke for the nice SOAP introduction at the PHPbenelux conference 2010.

Example files:
Webservice.rar

Just deploy the example files on your webserver, change the {siteUrl} values in the files with your domain and call the client.php

As you can see a simple but effective function.

The problem I ran into was that the UPS API returns the shipping rates with the currency of the country where the rates for are asked, so you can’t force it to always return the rates in EUR.

One solution to convert the prices is to make a very big array with all currency rates in it. I then would maintain the array every day at 9′o clock to check if the rates weren’t changed. Right, that’s not an option.

Like you might know you can easily convert currencies by using the Google search engine. For example searching on “1 Euro to dollar” will retrieve the Euro in dollar.

Below the class I wrote to convert currencies using the Google currency converter.

Pretty straightforward as you see.