Usual code:

The above will not work. We have to use the following

Solution:

$j=jQuery.noConflict();
$j(document).ready(
function () {
$j(‘#expandiv’).flash({

swf: site_skin_images + ‘/jackgeorges_fathersday.swf?i=443′,
width:680,
height:495,
wmode:’transparent’
});
});

$(‘ul.tree.dhtml ul’).prev().wrap(“<span class=’grower OPEN’>”)

which is working fine in other browser but IE doesn’t do.

Solution:

IE requires end tag to wrap. So I used the following code to fix the issue but this will also create same problem in other browser.

$(‘ul.tree.dhtml ul’).prev().wrap(“<span class=’grower OPEN’> </span>”)

Finally I had to check the browser identity.

var browpattern = /Internet/;
if(browpattern.test(navigator.appName)) { // IE: Microsoft Internet Explorer
$(‘ul.tree.dhtml ul’).prev().wrap(“<span class=’grower OPEN’> </span>”);
} else {
$(‘ul.tree.dhtml ul’).prev().wrap(“<span class=’grower OPEN’>”);
}

There are several ways to get browser identity and you can use any of them.

At the very beginning we should perform when documenting common web programming problems is admit that we are relatively new to this game. Web sites and applications are rapidly evolving and grow more advance everyday.

While the web is growing at a gigantic pace there are definite standards and techniques that are coming to maturity. For example, the basic design of portal sites such as Google has settled into an established pattern.

2 Web Programming Application Levels

One of the most exciting and difficult aspects of web programming is that it requires expertise on many different levels. Web master need skills in user interface design, human machine interaction, information design, scripting, code library development, database design and database queries. These can be organized and categorized in this diagram:

• User Interface
• Human Computer Interaction
• Information Design
• Scripting
• Code Library Development
• Database Queries
• Database Design

Any structure for describing patterns in web programming will need to be capable of explaining the design considerations across any or all of these levels. Web developers face them many or all of these levels.

3 Common Problems and Techniques

3.1 Form Using

Form is used to capture the problem of getting and verifying input from a user. It is at the core of all web applications and there are many different approaches for solving this problem available to the web developer.

The basic method and constructs for prompting the user remain the same regardless of the actual content being entered. All forms must:

• Display an empty form to the user
• Verify the data entered is valid and display an error if it is incorrect
• Perform the required action using the data

Forms can be implemented using either a single or multiple page design. The single page technique utilizes a self-referring script to display and process the form. Multi-page forms take the user through a series of pages to enter, confirm and submit the data.

Developer should use both client-side and server-side validation in their form using. The other important area to consider when thinking about form design is the reporting mechanism for invalid data. Some people like to display the form with the input highlighting any errors. This makes it simple for the user to find and fix problems in the data. Others prefer to keep the page and application design as simple as possible by reporting errors on a separate page. The user then needs to either go back to the original form using the back button on their browser or they may be presented with a link to a page which will contain their entered data.

3.2 Navigation

Meaningful, clean, structured navigation and information design is one of the most important aspects of web design. There needs to be a consistent look and feel throughout the site. Any User needs to be able to immediately recognize their location in the site as a search engine referral can throw them anywhere.

There are three major navigation designs employed on the web today.

• Single level navigation has a list of top level areas within the site.
• Multi-level navigation breaks the site into a hierarchy. The user can then drill down through these levels to find the desired content. All levels of the hierarchy are displayed as part of the navigation at all times. As such the hierarchy is usually only two levels deep to keep the display simple.
• Dynamic multi-level navigation also uses a hierarchy except here the next level of navigation is not shown to the user until they have selected the parent.

3.3 Database Handling

The best way to access a database is a fundamental problem for web developers. In fact, it’s so common that we could easily forget to consider it as being a problem we need to solve. Most people access databases through specific functions, class or an abstracted database wrapper.

Many web applications and forms revolve around letting the user insert new information into the database and edit existing entries. The data being used is irrelevant to the solutions employed making this a good candidate for a pattern.

3.4 Authentication

Any request to a web site is authenticated at one of the following levels:

• None – we do nothing to record or track the request
• Visitor – we track this anonymous person across numerous sessions at the site
• User – we have information about the person and require them to authenticate

These levels of authentication are related and have similar implementations. They should be considered together as we need to know the authentication level of any request to the site.

3.5 Error Handling

Fixing errors before they confuse users is vital. Logging and notifying the maintainers of these errors is equally important to prevent them happening again.

Another good error handling problem to consider is keeping the site alive even if components are off-line. For example, if the database is being backed up and thus read-only can we continue to serve database requests without trying to write. Or if the database is offline completely can we continue to show pages that do not really need to use the database.

3.6 E-commerce

E-commerce is an interesting problem because it requires the form and authentication problems above to be solved. The challenge is to build a pattern for e-commerce that is not dependent on a particular implementation of forms or authentication.

4 Categorizing the Application Levels affected by each Problem

Placing problems into their levels will help us to understand which problems are specific to web programming.

4.1 Form Using

All form processing is done through a user interface interaction with the user. This results in calls to the high-level functions implemented in the code libraries. As such, form processing is limited to all of the front-end levels.

4.2 Navigation

Single and multi-level navigation is limited to the user interface and human computer interaction levels.

Dynamic multi-level navigation requires knowledge of the users current location and the ability to generate navigational menus. Backend libraries will also be required to generate these menus. Whether these should be part of a pattern for multi-level navigation or just listed as a collaborator is open to debate.

4.3 Database Handling

Database wrapper code lives in the code library and database query levels. It actually only needs to know about simple database queries since most are just passed through the wrapper class.

Formalizing the process of inserting and editing data into the database requires the use of all levels. We need to design the database to facilitate this type of data entry. The user interface must be developed to make the process clear.

Trying to encapsulate database rows as objects or items is limited to the backend levels. The front-end has access to this data through the API developed for the items.

4.4 Authentication

User level authentication requires interaction with the person through the front-end. It also requires backend functions to verify and process the information arising from this interaction. It uses all levels of web programming.

All other forms of authentication require no interaction with the user. They are completely contained in the backend levels.

4.5 Error Handling

Errors must be reported to the user and detected at all levels of the application. Error handling code uses all levels.

4.6 E-commerce

E-commerce requires interaction with the user and backend processing of the data. It requires all levels.

Design patterns are basically an extensive method that can be used in solving a variety of different problems.  Design patterns use the principles of Object Oriented Programming (OOP) to help you create code that will be easy for you and the developers who follow you to understand, revise and extend.

The importance of design patterns is that they formally document problems and their solutions. This gives us a means to recognize and refer to known problems. We also have a means for comparing alternative solutions with full awareness of the consequences of each alternative.

By formally describing design patterns for web programming we can capture the knowledge of experts into a form that can be used by any developer. Well-named design patterns will also improve the ability of web developers to communicate their ideas and intended solutions.

Design Patterns are simply defined solutions to common problems.  Design patterns are proven solutions that are implemented over and over again through different projects.  This re-use of the solution itself becomes a pattern.  Don’t be intimidated by the imaginative names given to design patterns, such as illusion, singleton or spectator, they are exactly that just decorative names given to repeatable solutions.

• A design pattern is  a recommended solution rather than a style that is not implementation specific.  In other words you can take the same design pattern and implement it with any language, of course if the design pattern is an OO design pattern you need to implement it with an object-oriented language.  More importantly the implementation itself may vary from project to project because of project restraints and requirements.
• A design pattern is NOT a framework, though depending on whom you speak to, a group of design patterns maybe considered as a design framework.

Why Use Design Patterns

Design patterns are not new. In fact, the concepts behind them go back 20+ years but it’s really in the past 4-5 years that they’ve really gained prominence in software development in general. Most PHP developers may first ask why use Design Patterns or why design in the first place.  You will find Design and Design Patterns are beneficial in regards of:

• Maintenance
• Documentation
• Readability
• Easy when developing in large development teams
• Reusable by other then yourself

If this indeed is true then object-oriented development and design pattern skills are a definite asset to your resume.  Most enterprise applications that succeed are because of the fact that a good methodology and development process is in place, and apart of that comes design and with design more then likely comes design patterns.

However there is a trade off with design patterns because it adds another layer/component of abstraction there maybe a loss in performance and efficiency.   Granted this may not be noticeable on high-end servers, but could be problem on low-end servers.

Going off topic for moment, this is especially so when developing J2ME mobile applications, this would be prime example where coding like style would be more dominant then object-oriented coding purely for the fact that memory and heap size on mobile devices is limited.

First, benchmarking a web server is not an easy thing. To benchmark a web server the time it will take to give a page is not important: you don’t care if a user can have his page in 0.1 ms or in 0.05 ms as nobody can have such delays on the Internet.

Larry Garfield has an interesting set of benchmarks covering many of PHP’s magic methods. His results correspond pretty well to my own benchmarks in the area. The thing to take away is that its not necessarily the overhead of the magic methods, but rather what you do inside them. Its hard to do anything useful inside a magic method, such as __get or __call that isn’t 10 to 20 times slower than the “non-magic” solution.

There are probably more than a few naive programmers who would read results like this and start to avoid these constructs in their own code for performance reasons. These are the same kinds of people obsessing over a few single or double quotes, who eschew “slow” objects in favor of switch statements that are many times slower than the polymorphic method calls they are trying to avoid. But, that’s not the end of the story. Larry ran his benchmarks using 2,000,000 iterations. The N really matters here. Sure, iterators are slower than arrays, but you aren’t going to be iterating over two million things. I tend to fetch my database records in lots of 25 or 50. You aren’t going to be making two million invocations of __call. But how many will you make? Under what value of N does the performance of these techniques cease to matter? Is it ten, one hundred, one thousand, or ten thousand? You may be surprised at how few calls your program actually does and how little impact it has on performance. As Wez and Travis point out in their comments, profiling is the way to find out the potential impact and to discover your true N.

Paul M. Jones has a good example of what I’m talking about. There, call_user_func_array appears to be a bottleneck, but it turns out that its the function being called, htmlspecialchars, not the calling process that consumes the balance of the time. In that case, the function was “only” called 300 times. I find that order of magnitude to be fairly typical. Something to be aware of, perhaps, but not something to obsess over.

The memcached server and clients work together to implement one global cache across as many machines as you have. In fact, it’s recommended you run both web nodes (which are typically memory-lite and CPU-hungry) and memcached processes (which are memory-hungry and CPU-lite) on the same machines. This way you’ll save network ports.

Installation

You have enable memcache extension from php.ini file.

Download memcache daemon from  http://jehiah.cz/projects/memcached-win32/

To install memcached as a service, follow the next steps:

1. Unzip the binaries in your desired directory (eg. c:\memcached)
2. Install the service using the command: ‘c:\memcached\memcached.exe -d install’ from either the command line
3. Start the server from the Microsoft Management Console or by running the following command: ‘c:\memcached\memcached.exe -d start’
4. Use the server, by default listening to port 11211

Sometimes  it says couldn’t connect because i was n`t running the daemon. When you install the memcached it only install the extension and this gives the interface (functions) to access the memcache but to be able to store and retrieve data you need to install and run the daemon.

Sample Code:

$memcache = new Memcache;
$memcache->connect('localhost', 11211) or die ("Could not connect");

var_dump($get_result);

Conclusion

Memcahce is very faster than shm_op. It uses libevent to scale to any number of open connections (using epoll on Linux, if available at runtime), uses non-blocking network I/O, refcounts internal objects (so objects can be in multiple states to multiple clients), and uses its own slab allocator and hash table so virtual memory never gets externally fragmented and allocations are guaranteed.

Reference: http://danga.com/memcached/

The first thing people generally do is cache things within their web processes. But this means your cache is duplicated multiple times, once for each mod_perl/PHP/etc thread. This is a waste of memory and you’ll get low cache hit rates. If you’re using a multi-threaded language or a shared memory API (IPC::Shareable, etc), you can have a global cache for all threads, but it’s per-machine. It doesn’t scale to multiple machines. Once you have 20 webservers, those 20 independent caches start to look just as silly as when you had 20 threads with their own caches on a single box. (plus, shared memory is typically laden with limitations)

One annoying thing is that shm_op requires to allocate a memory block first though the system don’t know how much memory it needs to handle data. That’s why, this is apperant that shm_op either block some spaces which are not used or cannot save data if allocated size is less than data size.

Installation

You have to enable shm_op extension from php.ini file and restart apache server.

Sample Code

// Create 100 byte shared memory block with system id of 0xff3
$shm_id = shmop_open(0xff3, “c”, 0644, 100);
if (!$shm_id) {
echo “Couldn’t create shared memory segment\n”;
}

// Get shared memory block’s size
$shm_size = shmop_size($shm_id);
echo “SHM Block Size: ” . $shm_size . “ has been created.\n”;

// Lets write a test string into shared memory
$shm_bytes_written = shmop_write($shm_id, “my shared memory block”, 0);
if ($shm_bytes_written != strlen(“my shared memory block”)) {
echo “Couldn’t write the entire length of data\n”;
}

// Now lets read the string back
$my_string = shmop_read($shm_id, 0, $shm_size);
if (!$my_string) {
echo “Couldn’t read from shared memory block\n”;
}
echo “The data inside shared memory was: ” . $my_string . “\n”;

//Now lets delete the block and close the shared memory segment
if (!shmop_delete($shm_id)) {
echo “Couldn’t mark shared memory block for deletion.”;
}
shmop_close($shm_id);