The general idea is based on the concept of a centralized server that stores and displays messages from various users. If you’ve ever wondered how they work or how you could build your very own web forum from scratch this tutorial attempts to explain some of the fundamental underlying concepts. You will need a MySQL database to be able to store the messages – or whatever DBMS you prefer – along with a Server-Side-Scripting language such as PHP in order to process and handle requests from the various users of the forum.

Forums are actually rather simple in design. They work on a somewhat hierarchical system. The messages on forums are normally threaded, meaning they fit into neat little categories and span inwards. The messages are called posts. Every time a user submits a post to the forum it must be associated with some specific thread. The thread is a type of category that belongs to the forum. Most web forums will have multiple forums on the same web site, usually closely related in subject.

So in order to build our forum we will first need to design a database. For the purpose of demonstration in this tutorial we will use MySQL. We’ll call our MySQL database _forum and use the MyISAM engine, as this provides a very fast means of sending and retrieving multiple queries at once. The MyISAM storage engine is not a transactional storage engine. It provides table-level locking, which means it can slow down significantly if too many people are attempting to write to the database at once. However, for the purpose of an online web forum this should more than suffice. Given that the majority of forum users are reading rather than contributing to the forum and that the expected impact should not exceed a few hundred concurrent connections for even a large forum (this could potentially support hundreds of thousands of users).

The database will require four basic tables to become a fully functioning forum database:

1. The Forums Table – Stores information about all the forums available to the web site
2. The Threads Table – Stores all the information about threads associated to the forums available in the forums table
3. The Posts Table – Stores all the messages posted to each of the threads in our forums
4. The Users Table – Stores the information about the registered users of the forum

The bulkiest of these tables will probably be the Posts Table, since it is likely to handle – potentially – millions of records over a very long period of time. Here is a simple MySQL structure of the aforementioned tables to give you an idea.

/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8 */;
--
-- Database: `_forum`
--
-- --------------------------------------------------------

--
-- Table structure for table `forums`
--

CREATE TABLE IF NOT EXISTS `forums` (
  `id` int(12) NOT NULL AUTO_INCREMENT,
  `user` int(12) NOT NULL,
  `title` varchar(256) NOT NULL,
  `desc` varchar(256) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `user` (`user`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 ;

-- --------------------------------------------------------

--
-- Table structure for table `threads`
--

CREATE TABLE IF NOT EXISTS `threads` (
  `id` int(12) NOT NULL AUTO_INCREMENT,
  `user` int(12) NOT NULL,
  `forum` int(12) NOT NULL,
  `title` varchar(256) NOT NULL,
  `desc` varchar(256) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `user` (`user`),
  KEY `forum` (`forum`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 ;

-- --------------------------------------------------------

--
-- Table structure for table `posts`
--

CREATE TABLE IF NOT EXISTS `posts` (
  `id` int(12) NOT NULL AUTO_INCREMENT,
  `user` int(12) NOT NULL,
  `thread` int(12) NOT NULL,
  `subject` varchar(256) DEFAULT NULL,
  `text` text NOT NULL,
  PRIMARY KEY (`id`),
  KEY `user` (`user`),
  KEY `thread` (`thread`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 ;

-- --------------------------------------------------------

--
-- Table structure for table `users`
--

CREATE TABLE IF NOT EXISTS `users` (
  `id` int(12) NOT NULL AUTO_INCREMENT,
  `name` varchar(12) NOT NULL,
  `pass` varchar(256) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 ;

As you can see every forum, thread, and post are each assigned a unique ID number in their respective tables. That number is sequential so it is set to auto-increment. Every time a new forum, thread, or post is added it is assigned the very next number in the sequence. These IDs are also indexed to allow us easier look ups in the database queries.

Now lets write some simple script to test out the functionality of our database. For the purpose of this tutorial we will use PHP. The script below demonstrates the most basic way to read from the database and output the data in the same traditional fashion that most web forums work. We start by listing all the forums on the front page. Each forum provides a link that leads to viewing all the threads within said forum. Now since each thread will also provide a link to view all the posts associated with this thread we are beginning to see how more and more data ties together in a web forum and this can make it a little more complicated down the road if the integrity of our data structure does not remain intact.

<?php
/*
# Lets just assume this entire script is stored in a file named forum.php
# Whenever forum.php is called without GET arguments it will list all of the forums available in the database. Because it outputs the HTML with the proper GET arguments included in the links for each forum/thread all the user has to do is simply click on a link and the data is generated for them automagically. That's pretty much how a forum works.
#
# Of course if you want to try this script you will need to set these variables to your database name, user, and password.
*/
$db = 'urdbname';
$dbuser = 'urdbuser';
$dbpass = 'urdbpass';
$dbhost = 'localhost';
$link = mysql_connect($dbhost, $dbuser, $dbpass);
mysql_select_db($db, $link);

// List Forums
function GetForums() {
  global $link;
  $result = mysql_query("SELECT COUNT(*) FROM forums", $link);
  $forums = mysql_fetch_row($result);
  $result = mysql_query("SELECT COUNT(*) FROM users", $link);
  $users = mysql_fetch_row($result);
  $put = "There are " . $forums[0] . " forum(s) and " . $users[0] . " user(s) in the database.";

  for ($i = 0; $i < $forums[0]; $i ++) {
    $data = mysql_fetch_row(mysql_query("SELECT * FROM forums LIMIT ".$i.",1", $link));
    $put .= "<p><a href='?f=".$data[0]."'>" . $data[2] . "</a> - <i>" . $data[3] . "</i></p>";
  }
  return $put;
}

// List Threads
function GetThreads($var) {
  global $link;
  $forumnum = $var;
  $result = mysql_query("SELECT COUNT(*) FROM threads WHERE forum = '".$forumnum."'", $link);
  $threads = mysql_fetch_row($result);
  $result_test = mysql_num_rows(mysql_query("SELECT * FROM forums WHERE id = '".$forumnum."'", $link));
  if (!$result_test) { echo "This forum does not exist in the database..."; exit; }
  $forum = mysql_fetch_assoc(mysql_query("SELECT * FROM forums WHERE id = '".$forumnum."'", $link));
  $put = "There are ".$threads[0]." threads in the '".$forum['title']."' forum.";
  for ($i = 0; $i < $threads[0]; $i ++) {
    $data = mysql_fetch_row(mysql_query("SELECT * FROM threads WHERE forum = '".$forum['id']."' LIMIT ".$i.",1", $link));
    $put .= "<p><a href='?t=".$data[0]."'>" . $data[3] . "</a> - <i>" . $data[4] . "</i></p>";
  }
  return $put;
}

// List Posts
function GetPosts($var) {
  global $link;
  $threadnum = $var;
  $result = mysql_query("SELECT COUNT(*) FROM posts WHERE thread = '".$threadnum."'", $link);
  $posts = mysql_fetch_row($result);
  $result_test = mysql_num_rows(mysql_query("SELECT * FROM threads WHERE id = '".$threadnum."'", $link));
  if (!$result_test) { echo "This thread does not exist in the database..."; exit; }
  $thread = mysql_fetch_assoc(mysql_query("SELECT * FROM threads WHERE id = '".$threadnum."'", $link));
  $put = "There are ".$posts[0]." posts in the '".$thread['title']."' thread.";
  for ($i = 0; $i < $posts[0]; $i ++) {
    $data = mysql_fetch_row(mysql_query("SELECT * FROM posts WHERE thread = '".$thread['id']."' LIMIT ".$i.",1", $link));
    $put .= "<p>" . $data[4] . "</p>";
  }
  return $put;
}

if ($_GET['f']) $ui = GetThreads($_GET['f']); elseif ($_GET['t']) $ui = GetPosts($_GET['t']); else $ui = GetForums();
echo $ui;
mysql_close($link);
?>

This code will merely show you how to read and display data from the database. Now all we need is a way for users to add their posts to the threads. We can accomplish this by using an HTML form. The elements of the HTML form we will need are very basic. A textarea is used to capture the users message and a submit button is used to send the request to the script. Here is some very basic HTML code to write a form to your script.

<form id="form1" name="form1" method="post" action="">
  <label>
  <textarea name="text"></textarea>
  </label>
  <label>
  <input type="submit" name="Submit" value="Submit" />
  </label>
</form>

Next the script needs to handle the request through $_POST and add the post to the database. The example below is a simplistic approach to using post data from the form.

$msg = $_POST['textarea'];
$msg = htmlspecialchars($msg); // Minimalistic method for preventing html/script injection
$result = mysql_query("INSERT INTO posts (thread, text) VALUES ('".$var."', '".$msg."')", $link);

Of course you will need to make sure your code has some basic error handling methods as well as best security practices to prevent nuances like mysql injections or html/script injections as these examples are meant for demonstration and educational purposes only. So in a nut shell that is how web forums work and, as outlined in this tutorial, you now have the fundamental building blocks of a web forum. You would need to include some method of maintaining user sessions, for example by storing login information such as usernames and passwords in the users table of the database. This will allow you to keep track of who has posted what messages and the threads they start. Also it might be a good idea to add a time column to the forums, threads, and posts tables in order to keep a record of when each record was added to the database. Other suggestions may include adding a paging system that will divide forums/threads/posts in to pages so as not to have the user load hundreds of posts or threads in one page. This will also reduce the overhead on your mysql server. Such methods are not described here in detail. Rather they are left for a more conclusive technical documentation or implementation. The purpose of this tutorial was to merely introduce the basic concepts of web forums using MySQL and PHP.

This tutorial attempts to explain some of the inner-workings of DNS specifically in regards to web hosting. If you are thinking of getting in to web hosting, or have been hosting web sites for a while, you will likely benefit from this DNS tutorial. There are entire books written about DNS so I will not attempt to fully explain, in exhaustive detail, the complex system that makes up DNS. It is not the purpose of this tutorial to serve as a complete reference for DNS, but rather it is meant to act as a guide in helping you understand what parts of DNS to focus on for web hosting and maintaining a fully functioning web site.
Before we can begin let us first familiarize ourselves with some common terminology associated with DNS. First off, DNS is an acronym, which is commonly known as Domain Name System or Domain Name Service. DNS relies on some protocols that have been refined over time – and some that have refined DNS – as the Internet has grown and expanded to what it is today. Such protocols as HTTP, FTP, TCP, IP, and UDP should be basic general knowledge for those of us with a solid understanding of the Domain Name System. These protocols fall under the Internet Protocol Suite or what’s more commonly known as TCP/IP. What we need to know about this suite, for the purpose of this tutorial, focuses mostly on those aforementioned protocols.

Starting With The Domain Name

If you want to host a web site you will need a domain name. You can register a domain name with any of the registrars available online, through your ISP, or through a web hosting company. The process begins by selecting a Top Level Domain or TLD. This is a domain like com, net, or org, for example. The TLD is at the root of the domain hierarchy. To a human we read a domain from left to right. For example, www.domain.com is read starting with the www and ending with com. To a computer or DNS server, the domain name is read from right to left starting with the TLD and ending with the lowest point in the domain name space relative to the tree of the domain hierarchy. So www.domain.com translates to com.domain.www in a DNS because the DNS needs to start at the top of the domain name space and work its way down in order to resolve. You may ask, why use this nonsensical routine that contradicts the way you read and understand domain names? To us it seems contradicting based on how we may have become accustomed to reading a domain name, but to computers it makes sense based on how the DNS is designed. What you need to remember is that DNS is a hierarchical system and finds authoritative name servers by searching at the top of the hierarchy and working its way down until it finds the parent name servers. DNS is also delegated into zones and subzones to make it more efficient.
A Fully Qualified Domain Name or FQDN is distinguished by its uniqueness in the domain name space and is some times referred to as an absolute domain name. For example, if we have a server on a network with the host-name server1 then server1 will be relative to its root domain. If that root domain, including the TLD, happens to be domain.com then server1.domain.com is an FQDN as there can only be one server1.domain.com even though there may be many server1’s in other parts of the domain name space (e.g. server1.mydomain.com, server1.yourdomain.com, server1.ourdomain.com, etc). The host is thus unique in the domain name space and this is an important part of how the DNS was designed to remain hierarchical in a host-to-client fashion. The machine can now be uniquely identified on the Internet by server1.domain.com regardless of one’s physical location.

Name Servers

ISPs setup DNS servers and DNS resolvers that communicate with each other to locate information about domain names. The Name Servers tell us where to look for information about a particular domain name. Registrars retain the name server information that points to a particular domain name. This is called an NS record. It shows up on dig (a linux networking tool) as domain.com. 86400 IN NS ns1.domain.com, for example. You can set multiple name servers, but the general practice is that you have at least two name servers for each domain. This way if one fails then hopefully the secondary name server will still resolve. You can use the same name servers for multiple domains. Name servers can be both public and private. When the name servers point to the domain itself then the IP or Internet Protocol address must also be set in the A records of that domain name.
If you are using a shared hosting account you will most likely use your web hosts name servers set on that server. Some web hosts will allow you to use private name servers. In this matter you will set ns1.yourdomain.com and ns2.yourdomain.com as the name servers for you domain with your domain registrar and specify the IPs that your web host provides you for those name servers.
If you are running a dedicated server you will need to have your own DNS software installed. The standard is usually BIND. BIND stands for Berkley Internet Name Daemon and is sometimes referred to as named. Low-end VPS machines or some home networks may use smaller foot-print DNS server software such as Dnsmasq. While BIND has had some security vulnerabilities BIND9 is still certainly popular in use. Your focus should be on DNS cacheing and recursive DNS queries rather than authoritative DNS, unless you really know what you’re doing.

A Records, CNAMEs, PTR, and MX Records

People will commonly use www.domain.com in their browsers rather than domain.com when visiting a website. If you are hosting your web sites thinking these two are one and the same you are mistaken. They are in fact viewed as two different web sites. Common search engine bots like Google’s Google Bot will crawl these URLs as two different web sites. To avoid any confusion there is a good way to work around this both on the DNS side and through your web server software (for example, configuring your .htacess file to treat this with a 301 perm redirect).
First, you should consider that CNAME records (Canonical Name) will create a second lookup when retrieving the records. They can be avoided by simply using the alias as an A record. The A record can then look something like this:

If we add www.example.com. to A 192.0.32.10 then the alias will still point to the same IP without creating an CNAME lookup. This is because the server will first find www.example.com IN CNAME example.com and then proceed to lookup example.com to find it IN A 192.0.32.10

If you’re not familiar with the numbers showing up in the dig these are called TTL or Time To Live. They represent how often the records should be updated. The settings can vary based on record type. Again because DNS is a hierarchical distributed system the authoritative name servers will pass the records on to the caching name servers until the TTL has expired. This can cause different load issues depending on how low or high the TTL is set. It is generally not a good idea to lower your TTL too much unless you are constantly updating your DNS records, which is likely never the case.
Your MX records (Mail Exchange) are prioritized. So MX 0 should always be the first point of mail delivery. The lower the number set in the MX record the higher priority it gets.
Its also important to consider rDNS or Reverse DNS for your domain especially if you plan on sending mail from that domain. Some mail servers will attempt to verify fcrDNS, or Forward Confirmed Reverse DNS, from ips they receive mail from in order to prevent domain name spoofing (this is where a malicious server attempts to use some one else’s domain in their email header). Reverse DNS is basically the opposite of what we discussed earlier. Instead of the resolver using the domain name to find an IP address it is using an IP address to find a domain name. This can be done through a PTR record or Pointer Record. The IPv4 uses the in-addr.arpa domain and IPv6 uses the ip6.arpa domain. The pointer record helps us resolve the reverse DNS lookup in these domains. Forward Confirmed Reverse DNS is a full loop. The mail server will usually take the IP that the mail was received from and will attempt to resolve it to a domain using the reverse DNS lookup. That domain is then resolved back to an IP address and if the IPs match then the the fcrDNS test is a pass (i.e. we can be pretty sure that this IP is the one that correctly delivered the mail). Failing the fcrDNS test does not necessarily prevent your mail from being delivered, but most large email servers – especially ones that handle millions of emails per day like Yahoo, MSN, or Gmail – will delay or possibly reject the mail delivery. It might also get filtered out as spam so make sure you have correctly configured your rDNS. This process will require a dedicated IP address to become a fully qualified loop.

There are many other areas to be looked at in setting up and configuring DNS so I will try to update this tutorial where possible. Feel free to let me know if you have any questions or suggestions for this tutorial or to correct/append anything I may have overlooked.

Free Web Hosting

Free can mean not-so-free, sometimes. This type of web hosting is offered, usually, as an introductory hosting service to sell other paid web hosting services. It can be ad-free or otherwise. There are many limitations and constraints that are normally associated with this type of hosting. For example, you may not be able to host certain types of content with a non-paid hosting account. The host may restrict disk space and monthly data-transfer allotments stringently. The host may or may not allow you to use your own domain name. There can also be restrictions on certain files. For example, the host may prohibit you from using a custom 404 – Page Not Found error page or other types of error documents. This type of hosting is generally discouraged for business use as it does not set a good impression. Using a free hosting service is much like using a free email account for your business. It may lead your customers to view your business as unprofessional or result in other criticism. You should invest in a quality web hosting service as you would invest in your business.

Shared Web Hosting

This type of hosting is fairly common and you’ve probably come across this terminology by now. Shared web hosting is essentially when a user pays to use a small portion of a server for hosting their websites. However, the user can be limited to a specific number of constraints such as disk space, monthly data transfer, number of domains, database access, or even server-side-scripting access. The user is sharing that server with many other users who are also paying a small fee to host their own web sites. The users do not generally interact with one another or even know that they exist on the same server apartment from knowing that it is a shared web hosting server.
With shared web hosting you don’t have to worry about any of the techy stuff behind closed doors. You are usually going to find web hosts that provide some control panel interface for their users to utilize their server resources. This makes managing things on a linux server, for example, much easier for users who do not know linux. You can find popular control panels such as webmin, cPanel, Plesk, H-Sphere and many more online and try a demo for free. Since the majority of all computer users use Windows, and are generally accustomed to this type of GUI, it puts those users with a better understanding of *nix based operating systems at an advantage; since a great number of web hosting companies will run their servers on linux.

Dedicated Hosting

With a dedicated hosting solution you are given a server that is dedicated solely to you. Here you will need to whip out all those tech skills in order to use the server. This is a much more costly solution vs. shared hosting. On shared hosting you are paying a fraction of what it costs the web hosting company to run and manage that server, but with dedicated hosting you are taking on the full cost of the server by yourself. This has its benefits as well as its drawbacks.
In a dedicated hosting environment you are offered a more heightened security level. You have control and freedom over your security protocols, software configurations, and root privileges. This puts you front and center in the cockpit of hosting. With dedicated hosting solutions you have the ability to build your own network, create virtual private networks, enable virtual private servers on your machines, and even create your own firewalls.
There are many reasons why people will choose dedicated hosting over shared hosting and it primarily leads back to freedom. On a shared hosting environment the host must maintain the server adequately for all of its users. This means the host will likely put in place certain policies to prohibit the abusive users from consuming too many server resources, posing security risks that may otherwise harm other users or compromise the server, or overloading the server. These policies are usually defined in a document called the AUP or Acceptable Usage Policy and somtimes is contained or outlined in the TOS or Terms of Service Agreement that the host enforces.

Many other solutions have been introduced to the web hosting industry over the years. Terms like VPS Hosting, Cloud Hosting, Reseller Hosting, SEO Hosting, Semi-dedicated Hosting and Unlimited Hosting are becoming increasingly popular.

A VPS or Virtual Private Server is a software-based server. It acts and feels like a real dedicated machine, much like having your own dedicated server, but it runs on a single machine where several other virtual private servers may be running. So in essence it is much like the shared hosting concept, but with more flexibility and control. This is a much cheaper alternative to having your own dedicated server.

The Cloud is simply stemming from the idea that we now live in a world where everyone wants to share with everyone else. Sharing doesn’t necessarily mean giving up privileges, as some may suspect. Cloud hosting means you are on a network of virtual private servers, where everything is automated to utilize the network as a whole. You can provision a VPS within minutes using automated virtualization software and get your server online through the cloud immediately. Additionally, the cloud offers some substantial benefits in the areas of scalability. For example, most clouds are designed with the ideology that you pay for what you use. Companies like RackSpace and Amazon offer cloud computing that you pay for by the hour. You can quickly setup a few dozen servers to test your applications and take them down when you’re done. Most hardware specs are customizable and easily upgraded or downgraded. The cloud also allows us to share file storage systems and applications. This makes for more efficient web 2.0 utilization since most of us use the same apps online anyway. What’s more is that you can easily rely on the cloud to migrate your servers near-instantaneously. If a server goes down or crashes, the instance can easily be migrated to a different machine or even a different data center within minutes, as opposed to hours with a dedicated server.

I hope this quick glance at the web hosting industry has caught your attention. Stay tuned for more on tech and web hosting talk!

<?php
echo "Hello World!<br />";
$ideal = array("journal", "publish", "typewriter");
$conceptual = array("blog", "post", "laptop");
$txt = "I have decided to restart my journal and publish a few things online. Sorry that my site went offline for a while. I lost my typewriter and my domain expired, but luckily no one grabbed it while I was offline and I was able to re-register it and get my journal back online! I've decided to go with WordPress since it seems to be all the rage these days.";
$intro = str_ireplace($ideal, $conceptual, $txt);
echo $intro;
// Output:
/*
Hello World!
I have decided to restart my blog and post a few things online. Sorry that my site went offline for a while. I lost my laptop and my domain expired, but luckily no one grabbed it while I was offline and I was able to re-register it and get my blog back online! I've decided to go with WordPress since it seems to be all the rage these days.
*/
?>

I thought I’d start things off by posting this Hello World php script. Just click here if you’d like to actually try it yourself. Thanks!