There are a hundred and one thousand things that can go wrong with any web server installation. From a fresh installation to an installation that has been running for a long time, you never know when something is going to cause your web server to go astray. When it does happen, it’s always nice to know that, usually, Occam’s Razor applies.

In this tutorial you will find some advice that will help you through some of the more common issues that can pop up with an Apache web server.

Is your server actually running?

Believe it or not, this has happened to plenty of administrators. You take the server down, do some maintenance, and when you go to check out the server you’re getting errors. The first thing you do, naturally, is check out that /etc/apache2/apache.conf file to make sure your syntax is correct. But it’s perfect! What’s up? The first thing you might want to check is to make sure the server is running. But you don’t want to just issue the command to start the server or reload the server. Instead, issue the command:

sudo /etc/init.d/apache2 status

Which should return something like:

* apache is running (pid 9751).

If not, start the server with either:

sudo /etc/init.d/apache2 start

or

sudo apache2ctl start

NOTE: If you are using a distribution like Fedora, SuSE, or Mandriva you will need to first su to the root user and issue the above commands WITHOUT using sudo.

It’s not running and it won’t start

Did you just make changes to your Apache configuration file? Are the changes correct? If you’re not sure, you can use the apache2ctl command to check the syntax of your configuration file. This is done with the command:

sudo apache2ctl configtext

The above command should report:

Syntax OK

If you don’t get an OK, you will get information that points to the errors in your configuration file.

Apache wants to download .php files!

This is another common issue. When you add a new tool on your web server (such as Drupal), if your configuration file is set up properly, any .php file might not be displayed. Instead any attempt to view a .php file will instead have your browser trying to download the file. Why is this? Apache must be informed that certain extensions are to be displayed, not downloaded. This is done from within the Apache configuration file. Open up that file (in the Ubuntu server it will be /etc/apache2/apache2.conf) and first look for the following line:

DirectoryIndex index.html

If that file doesn’t include index.php nearly all sites that use php will be rendered useless.

The second line to look for is:

AddHandler application/x-httpd-php .php

If you find this line, and it is commented out, make sure you uncomment it by removing the “#” character. If it is not there add it to the bottom of the configuration file.

And, as always, when you make a change to the configuration file, restart Apache.

Know where to look for problems

Finally, it is crucial that you know where to first turn when the above doesn’t help you out. Any time I have an issue with Apache where Occam’s Razor does not apply, the first place I turn is the log files.

If you look in /var/log/apache2 you will find, at least, the following files:

• access.log: This keeps track of any connection made to your server.
• error.log: This keeps track of any errors that occur with Apache.
• other_vhosts_access.log: This is where virtual hosts will log when the virtual host has not been prescribed its own log file.

Of course, as your site evolves so will your available log files. Regardless of what you find in /var/log/apache2, that is where you should always first turn when you have problems. Even before you google.

Final thoughts

Now you should be able to handle some of the more common issues with the Apache server. And if your problem isn’t common, you also know where to turn to find clues that will lead you down the right path to correction.

Related posts

• Portable Web Server (8)
• Local Apache Web Server Wampserver (3)
• How to: Install a LAMP server (6)
• Host your own webserver (18)
• Wordpress template tags you should know (4)

Wampserver is an Apache web server for the Windows operating system. It provides in many regards the same functionality of other web server solutions like XAMPP or Home Web Server which we have reviewed in the past. The latest version of the local web server package will install Apache 2.2.11, MySQL 5.1.36 and PHP 5.3.0 on the local computer system.

One interesting unique feature is the ability to add different versions of Apache, MySQL and PHP to the installation in the form of add-ons. This can be very handy to test a website locally under multiple different Apache, MySQL or PHP release versions.

The installation of Wampserver will always install the latest versions of Apache, MySQL and PHP. One interesting security feature is the ability to limit access to the web server to localhost. It is required to click on the “put online” option to make it available to other computer systems as well.

Additional Apache, MySQL and PHP versions can be installed from the Wamp add-ons page. All add-ons are provided as executables that can be installed easily on the operating system.

Webmasters who need to test code offline can use Wampserver to do so. It is especially useful to test code against multiple versions of Apache, MySQL and PHP. Something that the other home server solutions do not provide.

Wampserver is Open Source and can be downloaded from the developer’s website.

Related posts

• Portable Web Server (8)
• How to: Install a LAMP server (6)
• Host your own webserver (18)
• Web Development: Standardizing variables to code faster (18)
• Web Development: PHP – what role does it fill (1)

• Linux
• Apache
• MySQL
• P (can mean PHP or PERL – depends upon your needs)

LAMP servers are very popular, cheap, effective, flexible, and reliable servers. But how are they installed? Actually, it’s not that hard. In this tutorial I am going to show you how to install a LAMP in two different ways: From the command line (using separate tools) and using the tasksel tool.

Hardware needed

Fortunately a LAMP server can be installed on lower-end hardware and still serve as a fairly efficient server. Naturally if you are going to be using your LAMP server for high traffic, you will want to select your hardware wisely.

Install prerequisite

Before you begin the installation of your server you will need to have your operating system installed. This is the “L” of LAMP. So find your favorite Linux distribution and install the operating system. For the purposes of this installation I am going to be installing on a Ubuntu 9.04 server installation. This will be a console only server (no GUI desktop) which is fine because the installation is done via command line only.

Once you have your operating system installed you are ready to install your server.

Apache

This is the easiest portion to install. Either log in to your console or open up a terminal window (if you are working from a GUI desktop) and enter the following command:
sudo apt-get install apache2

You will have to enter your sudo user password for this installation to continue. Once this installation is complete check it by pointing a browser to that server IP address. You should instantly know if Apache is up and running.

PHP

For the purposes of this article we will assume the “P” stands for PHP. To install PHP (and all of its requirements) issue the command:

sudo apt-get install php5 libapache2-mod-php5

Once this installation is complete restart Apache with the command:

sudo /etc/init.d/apache2 restart

Let’s make sure this portion works properly. To test this create a file in the Apache document root (for this install it will be /var/www) called test.php. The contents of this file will be:
< ?php phpinfo(); ?>

Save that file and then point your browser to http://IP_ADDRESS/test.php

Where IP_ADDRESS is the actual IP address of your server.

You should see “Test PHP Page” written on your browsers page. If so, you’re good to go.

MySQL

Now to install MySQL. To do this issue the command:

sudo apt-get install mysql-server

Once this is done you then need to set a password for MySQL. To do this issue the command:

mysql -u root

which will put you in the MySQL prompt. From this prompt (which looks like mysql> ) enter the command:
SET PASSWORD FOR 'root'@'localhost' = PASSWORD('YOURPASSWORD');

Where YOURPASSWORD is the password you want to use for the mysql user.

Now start your MySQL server with the command:

/etc/init.d/mysql start

That’s it. Your LAMP server is up and running.

The quick version

You can actually install a full-on LAMP server on a (Ubuntu server install) with a single command:

sudo tasksel

You will need to select LAMP from the list and you will eventually be prompted for a MySQL password. That’s it.

Final thoughts

Getting a powerful, flexible web server up and running will take you less time and effort than you think. LAMP servers are an outstanding choice for your web servers’ needs.

Related posts

• Portable Web Server (8)
• PHP – what it does and what it doesn’t (4)
• Local Apache Web Server Wampserver (3)
• Web Development: Standardizing variables to code faster (18)
• Web Development: PHP – what role does it fill (1)

Displaying valid markup code in websites, forums, blogs and any other page is not difficulty. The only thing that needs to be done to achieve this is to convert all entities before pasting the code. This can be done manually or by using a script like that offered at Spacefem.

All that needs to be done is to paste the code into the form and click on the Make Code button at the bottom. To display the following code on a website

<a href="http://www.ghacks.net/">Ghacks</a>

one would have to paste the following code into the form on the website where the code should be displayed

<a href="http://www.ghacks.net/">Ghacks</a>

This is actually the easiest way to ensure that the website will not interpret the code and that the code will be valid markup code.

Related posts

• Web Development: PHP – what role does it fill (1)
• Web Development: How does PHP work? (21)
• Scriptastique web development roundup (4)
• PHP – what it does and what it doesn’t (4)
• How echo works in PHP (2)

One of the better scripts to display cached RSS feeds in a website is SimplePie. It might look a bit intimidating at first glance as it provides lots of options to customize the display. It is however very easy to display a feed with just a few lines of code. Start by downloading SimplePie from the website. Extract it to the computer system and upload it to the root folder of the website. You should also create a directory called cache in that root folder and make it writeable (chmod to 777).

Now add the following two lines to the top of the php file where you want to display the feed in. The first line defines the location of the simplepie.inc file on the web server (which is in the simplepie directory in root), the second the feed that you want to display on the website.

<?php
include_once $_SERVER['DOCUMENT_ROOT'] . '/simplepie/simplepie.inc';
$feed = new SimplePie('http://feedproxy.google.com/Ghacksnet');
?>

Now place the following code in the location on the website where the feed should be displayed. This will fetch the five newest feed items and display them in the selected location.

<ul>
<?php foreach ($feed->get_items(0, 5) as $item): ?>
<li>
<a href="<?php print $item->get_permalink(); ?>">
<?php print $item->get_title(); ?></a>
</li>
<?php endforeach; ?>
</ul>

And that’s it. SimplePie offers a wealth of additional functions and settings to display more than one feed or mix feeds. The default caching time is 60 minutes.

Related posts

• Web Development: PHP – what role does it fill (1)
• PHP – what it does and what it doesn’t (4)
• Web development roundup (1)
• Scriptastique web development roundup (4)
• Publish RSS News Feeds On Twitter (6)

The tag we need is called “wp_list_categories()” and by default it lists all your categories in alphabetical order. All we need to do is add some arguments to it to modify the default values and we’re done! We need to limit the number of items shown to five, we also want to show the post counts in the categories and we want to order the list by the post count, in descending order.

The “number” argument actually has no default value. The reason for this is that it limits the SQL query directly, so there is no need for it by default. We can add it though to impose a limit, so our first argument will be “number=5″. We also want to show the post counts, so we use “show_count=1″ to enable this (show_count=0 is the default).

We also want to order the list by the post count, so we use “orderby=count” to achieve this. By default lists are sorted ascending, meaning that the lowest post count would show up first. To make the list descending, we can use “order=DESC”.

I also use one last argument in there, which is “title_li=”. This sets the title of the list to be nothing, by default the list is presented with a title. I like to hard code my titles for a few reasons, but feel free to change this as you like. So here is the complete code I used, one simple line to do a seemingly hard task, enjoy

<?php wp_list_categories(’number=5&show_count=1&orderby=count&order=DESC&title_li=’) ?>

If you’d like to read some similar articles, take a look at Scriptastique, a blog all about web development and coding, with great tips on CSS, HTML, PHP, MySQL and Javascript and tutorials and screencasts coming soon! You can follow us on our RSS feed, or Twitter where we’re posting 3-4 short tips daily now!

Related posts

• Wordpress Blogs: Create Custom Tag Pages (5)
• Zoundry Raven portable Blog Editor (6)
• Wordpress: Your attempt to edit this post has failed (8)
• Wordpress template tags you should know (4)
• Wordpress Remote Admin Password Reset Vulnerability (13)

The great thing about these tags is that they are very well documented “see link above”, and that they are extremely simple to use. You don’t need to know anything about PHP, so let me explain their basic use in common sense language. Wordpress uses a loop, elegantly called “the loop” in “Wordpressian”, which cycles through the posts you have.

If you show 10 posts on your main page, the loop cycles through the latest 10 posts. This means that one the first loop it will pull in the data of your latest post, on the second pass it will look at the second and so on. All the data is pulled, all you need to do is specify what you want to display out of that data, let’s take a look at how.

First of all, you need to identify the start and the end of the loop. The loop starts with the following (there may be some variation) :

<?php if(have_posts()) : ?>
<?php while(have_posts()) : the_post(); ?>

And ends with a “<?php endwhile; ?> <?php endif; ?>”. This end statement is usually followed by the page navigation links which let you “turn the page” to the next or previous posts. Anything inside the loop gets executed as many times as the number of posts which are shown.

If all you want is to show your title, you just need to put “<?php the_title() ?>”, and you will get the titles of your first 10 posts. If you also want to show the tags you can add “<?php the_tags() ?>”. There are many others you can add, and don’t forget, you also need some HTML and CSS to make them look good.

Here’s a list of the most basic ones and what they do, but you can see the full list and expanded usage by clicking on the link above. Remember that the following should be put in the form: <?php function() ?>

• the_title() – outputs the title of the
• the_content() – displays the actual post body
• the_category() – displays the categories the post is in
• the_tags() – displays the tags for the post
• the_author – outputs the post author’s name
• the_author_url – outputs the link to the author’s page, used a lot in links with “the_author”
• the_time() – outputs the time of the post, you need to add the format in the parenthesis
• the_permalink – outputs the posts permalink, usually used in a link with “the_title”

While I use many others now and again, there are loads of designs that only use these 8, you can do a lot, with these alone. As you can see, adding to and modifying a Wordpress template is not such a big deal, why not try it yourself?

If you’d like to read some similar articles, take a look at Scriptastique, a blog all about web development and coding, with great tips on CSS, HTML, PHP, MySQL and Javasctipt and tutorials and screencasts coming soon! You can follow us on our RSS feed, or Twitter and Facebook!

Related posts

• Web Development: How does PHP work? (21)
• How to show 5 top categories in Wordpress (9)
• Do more with your Wordpress using the function reference (3)
• Zoundry Raven portable Blog Editor (6)
• Wordpress: Your attempt to edit this post has failed (8)

Now, you could have different pages like “about_english.php” and “about_spanish.php”, but this would make updating a pain, and very inflexible, plus if you have 20 languages, it means 20 files per page. So how do we get around this? Let me introduce you guys, to PHP constants.

A constant is defined just like a variable, but as its name suggests, it is in fact constant. It can be echoed just like a variable, and is great for defining set pieces of text. Let me show you my method of using constants to easily keep multiple language versions of a webpage, without having to have multiple files for each page.

First of all, let’s take a look at how to define constants. Constant names are uppercase strings, but must not begin with a number and should not start with a special character. For example, let’s define a constant:

define(”NAME”, “Daniel Pataki”);

In this exampe we have defined a constant called “NAME”, and gave it a value of “Daniel Pataki”. I gave the constant a describing name, so I know that this constant holds my name.

The way I create multiple languages is that I create 1 language file for each language. I name them according to the standard 2 letter convention. The English file is named “en.php”, the French would be “fr.php” and so on. I include the language file the user needs at the beginning of all my other files containing text, so they will automatically be defined. There are many way to approach this, but for now, let’s say that the page is always in English, unless a user clicks one of the language links. So at the beginning of the code I would write:

<?php
if (isset($_GET['lang']))
include($_GET['lang'].”.php”);
else
include(”en.php”)
?>

This way the relevant file will be included only. Each file contains the list of definitions I need in the same structure. My name in the English version is “Daniel Pataki”, but in Hungarian we put our family names in the front, so in “hu.php” I would define it as:

define(”NAME”, “Pataki Dániel”);

In the page’s code, I can then simply type the following to display my name:

<h2><?php echo NAME ?></h2>

This would show my name as a level 2 heading. If the user is viewing in English, the output would be “Daniel Pataki”, if the user is viewing in Hungarian it would display “Pataki Dániel”, since this time “hu.php” is included, and not “en.php”. Notice that when displaying contants you do no need to put any special characters before or after the constant name, just type the constant itself as you defined it.

You can use this method to create languages for larger sites too. The reason I especially like this is that it is quite easy to translate the site, you just need to send the file over to someone and he will be able to do it easily, without any training. If you have a larger site it might be a good idea to indicate where the constant will be used. You can do this by defining a constant name like “SIDEBAR_COMMENTS’, or “CONTACT_NAME”. This way you and your translators will have an easier time, especially if you also use PHP comments in the language file for further pointers.

<em>If you liked this article, perhaps you’d like to take a look at <a href=”http://scriptastique.com”>Scriptastique</a>, which is a blog (and upcoming tutorial site) aimed at professional and aspiring coders. We just started, but there are daily posts and the tutorials (along with screencasts) are on the way!</em>

Related posts

• Wordpress template tags you should know (4)
• Web Development: Standardizing variables to code faster (18)
• Web Development: PHP – what role does it fill (1)
• Web Development: How does PHP work? (21)
• Web Development: A brief history of time() (3)

We had a look at how a mysql query basically works, which will come in handy if you’re just learning about MySQL and PHP. The article focuses more on the technical side than how to create specific queries, but we’ll get there in the end too! Just after that we created some simple but effective excerpts from longer text automatically removing unwanted characters and spaces.

We also had a look at website mascots, why you should use them, how to use arithmetic operators in PHP and just today, why a coder should always be well slept (easier said than done). If you feel like taking a stroll down web development avanue visit the site, or follow us on Twitter or our RSS feed!

Related posts

• Web Development: PHP – what role does it fill (1)
• PHP – what it does and what it doesn’t (4)
• Web Development: Standardizing variables to code faster (18)
• Scriptastique web development roundup (4)
• Portable Web Server (8)

The basis of this is to use php code to determine the directory of the page you are viewing and also the page’s name itself. I will show you the code in a second, but let’s say you have a social network site underway and you keep you messaging system (outbox, inbox, new message, etc.) in a folder named “messaging”. In this case you can grab the name of the directory and the page and assign these as an id and a class to the body tag automatically, so it would look like this for the inbox: <body class=”messaging” id=”inbox”>.

This will make it very easy to add new rules in your stylesheet, since you can refer to whole documents in a directory using “body.messaging” and you can refer to specific pages using “body#inbox”. You can now use the same CSS file to change the look of only one page without the need to go in and add new classes and ids all the time. So how about the code to grab the directory and the page? Let’s take a look!

First of all, let’s determine the page. For this we will use the “$_SERVER” superglobal variable which stores a lot of valuable information about the page you are viewing, the IP viewing the page and so on. Here’s the code as is, with the explanation coming up afterward.

function page()
{
$page = substr(strrchr($_SERVER['PHP_SELF'],'/'),1,-4);
return $page;
}

As you can see this is a function because I use it a lot throughout the site, not just for this one purpose. “$_SERVER['PHP_SELF']“ will return the path to the file with the filename from your root directory, so it will look something either like this: “/directory/subdirectory/file.php” or if the file is in the root directory it will simply be “/file.php”. To get only the filename we want to chop off all the bits before the slash (and the slash itself), and also chop off the file extension.

As you can see the first thing I did was to chop off everything before the last slash using “strrchr()” which returns the part of the string after the last occurrence of the sub-string you specify. However, the last slash still remains, but this is not a problem, we can get rid of this, and the “.php” part in one go.

This is done by using “substr()”. The function took three arguments, the string we want to work with, and two integers. The first integer tells the function to start from character 1 (this means everything before that will be chopped off, in this case character 0, which is the slash) and then return everything up to the -4th character from the end. This means that four characters will be dropped from the end.

Now the variable “$page” contains only the readable part of the filename which would be “inbox” or “index”, without any slashes or the extension. You could also create this as a variable without using function. the reason I use a function is that I usually have some extra code in there which allows me to echo the function at once by default, but also to store it as a variable if needed.

Now, let’s take a look at determining the directory. We could take the same approach as before but chop off different bits, but PHP already has a function which will make our life easier, let’s take a look at the code:

function thedir()
{
$dir = substr(strrchr(getcwd(), '/'),1);
return $dir;
}

Using “getcwd()” we can get the current working directory. This will be in the form of “/directory/subdirectory”, so all we need to do is return everything after the last slash and chop the last slash off. We use the same technique as before, so now we also have our directory. Once done, all you need to do is modify your header, which should be in a PHP file to make the body tag look like this (calling the functions as the names for the class and id):

<body id="<?php echo page() ?> class="<?php echo $thedir ?>"">

There are some other ways to do this, some can be simpler or more complicated, this is more like the proving of a point, but it is totally usable and I use a modified version of it throughout my sites. This is not a whole lot of code extra and will make your site better structured and easier to modify.

Please be aware that “getcwd()” can give you some weird results if you changed your current working directory somewhere in your code. In this case you can use a modified version of the ‘page getting’ code, or you can take a look at the server superglobal section in the PHP manual for some more help.

If you’d like to read some similar articles, take a look at Scriptastique, a blog all about web development and coding, with great tips on CSS, HTML, PHP, MySQL and Javasctipt and tutorials and screencasts coming soon! You can follow us on our RSS feed, or Twitter and Facebook!

Related posts

• Web Development: PHP – what role does it fill (1)
• PHP – what it does and what it doesn’t (4)
• Web development roundup (1)
• Scriptastique web development roundup (4)
• How to show 5 top categories in Wordpress (9)

Right now we only have the blog, but tutorial sections and screencasts are on their way! To keep gHacks readers in the know, I will be doing a weekly short roundup of posts, if you like some of them, head on over to the site, take a look and participate in all the fun! So let’s jump to it, here’s what we covered on week 1.

• Checking MySQL queries for errors
• Creating your first function in PHP
• How the internet works – domains and hosting
• Create cool icons in a flash for your website
• Creating rounded corners using only CSS

We have a few more up there, and you can follow us on Twitter and our RSS feed or join us on Facebook. If you have any questions or comments feel free to let me know!

Related posts

• How echo works in PHP (2)
• Ghacks Web Development PDF Article Compilation January 09 (6)
• Web Development: PHP – what role does it fill (1)
• PHP – what it does and what it doesn’t (4)
• A standard compliant web browser and editor: Amaya (2)

Instead of creating a separate HTML page for each post we make, we enter our posts into a database. Each post is then assigned an id. We simply create one page, say posts.php and the code for that page contains a query, plus all the necessary HTML for displaying a post. This query will pull one specific post from the database and put the correct pieces where they should go in the template.  We can tell the script which one to pick by passing it a variable in the url. If the value of this variable is 135 for example, the post that will be pulled will be the one with this id.

You can see right away how valuable this is, you can build truly dynamic pages with this method. Your data is better organized in a database, and you can change the way you display it by simply modifying the HTML code, no need to recreate any content whatsoever. So how is this done on a code level? Let’s take a look!

You need to use a PHP file obviously, and after the extension you need to write the names and the values of the variables you want to pass in the following format: http://url.com/page.php?variable=value&variable=value. Notice that initially we use a question mark to separate the variable name passed from the extension, but after each subsequent variable passed we use an ampersand.

You can easily retrieve these variables in the code, referencing them with $_GET['variable']. For example, let’s say the url you use is the following: http://scriptastique.com/post.php?post_id=345. In this case inside the PHP file the value of $_GET['post_id'] is 345.

Using the ‘get’ method you can pass strings, not just integers, so you could pass the name of the referring url, the name of a user, whatever you need. You should be aware though, that using the get method is unsafe if you want to send sensitive data. For example, you wouldn’t want to pass a user’s password from one page to another using the get method for many reasons, but mainly because it is displayed in the url bar.

For other things like telling a script which post you want to show, or which category you want the description for it’s fine, and a very comfortable way of organizing a huge site into just a few files, in fact, I think this is one of the best features of PHP!

If you liked this article, perhaps you’d like to take a look at Scriptastique, which is a blog (and upcoming tutorial site) aimed at professional and aspiring coders. We just started, but there are daily posts and the tutorials (along with screencasts) are on the way!

Related posts

• Wordpress template tags you should know (4)
• Web Development: Standardizing variables to code faster (18)
• Web Development: PHP – what role does it fill (1)
• Web Development: How does PHP work? (21)
• Web Development: A brief history of time() (3)

<?php
echo ‘Hello World’;
?>

I hate Hello World examples, but this shows what we are doing pretty well. Basically the echo command will write out that phrase “Hello World” (the quotes will not be shown, the single quotes above are part of the code), so if you open that file using Firefox for example you should simply see the phrase.

This seems straightforward, but to really understand what’s happening, and to be able to work with PHP efficiently we need to dig a bit deeper to see what really happens when we echo something.

The most important thing you need to understand is that PHP is a server side language. This means that whatever code you write is never sent directly to the client (the viewer of your site for example). When someone opens a PHP file form the next the file is first processed by the server, and only the result is shown to the user. This is why you will never see PHP code if you view the source of a page.

You also need to know that once the server has processed the file it retruns pure browser readable code. I would say pure HTML, but obviously your PHP file can contain inline javascript, just like your HTML files. Now echoing something tells the server that whatever is echoed should be placed as is into the HTML file. This means that whenever you want to put HTML tags when you are echoing you can do so by writing them as you would in an HTML file itself, like this:

<?php
echo ‘<strong>Hello World</strong>’;
?>

Once the server has returned its result, this is downloaded by the browser and processed like usual, so your “strong” tags wil be taken into account and will indeed bold text.

So what’s the point of sending the server that bit of code if all it does is just put it in like it was HTML? Well, the answer lies further down the road, but basically this is helpful because you can prevent/enable specific of section of code reaching the client, so the viewer only downloads what he/she needs, not the whole file. A simple example:

<?php
$random = rand(0, 99);

if ($random > 50)
echo ‘Number is above fifty’;
else
&nbsp; &nbsp; echo ‘Number is equal to or less than fifty’;
?>

Without really understanding what’d going on I can still explain. We create a variable, the value of it will be a randomly generated number between 0 and 99. If this number which we just generated is above 50 then we should echo that it is above fifty, in all other cases (it is below or equal to fifty), we should echo the other statement.

This is processed whenever someone loads (or reloads) a page, so the variable “$random” will always be different, generated “on the fly”. The script then checks the number, and only the relevant piece of code is returned, so if the number generated is 55 the only piece of code that you will see in the source will be:

The number is above fifty

Obviously this is a bit over-simplified, but in real life this is basically what happens. You can also use this to generate different pieces of code for different days of the week, and the change will be automatic, you only need to program once. You can also use it to create one file to display all your posts (like in Wordpress), so you don1t have to code a page for each post you write. PHP is awesome, start lovin’ it!

If you would like to read more articles like this, take a look at Scriptastique, a new blog by the writer, Daniel Pataki. The site will contain different articles from the ones published here, and will eventually have complete tutorials for numerous programming languages.

Related posts

• Scriptastique web development roundup (4)
• Ghacks Web Development PDF Article Compilation January 09 (6)
• Web Development: PHP – what role does it fill (1)
• PHP – what it does and what it doesn’t (4)
• Web Development: HTML Playground (7)

The most common server architecture on which PHP is found is called LAMP (for Linux + Apache + MySQL + PHP). All of the elements of LAMP are open source, meaning that the source code of the application is freely available. This means that the cost of setting up a server running LAMP is reduced (No License Fees), so LAMP based web hosting tends to be the least expensive solution available.

The Internet is built on a client-server architecture. On the client side we have the user and the browser. One the server side we have the server and its script interpreter (In our case, Apache and PHP).
Because PHP runs on the server side, we cannot use it for flashy client side effects, things like animations and auto-complete cannot be performed by php because php is only running on the server. For client side programming we could use javascript, Flash/Flex, Silverlight, or JavaFX.

What we can do with PHP is access a database, connect to other websites/services for information, and build a page out of smaller pieces, which we then deliver to the client for rendering.

I think it is important to indicate at this time that there are four levels at which you can work with PHP.

1. Scripting – this is where you take a small script and add it (integrate) into an existing page.
2. Coding – this is where you write scripts as needed to add basic functionality to your site.
3. Development – this is where you write an full application in PHP.
4. Architect – this is where you properly design an application that develop it into an application. Like development but puts a lot more thought into a good foundation.

Depending on your actual needs, several of these layers could be overkill for your task. The following articles will mainly be focused on the first two levels – scripting, and coding. In Scripting and coding we have two primary tasks we accomplish. One makes your job as webmaster easier. The second adds new functionality to your site.

Jeremiah Stover is a Software Engineer and a Business IT Consultant at Pragmatic Development. He has hands on experience and regularly provides practical advice in Business, Marketing, IT equipment and software. His Specialties include interpersonal communications, design skills, teaching and instruction. Right now he spends most of his time developing web applications in PHP and MySQL.

Related posts

• Web Development: PHP – what role does it fill (1)
• Ghacks Web Development PDF Article Compilation January 09 (6)
• Web Development: HTML Playground (7)
• Web development roundup (1)
• Scriptastique web development roundup (4)

The following web development articles have been published in January 2009 at Ghacks:

How does PHP work?
HTML Playground
PHP – what role does it fill
Standardizing variables to code faster
Web Development: A brief history of time()

You can download the pdf document by clicking on the link below.

ghacks web development january 09

Related posts

• Web Development: PHP – what role does it fill (1)
• Scriptastique web development roundup (4)
• PHP – what it does and what it doesn’t (4)
• How echo works in PHP (2)
• Web Development: Realtime Fonts Changer (1)

HTML is a markup language that lets us describe attributes of the text and blocks on our pages. This works great for simple requests, making pages much more interesting than plain text. However it leaves us with a very simple structure. One page from One url (address) results in one rendered content (every time this url is requested, the output is the same).

To give us more options we have programming languages. Some like PHP run on the server side. They modify the content that will be displayed before it is sent to the client and on to the browser. Others like JavaScript run on the client side and allow changes to be made in the browser after the page has been rendered – usually for interactivity or for adding a feature not normally available in that browser.

The very first thing you _must_ do before getting started with PHP is get a good grasp of HTML (and CSS). Many webmasters use a tool like Dreamweaver, Expression Web or KompoZer. To
work with PHP it is important that you understand the underlying HTML code. You will be modifying this code so you need to be able to understand the HTML well enough to understand what you see.

If you like video training try Lynda.com or VTC.com. If you prefer reading a book try “Head First html with CSS & Xhtml” or if you prefer free web instruction try w3schools.com and tizag.com.

Now that you understand the markup language which is what is sent to the browser (HTML) you are ready to tackle the server side use of PHP.

Jeremiah Stover is a Software Developer at Pragmatic Development. He specializes in client communications. While PD does offer a full range of IT services and consulting, they are currently specializing in website development in PHP/MySQL.

Related posts

• PHP – what it does and what it doesn’t (4)
• Ghacks Web Development PDF Article Compilation January 09 (6)
• Web Development: HTML Playground (7)
• Web development roundup (1)
• Scriptastique web development roundup (4)

The most important thing to understand is the difference between HTML and PHP. In HTML you write your code, upload it, and the user’s will subsequently download that page along with all the code. The user’s browser interprets this code and shows the user the page as you intended it (hopefully). In other words HTML is sort of what you see is what you get, in the sense that all the code goes to the user and is interpreted by the browser.

With PHP it works a bit differently because you don’t actually download the code the author wrote. What happens is that if you want to download a php page the code in that file is first processed by the server, and you download the output of the code, as opposed to the whole code as is. This in turn will be HTML just as before, this is why you never see PHP code in the source of a webpage. So what happens in processing? Turn the page to find out!

With PHP the goal is to use the processing powers of the server to build (usually) dynamic webpages. A very basic example is showing the correct greeting for the time of day on a webpage. In human terms you write a script with the directions to show “Good Morning” if it is before 10am but after 5am, “Good Afternoon” if it is after 10am but before 6pm and “Good Night” after 6pm, before 5am. Instead of receiving all the code for this and processing it in your browser, this all gets processed before you download it, and you only get the result of the process, the text “Good Night” for example if it is 9pm.

This is much quicker, since if you think of bigger sites, instead of having to download 300kb (or much more) of code, it is quickly processed on the server and you might get as little as 10kb or less. Obviously your PC could process the code quickly, but downloading and handling can take a while. In addition, the code may also have database queries which can not execute if processed on your PC, they have to be processed on the server which has the database.

If you would like a more real-life example, take a look at gHacks, which has almost 5,000 posts now. In HTML world we would have to have 5,000 posts which all have the whole site code, from header to footer with the article in between. PHP makes it possible to “compress” those 5,000 files into only 1!

When you view any gHacks post on a single post page you are actually viewing a file called single.php. This file also has some additional info in the url which will tell the script which post to show, so the file you are viewing would be single.php?p=234. This tells the script that the post with the ID of 234 needs to be shown. The script queries the database for the relevant post and pulls its details (like title and post body) from the database. So in the end all you are shown is one post. Wordpress has some other stuff built in to make nicer URL’s and so on, but under the hood this is what is happening.

Likewise for the front page we don’t always go and modify the code when posting something. Martin would be coding all day, removing the last post on the page and pasting the code of the new one. Instead, in the php file you are viewing the code gets the latest 10 posts and puts their data on the page.

There is a lot more to learn in PHP, but those are the basic mechanics, the ability to create pages based on certain criteria, as opposed to static content on each page.

Related posts

• Wordpress template tags you should know (4)
• Web Development: PHP – what role does it fill (1)
• Scriptastique web development roundup (4)
• PHP – what it does and what it doesn’t (4)
• How to show 5 top categories in Wordpress (9)

Echoing the time() function will give you the amount of time passed since the Unix Epoch in seconds. Say what? Epoch means a point in time chosen as the start of a period or an era and thus the Unix Epoch is January 1 1970 00:00:00 GMT. So echoing the time() function will give us “1230978041″ at the time I’m writing this, meaning that 1,230,978,041 seconds have passed since then. So why is this useful to us?

Mathematically it gives us a much easier way of keeping track of time. Sure, 2008, Jan 15th might seem all nice and organized to you, but to calculate the days passed from the 15th of Januaray to the 17th we’s have to strip the numbers of “th”, and in more complicated cases perform a bunch of other string changes. Using time you can essentially assign a number value to any given second, making it much easier to use, especially as a counter.

The place I use it most is to log out users of a website automatically after an inactivity period. When a user signs in I create all the session variables for him/her, and I also create one which holds the time his session should expire. The beauty of this whole system is that I do not need to know the actual time, I can just assign a value to the session variable like this:

$_SESSION['user']['time'] = time() +3600

This means that the user can stay logged in for 3,600 seconds (in other words an hour) from this moment in time. This is a very convenient way of defining expiration time, since you can think in terms of how long you want it to be, as opposed to trying to calculate a specific date and time.

When a user refreshes a page, or moves on to a new one, a script will check the value of the session variable. If the current time is smaller than the session variable, the user can stay logged in and I also usually prolong the session by another 3,600 seconds. This gives it the true “inactivity” aspect, since the user is allowed to stay logged in for more than an hour, as long as he/she is using the system. You could however choose not to prolong the session, in this case the user would have to log in again after one hour no matter what. In some high security systems this might be the way to go, or if you want the user to spend exactly one hour on a specific puzzle, there are many uses for everything. Needless to say that if the current time is more than the session variable the user is signed out.

Another common use for time() is to serve as the basis for generating a random ID, or character set, in other words, it can serve as a seed. A quite efficient way of creating a very random string would be to use time(), divide it by a random number generated between 0 and 9,999, add some random characters to it, and encode the whole thing using the SHA1 algorithm for example. Code-wise this is not as difficult or as long as it may sound, and it is pretty random and strong, although I am no security specialist.

if you have any cool uses for the time() function let us know in the comments!

Related posts

• Wordpress template tags you should know (4)
• Web Development: Standardizing variables to code faster (18)
• Web Development: PHP – what role does it fill (1)
• Web Development: How does PHP work? (21)
• Web development roundup (1)

If you’ve been coding for a while you probably have some set ways in which you work. I recommend you also widen this method to naming variables, which when done consistently can be a huge help, especially when you are using some fancy MySQL along with your PHP code. If you are building a site with 15 MySQL tables it is helpful if you know all the column names because you always name them in the same way, but the same thing goes for simple variables, and even ids and classes for HTML elements.

A very common example can be variables which hold a user’s data. In my case I always use the variable ‘$u’ for holding the username, and the variable ‘$p’ for holding the password. If you are grabbing a lot of data, like first name, last name, email and so on you can make up your own standard set, I use ‘$fn’, ‘$ln’ and ‘$e’ respectively for the three.

Since you usually use these variables in the same script the importance of naming them consistently may not seem like a huge time saver. However when you get into session variables it saves you a lot of time if you don’t always have to look at where you are defining them to find out the names of each. I pull user data using a mysql query when a user logs in and I immediately place the whole array in a session variable name “$_SESSION['user']“. The names of the columns represent the values of this array, so the username and email would respectively become “$_SESSION['user']['Username']“, “$_SESSION['user']['Email']“. This is the same in my case for every single website I build where applicable.

User data naming consistency is also very prominent in the MySQL tables themselves. As you can see above my columns are also named the same in each case, a user’s email is always “Email”, his last name is always “LastName”. I steer clear of abbreviations with MySQL tables so other coders can easily see what’s going on as well. Consistency doesn’t just apply to the actual names, you can also apply it to cases. As you can see all my column names are always capitalized, they are like wikiwords, but user session variables which don’t come from MySQL are not capitalized. For example, when a user logs in he is assigned a time, which is usually one hour. If he/she is inactive for more than this time (no refreshes), he/she is logged out. There is no need to store this in the database, and so I know that this is not in there the session variable here is “$_SESSION['user']['time']“. This means that if I come back to work on a site a year after completion I know exactly where variables come from.

Even if you don’t yet know any PHP, you’re just getting into HTML and CSS you can still use these good practices. When assigning ids and classes to elements try and work out a structure for yourself that you always use. I use empty div tags to clear floats a lot, so I have a separate class named “cl” for this purpose. Whenever I start out a new webpage I include this class by default in the stylesheet since I know I will most likely need it.

That’s about it for standardizing your coding work, most of it is just common sense really. Try and work out your own method which works best for you. It takes time and a lot of practice to get a system working well since there is so much to think of, but if you always keep this in mind somewhere while coding you’ll be a faster and better coder in no time at all!

Related posts

• Web Development: PHP – what role does it fill (1)
• Web development roundup (1)
• Portable Web Server (8)
• PHP – what it does and what it doesn’t (4)
• Local Apache Web Server Wampserver (3)

The web server can be downloaded in various configurations. The various configurations range from a bare-bone Apache web server to a web server supporting MySQL, SQLite, Pearl and PHP. The configuration only has an effect on the type of applications that can be run on the web server. Most users will probably need at least MySQL and PHP support to run their websites locally.

The web server can be started by double-clicking on the Server2Go.exe executable file in the root directory of the server. This will load the various web server modules and display a start page in the web browser. The pms_config.ini file can be used to change various settings of the web server including the default web browser, the port and whether the modules like MySQL or PHP should be started as well.

The actual files of a website are placed in the htdocs directory of the web server. Loading them can be as easy as pointing your browser to 127.0.0.1:4001 or some subdirectory of it depending on the type of site.

MySQL comes with phpMyAdmin which is accessible from the main interface of the web server. Server2Go offers an uncomplicated way to run a web server, it is especially helpful in environments where software installations are restricted.

Related posts

• Local Apache Web Server Wampserver (3)
• How to: Install a LAMP server (6)
• Host your own webserver (18)
• Web Development: Standardizing variables to code faster (18)
• Web Development: PHP – what role does it fill (1)