Web Development Company New Zealand, Web Design Company, Software Company

	ASP Programming Fundamentals

What Is ASP Programming?
Simply put, programming is the process of creating a set of instructions for the computer to follow. These instructions are written in a language or languages which people can understand, and then "compiled" (literally, translated) into machine language, or interpreted by the computer from reading a script. HTML is a programming language, as are JavaScript and VBScript. The "syntax" of a programming language consists of the various language elements, conventions, and operators that are used to write the instructions.

Procedural and Object-Oriented Programming
The first item of business is to identify the 2 basic kinds of programming that exist, and how each one fits into the overall picture:

Procedural Programming was the first kind of programming to develop, and involves a relatively simple way of doing things. In procedural programming, the computer is given a set of instructions which it executes, and then waits for input, which it reacts to by executing another set of instructions, and so on.

There are 3 basic elements of procedural programming:

Sequence - The order in which instructions are executed is the sequence of the programming. This is far more important than it might seem, but having things in the proper sequence is essential.
Selection - If/else conditional statements and other forms of selection form the second element. This is how a program makes and reacts to choices.
Iteration - The use of "loops" and other forms of repetitive sets of instructions forms the last building block of procedural programming.

Object Oriented Programming came along later, with the advent of multi-tasking operating systems such as Windows. In point of fact, procedural programming is at the heart of all programming, including object-oriented, but because certain kinds of objects have many characteristics in common (such as windows, for example), it is more convenient to treat them as objects, rather than as sets of instructions. An object has properties, methods, and event handlers.

* Properties - Properties of an object are the characteristics which define how the object behaves. In a web page, for example, the page itself has certain properties, which are defined in the <body> tag, such as the background color, style source page, etc.

* Methods - Methods are actually blocks of instructions that can be executed by an object itself, and each object has its' own set of methods. A simple example of this would be the submit() method of a form. When You click on the Submit button of a form, or invoke the submit() method for a form with a JavaScript command, the form is submitted using the form's submit() method.

* Event Handlers - An "event" is when something happens, either something that the user has done, or something the program itself has done, or another program has done. The simplest example I can think of for an event is using the form example above. When you click the "Submit" button, you have generated an event, and the event handler is the set of instructions which is programmed to execute when that event occurs. Because of the nature of multi-tasking systems like Windows, one is never sure where the next event is going to come from, so event handlers are designed to react to events in the appropriate manner. Each object has its' own event handlers, built into the object itself.

Error-handling and Debugging
Believe it or not, the biggest investment of a programmer's time is involved in error-handling and debugging. Why? Because half of the participants in an application, that is, the user, is human, and prone to error, unlike our trusty electronic companions. A relatively simple application may contain scads of code to prevent humans from doing something stupid, or to react appropriately when they do, which they do. Humans do the darndest things. Don't ever put anything past them

Building a Program
Building a web application is a lot like building a house. You begin with a problem. A client has a need. You identify the main problem, and then begin to identify the component parts of the problem. That is, you break it down into component parts. As Uncle Chutney sez, "Big things are made up of lots of little things." Each of these parts is an individual problem to be solved. The solution to each problem may contain a number of composite elements. In fact, a finished program is a complex combination of very simple building blocks that all interact with each other.

Once you've come up with your overall plan, you begin to put the simple building blocks together, one at a time, and test each piece as you go. Why? Because it's easier to find a bug in a single page or block of code than it is to find it in a vast expanse of code. Once you begin combining the elements of your application there will be enough digging for needles in haystacks.

You must plan the development of your application logically. Just as you can't build the walls of a house until you have laid the foundation, identify which elements of your application are essential to the workings of others, and plan the development along these lines.

As you progress, the application will develop from something very simple to something very complex, made up of many simple parts. Don't ever let the complexity of the overall plan overwhelm you. Take each simple problem, one at a time, and let the overall plan take shape automatically, as you simply concentrate on the single element you're designing.

Conclusion
If you can keep these fundamentals in mind, you can write a program! Just as the program itself is made up of simple building blocks (how complex is a single brick, or 2X4?), the fundamentals of programming are simple building blocks as well. Keep them all in mind as you work. When the forest gets too complex, take a look at the trees for awhile. Take it one tree at a time, then one grove of trees, and work your way up to the forest. Logic is the key, organizing your thoughts, and your plans.