My meeting with a celebrity

Last week, a colleage and myself were fortunate to participate at a one day GSE Nordic WebSphere User Group conference held at Bouvet’s offices in Oslo. One of the conference speakers was Stefan Hepper from IBM Germany. Stefan works as the WebSphere Portal Programming Model Architect and leads the programming model part of IBM’s flagship portal product, IBM WebSphere Portal Server. However, more importantly (at least to me), he had the honorable task of working as specification lead for the JSR-168 Portlet version 1.0 specification, and is currently working as specification lead on the new JSR-286 Portlet version 2.0 specification. Naturally, Stefan spoke primarily of the new features in the upcoming WebSphere Portal Server version 6.1 product in the context of JSR-286, but the two aforementioned portlet specifications influence every serious Java based portal server like IBM’s WebSphere Portal Server, SAP Enterprise Portal, Oracle Portal Server, Liferay and JBoss Portal Server, just to name but a few.

However, although Stefan answered a lot of question during his talks, oddly enough, for me the highlight was sharing a taxi and a 20 minute train ride from the conference back to Gardermoen airport (main Oslo airport) where we loosely discussed portlets and portals in depth, and Stefan willingly shared his knowledge with us indiscriminately. It goes without saying that this guy really knows his “stuff”, but it was also quite fascinating to hear how a Java Community Process expert group works in practice. I admit that I knew little of how the JCP works behind the scenes before our conversation, but I got the impression that Stefan is responsible for a whole lot of the final specification work and seems to carry a “heavy burden” by leading the group. However, you won’t find a nicer guy willing to help you with anything related to Java portlet/portal development should you need to call upon him for help.

As you may know, the JSR-168 specification is implemented and supported on almost every Java based portal server. The JSR-286 specification is expected to be finished in april 2008 and introduces quite a lot of new features. If memory serves me correctly, Stefan mentioned that the specifcation API has grown by over 100% since version 1.0. IBM WebSphere Portal Server 6.1 is scheduled for release sometime in the second quarter of 2008 and will support portlets complying with either of the portlet standards. It is also possible to communicate between portlets developed on either standard something that was not possible before between the proprietary IBM Portal API and the JSR-168 implementation.

I also mentioned to Stefan that I thought it was odd that there were so few JSR-168 or porlet related books available on the market. It just so happens that he has co-written and almost finalized a Manning book that was never published. It happens to be available for free download from the Manning web site, but requires registration (free). The book is titled “Portlets and Apache Portals” and it looks good. It also seems to cover WSRP (Web Services for Remote Portlets, version 1.0) and also portlet development using JSR-127 (Java Server Faces).

Adding lists in MediaWiki

Introduction

This is a follow up article to the ongoing postings regarding adding content in MediaWiki. The plan is to add more short posting about adding content to MediaWiki. This posting talks about lists.

You can create 3 types of lists in MediaWiki:

• Unordered lists
• Ordered lists
• Definition lists

Unordered lists

Unordered lists are just the normal bullet lists probably familiar from word processing software or plain HTML. You create a new list element by using an asterisk (*) at the beginning of each line. It is important that the asterisk is at the beginning of the line for it to work. You can have no whitespace between the line start and the asterisk. The number of asterisk characters indicates the list element level, so for example:

* First element
** First subelelement
*** First sub-subelement
** Second subelement
* Second element
etc.

Will create an unordered list that gives the following output:

Ordered lists

Ordered lists are pretty much more of the same. However, you use the hash character (#) instead of the asterisk. To restart the automatic numbering you must insert a blank line within the list, so

# First element
## First subelement
### First sub-subelement
## Second subelement
# Second element

Gives the following output

Combining unordered and ordered lists

It is also possible to combine the two list types to make any kind of crazy combination. Check out the following example:

# element 1
# element 2
#* element 3
#* element 4
#** element 5
#** element 6
## element 7
##* element 8
##** element 9
# element 10

Which gives this result:

Definition list

A definition list is a list type you expect to find in a dictionary or a glossary. The syntax is a bit different from it’s list siblings:

;First definition : definition text
;Second definition : definition text

So here we have two definition keys with their matching text definition. The output looks like this:

The definition text itself can expand over multiple lines and can also contain semicolon (;) characters as part of the text as long as the semicolon is not at the beginning of a new line. Like the other list types it is very important not to type any whitespace between the semicolon and the beginning of the new line. The colon character, however, defining the definition list, can be placed just about anywhere you like.

Changing the logo of your MediaWiki site

Introduction

Yes, it looks ugly. It looks a bit better now than it used to in earlier versions of the MediaWiki distribution, but still… it’s just begging to be replaced and you would think it would be just a little more straightforward since it is one of the first things you notice on the wiki site. Yes, that default MediaWiki logo just has to go!

Changing the logo

It’s not that difficult, but you will need access to the web server’s file system. Start off by getting hold of a replacement image, preferably something about the same size and shape as the original.

The default logo is of type png and size 135 x 135 pixels. Locate your LocalSettings.php file in your wiki directory. The wiki directory is probably the wiki/ directory in the document root of your web server. When you have found the file then open it for edit.

Search the file for the string $wgScriptPath. It should refer to the URL base path to the directory meaning is is most likely set to the value “/wiki” or similar. At the end of the file add the following two lines,

$wgStylePath = “$wgScriptPath/skins”;
$wgLogo = “$wgStylePath/common/images/<image>”;

where you replace the text <image> with the filename of your replacement logo image. Then place your new logo file in the directory as referred to by the full path contained in the $wgLogo variable. And that’s all there is to it, really. The change will take effect immediately after you save the LocalSettings.php file, but make sure you don’t forget to end the statements with mandaroty semi-colons on each added line and also make sure the lines come before any closing “?>” at the end of the file. The file must still be valid PHP code when you are finished, after all.

Summary

Your results should look something like in the figure below. I can’t remember where I found the image I am using for my MediaWiki instance, but it is a gif image of size 84 x 64 pixels. As I mentioned earlier, the original default logo image is of type png and size 135 x 135 pixels.

A few good reasons why I prefer open source software

[Ed note: I changed the title of this article from 'Why I prefer open source software' to 'A few good reasons why I prefer open source software'. My boss read my posting and correctly pointed out that there are many other good reasons why someone would prefer an open source model other than just the choice/freedom point I make. In hind site I happen agree with her. Please keep that in mind when reading.]

Introduction

Apparently I’m seen as a bit of an open source software advocate within my company. I admit that I can’t say I’m displeased with that description, but I caught myself asking why that is? And why am I happy as being seen as such?

Sure, I have purchased a “few” T-shirts from the Mozilla foundation and CafePress that help reinforce an indisputable image of my beliefs among colleagues, but still. Why do I prefer open source software over proprietary alternatives?

Choice and freedom

Open source software means different things to different people and there any many other good aspects of adopting an open source software strategy. However, I think one of the main reasons I like it boils down to promoting choice and freedom. In general, I don’t like being forced to do anything I don’t want to do. I like to make my own choices.

Choice is good

When developing software the goal is usually to create components that have high cohesion and low coupling. Well designed software enables you to react easily to change, and the lower the correlation between components, the easier it is to alter behavior. Choice is good, so when picking the software I want to use in my everyday life, or within the systems I want to build, I want to experience the same kind of freedom. I want the freedom to use a set of software components that match my specific needs, and not ones forced upon me because they coincidently just happen to be the ones my operating system supports. I want the freedom to replace any of these components at a later date, with better alternatives should I wish to do so, for whatever reason. And should the person, project or company, behind a particular software component on which I depend, decide to abandon support or further production then I have the freedom to carry on development on my own merit since I have the source code available. That is my prerogative. The choice is mine.

You can use the same analogy in other parts of life. If you are a car owner you wouldn’t accept having to fill petrol at only one brand of petrol station because your car happens to be incompatible with other pumps. Such a car just wouldn’t hit the market because nobody would buy it. The reason is apparent. No, you want the choice to shop for the best petrol price or just buy the first thing that comes along. You have the freedom to make that choice.

Paying for software

It’s not about price. Yes, free sounds great and it’s beneficial to have the option to try something for free instead of paying for a trial license, but in general I don’t mind paying for software and have done so many times in the past. However, I’m finished paying for things I no longer need. For example, I have followed Microsoft Windows since 1991 and have purchased licenses for Windows 3.0, Windows 95, Windows 98 and Windows XP among other things. However, I can state with a high degree of certainty that Microsoft Windows XP will be the last Windows license I will ever buy. My company PC happens to use Microsoft Vista and there is absolutely nothing there that I feel I really need. 98% of my everyday needs are covered by using Kubuntu at home. Now, if only Adobe would consider open sourcing some of their products or at least offer their full portfolio on Linux…

M$ basher

So I guess this means I hate Microsoft? I don’t really. I dislike some of their business methods and the FUD they spread, but Microsoft is a corporation that exists to make money. That is it’s purpose – it is not a charity. Many people are unaware that when I left college my idea was to work for a company that developed Microsoft Win32 applications using C. I saw that as a great challenge and something I really wanted to do. I read many books on the subject. However, that never happened for me and I can’t say I lose sleep over it. I think I have gone on to better things, but I think it’s fair to say that I can see the view from both sides of the fence.
I don’t really dislike the Microsoft software portfolio, but I think some of the people using and promoting the software need to take a good, long look at some of the great open source alternatives available out there and assess if the proprietary software they are recommending is really worth the price. Just what is the total cost of ownership for the paying customer?

One thing that does annoy me is when people can’t distinguish between a PC, the Microsoft Windows operating system and the Microsoft Office suite. Of course, this is more down to their own ignorance than anything Microsoft has done [can be disputed]. It’s a shame, but the market for good software alternatives has been so bad for the last 10 years or so that people have become accustomed to seeing these components packaged together that they just see them as one and the same. That’s a tough nut to crack.

Moving along

The open source world is not what it once used to be. It’s still a movement, a rebellion in a way, but it is definitely growing. Open source software recently reached the boardrooms and more and more companies are reaping the benefits of developing products under an open source license. But let’s not beat about the bush. There is a lot more money involved in open source development today than ever before. Large corporations like Sun and IBM aren’t giving away software to be nice. It is clear that the mindset has changed and so have the business models.

As I said earlier, there are many other good reasons why open software is preferable. However, I can only cover so much in one posting. However, I think the steady rise of open source software is good news for developers, corporations and consumers alike. For the first time in many years they now have the freedom to choose between several viable alternatives and more and more of them seem to be breaking free of their shackles.

Sending SMTP mail with Java

Introduction

So your Java application needs to send a notification mail? Not an uncommon scenario, but how to do it? Luckily this turns out to be pretty easy in it’s simplest form, but SMTP configuration can be the killer. You are of course dependent on being able to access a SMTP mail server and also possessing a little knowledge of the SMTP protocol.

What you need

Some years ago, Sun released the Java Mail API. It doesn’t ship along with the standard Java distribution (yet!) so you will need to download it manually. It can be found here and at the time of writing is at version 1.4.1. The Mail API depends on code from the JavaBeans Activation Framework (JAF) so you’ll need to download that package also. It can be found at this link and at the time of writing is at version 1.1.1. Make sure you add the activation.jar file from the JAF distribution to your Java classpath and you will also need both the mail.jar and smtp.jar files from the Mail API distribution to enable you to send SMTP mail.

The code

The code itself is straightforward enough, but as I said earlier, it’s the SMTP mail server configuration that can turn out to be the problem. Specially if the server is configured to not let you use it indiscriminately to avoid SPAM etc. This will depend on the company policy configuration settings of the SMTP server you are trying to connect to.

OK, here’s a simple example of how it can be done…

import java.util.Date;
import java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

public class Main {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("mail.smtp.host", "your SMTP mail server here");
        props.put("mail.debug", "true");

        Session session = Session.getInstance(props);

        try {
            Message msg = new MimeMessage(session);
            msg.setFrom(new InternetAddress("from@here.com"));
            InternetAddress[] address = {new InternetAddress("to@somewhere.com")};
            msg.setRecipients(Message.RecipientType.TO, address);
            msg.setSubject("Mail subject title");
            msg.setSentDate(new Date());
            msg.setText("Message body string");

            Transport.send(msg);
        }
        catch (MessagingException e) {}
    }
}

So, to summarize, start you of by creating a Java Properties object and populating it with relevant configuration information. You need to specify the SMTP host name or IP address for the key “mail.smtp.host”. The “mail.debug” property is useful for development and will give you a hint what’s going wrong should you get into trouble. Proceed on by creating a javax.mail.Session object and passing it your properties object. To create the actual mail message use a javax.mail.internet.MimeMessage object passing along the session instance you just created. Populate the javax.mail.Message object with a valid sender address and receiver address array (mail has only one sender, but can have multiple receivers). Add a mail subject, the timestamp and of course the mail message body. Then all that remains is to actually post the message to the SMTP server. That where the hard part usually begins.
So, not that difficult all in all, but remember to encapsulate the code in a try/catch block and catch the javax.mail.MessagingException exception type for it to compile. Handle errors appropriately, there is a lot that could possibly go wrong here.

SMTP server authentication

As I mentioned earlier, configuration can be the killer. These days most SMTP servers don’t let any old message pass through the system without some kind of policy checking switched on. It is likely that you will need to authenticate your application to the SMTP server when creating the session object. It is also possible that the server will attempt to validate the sender e-mail address your application is using so you need to choose it wisely since it will need to be valid in the mail domain.

To create an authenticated session object you will need to make a few minor adjustments to the code. Create a javax.mail.Authenticator subclass and override the protected method getPasswordAuthentication. By default this method returns null, so you will have to make it return an initialized javax.mail.PasswordAuthentication object containing your username and password.

You also need to tell the session object to use your new authentication class so add the property “mail.smtp.auth” to your Properties object and set its to “true”. Also change the code that creates the session object by using an overloaded version passing both your Properties object and an instance of your new Authenticator subclass. The new code should look something like this:

import java.util.Date;
import java.util.Properties;
import javax.mail.Authenticator;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

public class Main {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("mail.smtp.host", "your SMTP mail server here");
        props.put("mail.smtp.auth", "true");
        props.put("mail.debug", "true");

        Session session = Session.getInstance(props, new MyAuth());

        try {
            Message msg = new MimeMessage(session);
            msg.setFrom(new InternetAddress("from@here.com"));
            InternetAddress[] address = {new InternetAddress("to@somewhere.com")};
            msg.setRecipients(Message.RecipientType.TO, address);
            msg.setSubject("");
            msg.setSentDate(new Date());

            msg.setText("Message body string");

            Transport.send(msg);
        }
        catch (MessagingException e) {}
    }
}

class MyAuth extends Authenticator {
    protected PasswordAuthentication getPasswordAuthentication() {
        return new PasswordAuthentication("your username","your password");
    }
}

And that ought to do it! This code worked fine for me when testing with two separately configured Microsoft Exchange servers (ESMTP , version 6.0.3790.1830 and 6.0.3790.3959) in different mail domains as my SMTP server host, but only if clear text authentication (BASIC) was enabled on the Exchange server.

In both cases the Exchange server checked my sender address and also insisted that my application authenticate itself before allowing it to post.

Achieving readable output with MySQL

Introduction

Although I like using GUI tools for a lot of things, there are some things I feel you should be able to do without being dependent on a graphical user interface. Using the MySQL console to administer a database is one of them. More than often your only channel of access to a MySQL database server is using a SSL connection to the server host. This is often the case if the database server is configured to disallow connections from any other host than the localhost.

A useful feature

Most users associated with MySQL are familiar with a SQL statement of the form “SELECT * FROM table;” to retrieve table information. It’s one of the first things you learn. However, if the table in question has a lot of columns and contains a lot of records, then you are going to find the MySQL console a bit of a pain when reading the data. Check out the familiar SQL output result in the figure below.

The alternative

Of course you can limit the output listing by using a SQL WHERE clause and specifying the exact names of the columns of interest, but that is not the point of this posting and in some cases you may not be aware of column names you need to use (yes, I am aware of the ‘DESCRIBE table;’ command). As you know, you terminate each SQL statement with the default semicolon ‘;’ character. Without this character the database server console just waits for you to finish your SQL statement indefinitely, but there is an alternative. By replacing ‘;’ with ‘\g’ gives the exact same console output as before. OK, I know what you are thinking. Why is that any better? It’s not, however, replacing ‘;’ with the uppercase variant ‘\G’ is, and gives an output listing in a different, and often more readable, format listing each table record by it’s columns:

SELECT * FROM table \G

See the figure below showing the end of row number 2, the full row number 3, and the beginning of row number 4 from the same table as earlier:

It was only recently that I stumbled across this feature, but I have found it useful on many occasions already.

Summary

I’m sure you can see the benefit of using this alternative statement termination character on occasion. As you can see, records with many columns are a lot easier to read without being forced to limit the record column output using a WHERE clause. I’m pretty sure that using the ‘\G’ termination character isn’t standard SQL, and not something you would want to use when terminating embedded SQL in your application, but a useful feature all the same. It definitely makes reading records easier even if the output may appear to be more verbose at first. You can of course use a WHERE clause or similar as before to narrow down your output further, but using ‘\G’ makes the output easier to read in many situations:

SELECT * FROM table WHERE id = ’something’ \G

Removing default search limitations in MediaWiki and MySQL

Introduction

So let’s assume you have created a page in your Mediawiki site, named it with an appropriate page title consisting of only 3 characters, say SSL or SQL, only to find that it never shows up when searching for it in the MediaWiki site search. You have tried both uppercase and lowercase search query words, you haven’t misspelled the search query (only 3 characters, after all), and you are certain you are searching through the correct MediaWiki namespace. You are also certain that you saved the page, not only previewed it and then made the mistake of closing your browser.

Come to think of it, that page you are 110% certain you read yesterday, referring to the exact same search query word, say ‘SSL’, doesn’t show up either when searching for either of ’ssl’ or ‘SSL’. How can that be? You didn’t delete the page by mistake, did you? This is getting annoying, but are you starting to see a pattern?

As we will see this has nothing to do with searching the wrong MediaWiki namespace (although easy enough to do), misspelling the search query word, distinguishing between uppercase or lowercase search query words, failing to save a page edit or deleting a page by mistake. The cause is simple: by default, the MySQL database server does not fulltext index words of 3 characters or below. To make this possible, you will have to change the configuration of both MediaWiki and MySQL to enable it to search for useful words and abbreviations of character length 3, such as apt, ssh, nfs and the like.

Editing the MediaWiki configuration

It is simple to correct this problem, but you need access to both the web server file system and administrator privileges to the MySQL database server. Locate the LocalSettings.php file in your MediaWiki installation directory, usually a subdirectory of your web server’s document root, say /htdocs on Apache. Edit the file and add the variable wgDBminWordLen to it. Set it’s value to 3, so:

$wgDBminWordLen = 3;

Editing the MySQL configuration

You must also tell the MySQL database server to index 3-letter words in fulltext indexes. This is the core of the problem and this configuration change will also apply to any application using the MySQL database server, not just MediaWiki. Add or edit the [mysqld] heading in your my.conf file with the following configuration line:

[mysqld]
ft_min_word_len=3

And that’s really all there is to it!

Recreate the MySQL table index

So just one more step to go before you can use it. You now need to restart your MySQL database server to load the new configuration setting, and then recreate the search index. So restart your server process, open a console and proceed to enter the MySQL database you use for your MediaWiki installation. Recreate the necessary search index by typing:

REPAIR TABLE searchindex QUICK;

If you prefixed your MediaWiki database tables with a prefix when installing the wiki then the name of your ’searchindex’ table may be wk_searchindex or similar. A simple ‘show tables;’ query will give you a hint of the correct table name.

Summary

This particular fix took me a little while to find. Not that it was hidden, but I was unsure which component was limiting the search. As you have seen it turns out both MediaWiki and MySQL needed to be tweaked to correct the problem. Remember there is a reason why MySQL sets the index limitation to 3 characters by default. By changing it you will increase your index sizes leading to a performance hit. The default setting is 4 characters and I’m sure there is a statistical reason for this. Take a closer look at this page for more information on tuning the fulltext search in MySQL if you are unsure of the impact it might have.

Adding simple content to MediaWiki

Introduction

This is a brief follow-up my earlier posting on creating a personal wiki. Hopefully this posting will help show just how easily wiki content can be added. No need for client side word processors or fancy html editors, publishing software or the like. You simply just access the site and start typing. You don’t even have to log on unless the site administrator (here: you!) requires it. By default anyone can edit page contents which is half the point.

Creating your first document

So if you followed my earlier posting you should now have an empty MediaWiki based installation running. The natural starting point is to either import data into it or create pages by hand. Both are possible, but I will focus on the latter. If you are like me, your first thought will probably be to look for the “Create new page” button. However, you won’t find one! The way to add pages to MediaWiki is to either point your browser to the new wiki page address or use the search box on the left hand side of the wiki site main page. The easiest method is to use the search box and type a page title, preferably something longer than 3 characters (by default MySQL doesn’t index words of 3 characters and below) and then press the “Go” button.

If the page does not exist you will be presented with a page stating that “There is no page titled ‘My Page title’. You can create this page”. If the page does exist then it will be opened, as expected. Assuming the former scenario, press the linked text “create this page” to create a new page with your given title. You should now be ready to add content.

The way the wiki works may appear a little backwards at first, but the general idea is to first use a reference to something before actually creating the actual referred to object. In this case you are referring to a page that does not yet exist so the wiki complies by asking you if you want to create it. We will see the same behavoir later when creating internal page links, categories and the like. You simply assume they exist and refer to them as if they do.

Formatting options

So you have created a page. Pretty simple, but what about content? Well, again it’s really just as simple. You just have to start typing into the large editor field in the middle of the screen. However, to make you pages look pretty, you might want to pick up a trick or two along the way.

Text formatting

There is not much to say really. You create italic text by surrounding it with 2 apaostrophe characters on either side of the text, like:

”this text is bold”

You create bold text by surrounding it with 3 apostrophe characters on each side of the text:

”’this text is bold”’

A combination of both bold and italic can be created by increasing the number of surrounding apostrophe characters to 5:

””’this text is both bold and italic””’

Headings

You create a title heading by surrounding it with an equal number of equals characters (=) on either side of the heading, so for instance

= My title =
== My title ==
=== My title ===
==== My title ====

and so on. This corresponds loosely to the h1, h2, h3 etc. tags familiar from html. You can add up to 6 equals characters on either side before the actual equals characters start to show up as part of the heading label. You must make sure that the number of equals characters is the same on both sides of the heading label or else they will show up as part of the label itself. The thumbnail image on the right illustrates how the headings will appear on the page. Also notice the content box at the top of the page. It appears automatically once you have added more than 3 headings on a page. Notice also the last heading containing more than 6 equal characters as they now appear in the heading label. This is probably not what you want. In most cases you will find yourself only needing two or three heading sizes per page. If you find yourself running out then maybe you should be considering splitting the contents into several wiki pages and linking them together using internal links.

Creating links (external and internal)

You create a link to an internal wiki page by referring to the page title in double square brackets, like

[[link to my page]]

where ‘link to my page’ is the actual title of an existing or non-existing page in the wiki. If the page does not exist then the user will be asked if he would like to create a page with the given title. This is in fact the same procedure used when we created our first page earlier. In this way the wiki grows by letting a page refer to non-existent pages for others to fill in the blanks. It is really quite clever and the exact opposite of how a normal web site usually works. You can change the link label by adding a pipe character between the page title and desired label, so for instance

[[link to my page | preferred label]]

will add an internal link to a page named ‘link to my page’, but will display the link text ‘preferred label’ instead of the given page title.

External links are a little bit different. You type a URL in the same double square brackets like so

[[http://www.wordpress.com]]

Here the actual URL will be displayed as the wiki page link label. However, in most cases you will want to give it a more user friendly label. You do so by simple adding the desired label after the URL like

[[http://www.wordpress.com WordPress]]

Now the link will show up labeled ‘WordPress’. There is no pipe character as before, just a space. Since URL’s can’t contain the space character this works out fine.

Creating categories

Categories help structure the content in the wiki. You can assign a page to an unlimited number of different categories and like before, they do not need to exist beforehand. A page’s categories appears at the bottom of the page (see figure)

Creating a category is very simple. When in edit mode on a page you want to categorize you simple type the category name in square brackets, prepending the category name with the label ‘Category:’, so

[[Category:Your category name here]]

So [[Category:PHP]] would assign the given wiki page to the PHP category. To add the page to more categories simply add more [[Category:whatever]] declarations.

Summary

I’ll leave it at that for now. That should get you started creating pages with simple content, linking them together and categorizing them in a logical structure.