Failblog.org – Just hilarious, never-ending moments of human idiocy.

Netflix.com – I love websites which return your time spent. Not only is it full of great design and cool AJAX features, it keeps track of all your movies and movie ratings.

DeviantArt.com – This website has some of the best art I have ever seen. The amount of content rivals every other site, and you can spend hours relishing in (and envying) the talents of individuals all over the world.

Gametrailers.com – A lot of gaming websites are realy bogged down with ads and excessive clicking. Gametrailers.com tries to keep it a bit tight, and provides HD video for every video game.

imdb.com – Internet Movie Database, usually my central source for movie information. What’s that actor’s name?, When is Ridley Scott making another movie? and similar questions are examples of reason to visit imdb.

Wikipedia.org – I know some people scrutinize the credibility of this web encyclopedia, but I find these instances rare, and it’s really easy to use when trying to gather sources and learn quick info on basically any subject.

Youtube.com – What do you expect? Addicting content and good design always ensure at least part of my time.

Interfacelift.com – Beautiful wallpapers and OS X icons are constantly added to this free website. A great way to spruce up your desktop.

Least

Myspace.com - Annoying ads and loathsome loading times, make Myspace a major hassle when trying to use, much less the sloppy table style.

Gamespot.com – I used to be a big fan and user of gamespot.com, but the overuse of advertisements and more links than milipede’s legs slowly drove me away.

UrbanDictionary.com – Is it just me, or is 90% of all content sexual in nature? I personally believe there is more than a handful of people just sitting around thinking up idiotic phrases and trying to submit them to urbandictionary.com.

Microsoft.com – Fortunately most of my work is done via Apple, so I spend little time troubleshooting Microsoft issues, but when I do need to use microsoft.com, I always have a hard time. There’s just something lacking about it when you think that one of the richest company in the whole world funded it.

Rottentomatoes.com – The only thing less consistent then it’s reviews are it’s loading times.

1. Use intelligent file inclusion.
   PHP functions such as include(), require(), require_once() allow you to run external scripts or include content at your whim. These functions are generally critical to a good application design so you should always use them wisely. Don’t use $_GET or $_POST variables in the included file name (e.g. include($_GET['page'].”.php”);). If so, a hacker could pass any file name they wish to be run on your server.
2. Turn off PHP register globals.
   If Register Globals is turned on, all variables must be wisely utlized and checked while writing your script. Similar to the first security tip, a user or hacker could pass a variable via $_GET and it be recognized and localized as a global variable and could maliciously harm your application and abuse your host.
3. Always validate user input.
   When using HTML forms for processing user based data, ALWAYS validate this information with stringent PHP inspections. Some developers may foolishly rely upon Javascript to validate their data only, but Javascript is a client-side feature and can be turned off or manipulated.
4. Watch for SQL injection.
   Most of the time, an application takes information from a user and then stores this information in a database. This means that the code uses SQL to store this data in the relational database, and in turn uses the data the user has submitted in the form directly in the SQL command. Some hackers will include an SQL command in the form which tries to end the normal SQL command and append a destructive command afterwards. Good PHP validation will take care of this, and always use a function like addslashes() to keep them from breaking out of the proper SQL command.
5. Regenerate Session ID’s.
   Everytime a user logs into the application, use the PHP session_regenerate_id() function to update the user’s session. This prevents Session hijacking where a Hacker attempts to copy the Session ID from another user and access their application.
6. Error Handling.
   Never let your user see a PHP compiler error… ever. This can be achieved by changing the php.ini setting for display_error to “0″. Then use the error log for viewing errors related to code. Don’t rely on this though, use proper error handling techniques to avoid compiler and SQL errors.

I implore you to recognize that this information is a basic tutorial for PHP security, and represents the most pertinent issues to be addressed when designing a professional PHP application. As a developer it is your responsibility to design programs with integrity, and ensure the security of the program to it’s fullest.

admin/
content/
developer/
images/
includes/
js/

admin/
In most application design scenarios, an administrative interface which controls many features of the application is required. These files and scripts are placed within a password protected “admin/” directory. The file structure within mocks the file structure outside because inside of “admin/” and entire application is housed.

content/
Most applications and websites have the same overall interface throughout the entire process. The “content/” directory houses the HTML and PHP of the application which changes from operation to operations. These files within are nested in the index.php file in the root directory.

developer/
This directory holds an almost exact copy of the live website, and allows the developer to have a password protected area to design and upgrade existing features, and gain approval for changes before they are live.

images/
All of the images used for the design of the website interface are housed within images. A series of sub-directories may be found inside if they are needed. If my application allows uploading of images foer user purposes, then I usually create a sub-directory within “images/” for such purposes.

includes/
The “includes/” directory houses much of my application meat. Several files are very important in this directory, all of which are standard page to page operations which are included in the index.php running process. Files such as:
application_top - houses all session and initialization of each page load and loads other "includes/" files
application_bottom - same as application_top, but ends all processes
configure - houses all site defined parameters such as database credentials and directory names
db_connect - file which create the database connection
classes/ - directory which houses the Model and Controller of the website
functions/ - holds all files which house the various function listings required for the application

js/
This directory houses the javascript files which are kept relative for each page. This usually holds the libraries for the javascript objects which run various parts of the applications. Example could be the scriptaculous library, or mm_menu.

Of course, other directories and files exist within and among this file structure, and thats where you as a developer determine what is best for the project, but feel free to use this as a guide for designing a modular web site or program. It feeds generally well into most projects and can really alleviate the frustrating changes to your design in the future.

When the street view of Google Maps was introduced a while back, I was completely enthralled. I made it a point to visit every point of interest in America that I could think of, checked out my folks house, and even tried to locate my girlfriends car. Since that time I always check out the street view for places I am travelling to get a real view of where that point is in my destination.

Anyways, Google seems to have focused on forraying the Street View even more, and in doing so has provided a new interface to the Google Maps system. Now, street view is a central component in their mapping information, making it easier for us all to fall in love with them again.

Check it out.

Last time we discussed how the Session retains the actual Controller object and allows all it’s live data to travel from page to page without reloading. With you controller built, you will need to either have your programming load a new Controller, or recognize whether the current Session has an active Controller. This can be achieved through a script such as:

if(isset($_SESSION['SERIALIZED_CONTROLLER'])){
$_SESSION['CONTROLLER'] = unserialize($_SESSION['SERIALIZED_CONTROLLER']);
}
if(!is_object($_SESSION['CONTROLLER'])){
$_SESSION['CONTROLLER'] = new controller;
}

and script at the bottom of each page:

$_SESSION['SERIALIZED_CONTROLLER'] = serialize($_SESSION['CONTROLLER']);


By serializing our Controller after each page load, it allows the state of the Controller to be transferred from page to page without affecting it’s integrity. Upon each page load the Controller is either unserialized or completely re-instantiated determined by the current Controller state.

If some Controller data is pertinent to the operation of the program, it may be reasonable to create a Controller method which checks to see if this data is available and either re-instantiate or continue with it’s current state.

This type of framework and design lends itself well to applications which require front end loading and operation of data which are specifically chosen by the user. For example, an application which loads a directory of information from which the user chooses an entry and makes that entry their primary focus of operation during their time within the program.

This concludes the MVC made very casual part 3.

For those who may not know, spammers use spider bots similar to google and yahoo, which scour the internet collecting email addresses. Whence collected, these email addresses are added to a massive database alongside thousands or millions of others. This database can be either: rotated through and emailed with scam mail, or sold to other spammers who do the former anyways.

As a web designer, you must take careful precautions to avoid these pitfalls, and deny the spider bots access to email addresses displayed on file. There are many ways of doing so, and I woudl like to point everyone to an article which outlines some seriously useful techniques which do not undermine the email address in the end.

Article: Hide your email address on websites from spam

Our abilities may ensure our place as strong components to a powerful team, but they will never ensure our employment. Being experienced with corporate undermining, we can’t allow those frustrations to destroy our ambitions. Our creativity is our internal value, and simply because that prowess is unrecognized, we cannot allow it to destroy our very values.

I encourage you to press on, and despite the change in atmosphere, look for challenges that broaden your knowledge. See every opportunity as one of significance, every technology as one of wisdom, and every motivation as one of purpose. We can’t afford to depress ourselves to the limitations and nonrecognition of others, but must strive forward, looking to those few leaders who can recognize our true ability.

I hope you gain courage to never let go of the deep ambition, because the journey before you allows you to express the culmination of all you have learned.

The idea behind CSS <div> tagged websites for managing content and becoming the framework of the website really took hold when a lot of Search engines viewed it as easier content to spider. When this information was released, developers abroad began writing almost all of the web based tools with this CSS structure. And it is true, CSS based websites do provide a more organic search result, but only if coded correctly.

A long time before <div> based sites were popular, the good old <table> ruled the HTML frameworks. Initially it’s strength in numbers appeared alongside of the Photoshop spliced images. It gave developers a way of organizing the website in a clean zero-pixel manner for a long time, and became the guts of many web applications today, such as osCommerce.

But to be honest, neither platform should become the norm. I have a large experience in the table design, and have designed many applications using this concept. CSS tableless designers argue that, if coded properly, the CSS websites are easier to scale and change with future updates. But from my experience, those websites are very few and far between. I have encountered many CSS <div> websites that were absolutely horrible for updating content or changing the structure slightly, far more than were good. And I have experienced Table based websites that were awesome, and would be hard pressed to be overcome by a CSS design. That being said, it’s harder to muck up the Table structures than the CSS structures, and both have very good purposes.

If you are going to design your website, here are the two key rules I would follow when choosing your layout:

If you primary concern is Search Engine Optmization, and you are comfortable with it, design your website with CSS <div> structures.

If you are designing a web application, that is probably for a private company, and deals with reporting and data go with Tables.

Video games and movies are both great forms of media entertainment. I believe that on almost any level movies and games can produce entertaining masterpieces that evoke inspiration and salivation (for more) from users and viewers who experience them. Both can create quite deep and provocative worlds and themes backed by stunning visuals and emotional substance which can truly be defined as magnificent. And in contrast both can be created for simple marketing goals and financial deadlines which corrupt the purpose and desire the film or gaming adventure wishes to tell. And interestingly enough, both mediums produce about the same ratio of exceptional/rubbish results as each other.

But one thing has become clear. Crossing that medium boundary has failed over and over again.

For a very long time video games were viewed by the overall public as extravagant board games and simple tools of fun, nothing serious like film and the arts. But the generation which held gaming controllers in place of their rattler has matured, and matured with a desire to express the beauty of the gaming industry to the world around them. Successive generations are promoting the same concepts, and film is catching on.

It has become a standard marketing strategy now for films oriented towards action and youth to produce a video game to compliment the film’s release. Of course these games are simply tools to increase the profit and interest surrounding the film, but why is it that they always have to SUCK!

Being an avid gamer I very quickly learned that nearly ALL video games based upon a film are awful wastes of time and are a slap in the face to those enthusiasts desiring their medium to be expressed as an arena of depth and great potential. The only game I have ever encountered which thankfully broke this hackneyed idea was “The Chronicles of Riddick – Escape from Butcher Bay“. Here is an example of the game, as it was when released on the orignal Xbox.

Compare to the release of Spider Man 2 on the PS2, very common expectation of film to video-game crap.

One of the reason Riddick did so well and received such rave reviews in the video game world is that the Riddick story was approached from the gamer’s point of view. The designers behind the game made a stand alone story, which fit well with the concept of gaming and allowed the player to have an accomplished sense of new discovery and involvement in what was the film’s enticing aspects. Players wanted to be Riddick, to be given opportunities to play out his strengths. Placing Riddick in a “Triple-Max” prison and challenging the player to escape through wits and strengths, whether it be surviving the prison gang hazings via shiv battles, battling guards with adaptable and well developed combat, or sneaking out of secured areas, was exactly what the player needed for the film to viably relate and succeed in the gaming world. And don’t tell me Spiderman couldn’t do the same. Producing a quality game was well within their resources.

On the flip side, similar trends are emerging when video games cross the other’s threshold, and film attempts to allure movie goers to see flicks based on popular gaming titles. Hitman, Resident Evil, Bloodrayne, Tomb Raider, Street Fighter, Doom, and the recent Max Payne films are the most popular game-gone-film examples, and every single one of them has been a laughing joke for film critics and viewers all around the globe.

Max Payne for example, was one of the more influential and creative games ever created. It’s rich features and dark story lulled the player into loving the main character, sympathizing over his his eternal loss, and striving to grant Max Payne his justice and quench him of his thirst for redemption. The story in the game unraveled piece by piece, with the character narrating his own internal struggle, visualized in the rendered world surrounding him as he plunged deeper and deeper into the dark truths of the hellish earth which had destroyed his family and his life, and was his only home till the day he died. The theme is grim, the plot dark, but the fruition so tasteful, and an opportunity like few others to dance with the emotional strings a player or viewer has within.

But of course… as soon as I saw this movie was rated PG-13, I knew they had dropped the ball again, and that film was too dense to realize the tangible masterpiece they could have produced. I can accept the Street Fighter, Mortal Kombat, Tomb Raider etc. jokes as they were since the games offered little intriguing story themselves, but come on, lets not wreck great possibilities and iconic games with tasteless film designed for monetary return. It sounds too similar to “pearls before swine.”

On a final note, when will it end? Game producers shouldn’t see the film industry as a superior art medium, but should treat it as it’s equal, not allowing film interpretations of excellent games be butchered for a DVD slot on the Best Buy shelf, and Film should take a good look into the potential of the gaming world, in that the artistry and excellence of films can be directly produced in the game, by adapting to the concept of the player as the main character, and the story as an adventure of choice.

Awesome blog about some technical tricks and tools for PHP, MySQL development. The tips are not hard to use as a developer and very very useful.

#2 - sitepoint.com

Focuses on a more corporate aspect of internet software and affected computer services. Provides solid updates on big software developers and their affects on the web day by day.

#3 - tdcreative.net

Simple techniques to keep in mind when developing web sites. Also, there are some tutorials and simplified examples of common internet software that people may have trouble with.

#4 - nelson-wong.com

Very visual blog, to keep the eye happy while the author discusses new products in the tech based arenas. Considerable amount of humor and funny media to boot. Woot!

#5 - webmonkey.com

A lot of topics covered are unexpected and hidden from the general public. From small (non-obtrusive) hacks into websites to conceptual software and interface ideas. A great source for unconventional internet tools and ideas.

1) Guides for Noobs

Where are the transitional guides!? Many developers are self taught, and after a certain period of time reach a wall. Well, the wall is more of a plateau, where self taught developers just cant quite seem to reach the professional engineering level. Much of the advanced techniques and conventions that make software truly professional could be very useful for developers of all skill levels, but apparently, all of the guides are written with elite engineering jargon. So help the noobs!

2) A Sweet Interface

I think that web-users see websites and web-apps like very shallow people. We are taught to look at inner-beauty, to see a person for who they truly are in their heart, and ignore the external features to truly experience a person. A lot of people actually do this, out of respect and care for their fellow man, but I don’t think anyone does so with the web. The heart of your program may  be the purest and most efficient being online, but let’s face it, people don’t care unless it looks good on the surface.

3) Backwards Compatibility

!@)(#*$&! Nothing bothers me more when software releases which is not compatible with previous standards. This isn’t a huge issue with web sites and web-apps since they only have to adapt to themselves, but they need to let people enjoy their comfort zone, and try very little to force them into a new structure, especially if its working well.

4) Stand-alone Resources

In anything I do which involves creation or building, I hate it when I rely upon temporary resources, or power/data sources which I do not own. In video games, for example, I always create a character with a loner style power, not conforming to the utilitarian needs of the group, but gathering permanent resources and gaining abilities that never fade. I’m sure this fits somewhere in my web design too.

5) Artificial-Intelligence

A.I. has always intrigued me greatly. The concept of masterful code design to produce software which can intelligently grow, learn, adapt, and create extensions of itself is so genius and fanciful that it gives a tangible element of surrealism to a developer’s imagination. A professor from the University of Texas at Dallas, Prof. Lawrence King, once told me that “intelligence is not artificial, it is simply biological.” I do agree with him, that I think their is a barrier to how intelligent software can become, that essence of self-awareness, but many of the other aspects I feel are not so delusional.

But…

The internet has it’s own story to tell. It appears that Canadian researchers have already begun design work for a nano based global internet system which will increase the speed of the global internet by 100 times. according to this page and this page, the technology utilizes fiber optic lasers which act as controllers for other lasers by which the data is transferred. Apparently, using light to trigger other lights as a controller system is extremely hard to do, and up until this point seemed impractical. But not anymore.

Yet the questions I ask are, “Will this technology truly change the way the internet works? Will users be capable of harnessing this speed to drastically increase productiveness of the web? Or will our internet addictions simply become more enveloping as we escalate our youtube-per-second inhalation?”

Can I help myself?

One of the largest eCommerce frameworks being utilized by web designers is osCommerce. It’s open-source free software is an automatic plus for any website design, much less the flexible structure from which it was designed upon.

Customization of osCommerce has always been it’s biggest asset. Developers having access to the code allow them to mold the store design or operations to fit their client’s needs without any real hassle. In fact, because osCommerce was designed for such purposes, a huge collection of “Contributions” have been collected and hosted at oscommerce.com for user by other developers. These contributions include shipping modules for UPS or FedEx, downloaded products, extensive sales reporting, and about a million other helpful features. Most contributions are outside developer creations, uploaded and updated from time to time, and contain generally easy-to-follow instructions for installing on your osCommerce system. But why doesn’t osCommerce employ these powerful contributions as part of the packaged store?

In comes osCMax. osCMax is nothing more than an osCommerce store that has all the greatest and most reliable of contributions built directly in. As well, the development team behind osCMax, has thoroughly tested and adjusted these additional tools to provide reliable usage for the end-user. As well, some very cool features has been added by the team outside of the contribution arena. The store now works within a template system, allowing changes to the entire site’s design a much simpler solution than previously.

As it is at the current time, osCMax has maintained pace with osCommerce’s updates and new releases, ensuring that the feature of the standard osCommerce are available in the osCMax system.

If you decide to go for osCommerce, or osCMax, both have great track records and a decent support base for any problems, and since it’s all open-source, there is nothing you can’t handle yourself as a developer.

Cha-Ching!

The collected classes are sorted into a series of categories to help find the tool you need, and each class has a description, user rating, log of the class changes, and downloads of the current version.

An account is required to actually download any of the classes, but are as free as the open-source code offered and is easy to sign up. Not only does phpclasses.org provide a huge collection of PHP classes, butoffers PHP networking groups, technical forums, and classifieds for PHP developer services.

It’s easy to get caught up in perusing the classes hosted on the site, since many of them are very unique and provide very simple solutions and toolsets to both typical and atypical PHP issues. Once you have downloaded and tried one of the classes, you are free to return to the class sub site and leave feedback and a rating on how the class worked for you needs.

Its websites like these that really empower web developers by providing a collection of tested and easy-to-implement tools for free.

Since Javascript is a live manipulation of real data within the loaded HTML content, it allows a website to change and adjust the web site’s interface for standard back-end processing. Flash on the other hand has an extremely difficult time communicating with the server side power and providing any real SEO.

These script.aculo.us libraries allow you to create some very intuitive and customizable interface enhancements, such as dynamic list sorting, fading text and image slideshows, and drag-and-drop shopping carts. Nice tools like these allow serious web developers to create a cutting edge applications and web sites that can really awe the user and sell to the client.

Take a look at the library and the multitude of examples, and enjoy the open-source script.aculo.us enhancements.

The most predominant element of our design is the Controller object. This object class contains all our methods through which the our application operates. These methods should directly relate to processes important for the application and should have well defined purposes. General functions that can be applied to a variety of situations should be housed in a separate functions file or directory so that it can be accessed by any of our PHP scripting. The controller on the other hand should have ownership of methods that work more specifically on tasks that relate to the project. For example, if you were building a simple eCommerce store, the general rule would be that our Controller object would house methods that directly perform eCommerce functions such as pulling orders from our database, or applying shipping costs. A general function to be excluded from our controller could be a money formatting function or a function that generates thumbnail images for products.

In our Model element, it is very useful to create a Database object. This object can be the agent for our normal database operations and provides easier, linear input and output from the database. This Database object should be instantiated inside of the Controller class, since majority of our database operations will be commanded through the controller object. With the Database object local to the Controller, it makes writing the controller methods easier and more durable.

Alongside the database object, your standard Model should be written. These model objects as well need to be instantiated and owned by our Controller class, so that updating and calling them are local to our Controller methods. As well, after we have loaded data from the database inside of our Model objects, calling and recalling of this data is streamlined and provides faster loading times.

A very important trick in a web-based MVC website is properly utilizing the session variables. We can instantiate any of our objects in normal variables as we typically do, but a better method for instantiating the Controller class shoud be used. Instead of using a normal variable, instantiate the Controller in a Session variable. Since the session variables are accessible despite page loading, all the data and attributes built inside of the Controller are available to us despite where the user navigates to inside of the application. This means that once the Model has been populated and loaded from the database, these objects and their respective data are accessible at anytime, and do not have to be reloaded each time the page is parsed. Yea!!! And by serializing and un-serializing the controller at the end and beginning of each page load, we can avoid overwriting our instantiation with a little care.

Once these elements have been created, the Controller and Model, and they have been properly built and instantiated, all that is left is the View element.

As you build your controller, majority of your methods and attributes will be added over time, as you develop your View/Interface element. The interface of the application determines which actions the user can perform, and therefore which actions your Controller must be able to take. This being the case, much of the Controller design is built alongside of the View and added and changed as the Interface is adjusted to fit the user’s needs. But that is the beauty of our MVC framework, since both parts are independent, and our interface never actually works directly on our data, our Controller has the freedom to expand at a whim. It as well allows us to divide the work into various departments without offending the design process of another.

This concludes part 2 of our Model View Controller – Made Very Casual topic. In part 3 I will demonstrate some very clear examples of how a PHP/MySQL web application utilizes these concepts.

But what about web applications? Since web site based software is based upon page after page reloading and procedural style run time, it becomes very easy to design the application as procedural and forget our MVC framework for dealing with objects. For starters, lets discuss the basics of MVC and how such a framework lends itself well to industry standard software.

The MVC Framework is made up of the following three components:

• Model – houses our data and objects.
• View – the interface for the user.
• Controller – the object that operates our program, changing the Model and updating the View.

The general idea when designing an MVC software piece is to sit down and write out each object that will be represented in the application. Determine the state and needed methods for these objects and then write their classes. Once you have a collection of classes that represent the objects represented in your software, this collection can be dubbed “the Model.”

After the Model is formed, the View and Controller are built side by side. As you design the interface, determining the HTML needed for your users, and as you foresee the processes and actions the user will take, you build related controller methods which perform these tasks. E.g. the Controller could own a method which draws drop down menus based upon model data, or methods that update and add data to the Model which is then output at a later time.

Using the MVC framework allows a developer to make changes to the View (interface) without having to affect the Model since our Controller is the middle man. Because of this abstraction, it allows developer teams to divide work and link them with the Controller.

This framework lends itself very well to the continual running style of standard desktop software, where objects and methods are always accessible during operation, but with internet based software, the procedural output nature has strangled this framework. Part 2 of this composition will cover the details of how the MVC framework can work well in the web based industry.

Wikipedia – Model View Controller

To create a form using HTML you only need to know what type of data you are going to transfer. 

First and foremost, all of your form elements should reside inside of two form tags such as:

<form action="myPage.php" method="post"> 
form elements... 
</form>


The first tag, <form action=”myPage.php” method=”post”>, contains an action parameter and a method parameter. These two parameters are crucial to the functionality of your form, so I will explain them in better detail. 
The “action” parameter is the location of the page you would like to submit your form to. In other words, it is the page you want the form to go to when you click your submit button. The data that the user has entered will be sent to this page as well. 
The “method” parameter determines the way that the user’s data is going to be sent. There are two methods for transferring data, one is called “post”, and the other is call “get”. 
When you “post” your form to another page, the data that was given in the form is sent invisibly to the next page. This takes it a slightly longer time to send, but a bit more secure as well. When you use the “get” method, the data is actually sent through the URL in the top of your browser. This can be seen, as example, as w ww.mydomain.com/mypage.php?name=john&phone=555_3232 (each item proceeding ? are variables). Since the data is sent through the URL, it can be changed by typing new data in the URL and viewed by someone submitting the form. This has it’s advantages in speed, but lacks an aspect of security that the “post” method retains. 

Inside of your form tags, there are various other HTML tags to make your form useful. The two most common ones are the “text” field and the “submit” button. 
The “text” field tag: <input type=”text” name=”username” value=””>. It allows a user to enter some text into the field. When the form is submitted the variable entitled “name” will contain the text they input in the text field. 
The “submit” button: <input type=”submit” name=”submit” value=”Submit Form”>. This button will send the data entered in the form to the page in your “action” parameter. 
Like I said their are many other ways for a user to input data, such as drop-down menus, radio buttons, check boxes, and so on, but I will not be covering them here. 

Here is the example outlined above:
 
<form action="myPage.php" method="post"> 
Enter your name: <input type="text" name="username" value=""> 
Press: <input type="submit" name="submit" value="Submit Form"> 
</form> 


Once the form is built, and a user enters their data and submits, what next? 
Well, the page that the form submits to has the job of taking care of the data. Using PHP we can quite effortlessly retrieve the data that was sent so we can begin working with it. 
Now, since there are two ways of sending the data through the form, “post” and “get”, we can set our PHP variables up to retrieve them. If the form was posted we can access that variable using the syntax $_POST['variable']; . If it was sent using “get” we access that variable through the syntax $_GET['variable']; . 
So, assuming we used the example above to submit a name through a form, the receiving end page must have PHP similar to this: 

<?php 
$name = $_POST['name']; // if it was post 
$name = $_GET['name']; // if it was get 
?> 

$name will then contain the text the user entered in the form, e.g. “john”. 

Being able to access the data using $_POST and $_GET is extremely useful, and allows us to perform many operations using PHP on the form data.

There are certain rules to creating a function and these rules, if not followed will result in a compiler error. So basically, they have to be followed.

Here is an example of a small function that removes all characters from a String that are not numeric:


function removeAlpha($string)
{
         $stringChars = preg_split('//', $string, -1);
         $numericStrin = "";
         for($c = 0; $c < count($stringChars); $c++)
         {
                  if( is_numeric($stringChars[$c]) )
                  {
                           $numericString .= $stringChars[$c];
                  }
         }
         return $numericString;
}
// written by Jordan Savant

Let’s take the function apart one by one and explain the purpose for the syntax presented.

Line 1: function removeAlpha($string)
This is the declaration of the function, and also called the function’s signature. When you are defining a function you must present the word “function” before writing the function’s name and parameters. Inside of the parenthesis, you can place all of the variables you wish for the function to accept. In this example we are excepting a single variable called “$string” which contains our string we want to operate on. If you were to use more than one parameter, you would separate them with commas.

Line 3: $stringChars = preg_split(’//’, $string, -1);
In this line we are calling upon a PHP ready function called preg_split(). preg_split() is a function that can split a string into tokens or parts based upon patterns in the string. For instance you could break the string into pieces every comma, period, colon, space, or any character. In this particular example we are breaking it into tokens with no identifying split marker. In other words we are splitting the string at every single character in it. This function returns an array of those characters in the string which we store in the variable $stringChars.

Line 4: $numericStrin = “”;
In this line we are simply initializing a variable called $numericString. Our function will use this variable internally as you will see shortly.

Line 5: for($c = 0; $c < count($stringChars); $c++)
Here we are creating a loop that will cycle the same amount of times as the length of the array. This means that we will have as many cycles as we will characters in our $stringChars array. This will allow us to work on each individual character in the array one by one.

Line 7: if( is_numeric($stringChars[$c]) )
Here we are creating an if statement. Inside of the condition of this if statement we are using a PHP prebuilt function called is_numeric(). This is_numeric() function checks to see if the variable it is given contains only numbers. If it is only filled with numbers it will return a true, otherwise it will return a false. Since we are asking whether or not the current character is a number we want to act upon it as so. If it returns true then we will run the if statement, otherwise we will skip the operation in the if statement.

Line 9: $numericString .= $stringChars[$c];
The instructions given on this line of code will only be executed if our previous if statement condition is true. In other words, if our character is actually a number we execute this line. More particularly, this line actually takes the current value in the array and concatenates it with the variable $numericString (concatenate means to add to the end or append). So for each character that is a number, we add it to $numericString. By the time our for loop ends the $numericString variable will contain a string of the numeric values in our original string only.

Line 12: return $numericString;
This is the final instruction in our function. When the loop has ended and our numbers in the string have been found, we will want to be able to use that numeric string. Thus the “return” command is required. In a function code outside is not allowed to access the data inside. Therefore, if we want to get the data back from the function we are required to return that data using the return command. Sometimes functions just perform tasks and do not return data. This is fine, and by simply putting “return;” as the instruction will work. On another note, we can accept as many parameters as we would want, but we can only return a single value from a function. So our function needs to be simple enough in nature that we desire only one result from it’s operation. And like we said before, our outside code cannot access the data inside of the function, for instance, the $stringChars array.

Here is an example of the usage of our removeAlpha() function:

$str = "this is a string with a 7, a 3, and a 29";
$newStr = removeAlpha($str);
echo $str;
echo $newStr;


$str contains : “this is 1 string with a 7, a 3, and a 29″.
$newStr contains : “17329″.

We can define our function either before or after the we call it in our code, but most importantly we must define it.

General Rules:

1. You must define a function using the “function” command.
2. You can pass as many parameters as needed to the function, but you can only return one.
3. Functions can call other functions, or even themselves.
4. Data created in the function is not accessible by outside code.
5. You must use a return statement when ending a function. It is an accepted convention for most languages.
6. Be creative, but not wasteful. (~:

Have fun writing functions and feel free to post any you may have created!