My thoughts on determining if you are standing the correct distance from the golf ball in more detail:

You will know if this feels wrong through developing a feel for your clubs (by practicing daily). To verify the correct distance to stand from the ball, let your right arm fall away from your grip, hanging from your body. If your right hard falls away from your grip in line with your target, you are the correct distance from the ball. This same rule applies with all clubs from your wedge to your driver.

Address

1. Address the ball. [more info]
2. Check I’m standing the correct distance from the ball. [more info]
3. Check the ball is where I want it in relation to my stance.
4. Check my feet are far enough apart to provide a strong foundation for my swing.
5. Look at the target and make any final foot adjustments.
6. Check my knees feel like that are pointing towards each other, providing a strong swing foundation.
7. Check my elbows are in the correct positions. (Left elbow straight, with inside of left elbow pointing up. Right elbow bent straight down in a relaxed position, with inside of right elbow pointing up)

Backswing

1. Take the club away in one motion. (The hands, arms, shoulders all acting as one)
2. Feel that right elbow brushing against my side throughout the whole backswing. (This ensures I’m on the correct swing plane, rotating around my body)
3. Check I get a full shoulder turn on the backswing.
4. At top of backswing, check I still feel that right elbow brushed against my side.

Downswing

1. Turn my hips back to the left. (Make sure this is a turn, not a slide)
2. Check your head does not move too far forward on the downswing.
3. Feel that leading left arm through the impact zone. (This will prevent the right arm dominating and hooking the ball, and gives you the control to play a draw, fade or straight shot, just direct the left arm through the hitting area how you want)

Final Thoughts

1. If blocking or slicing, check you are getting a full shoulder turn, your hips are not sliding on the back or downswing, and that your right elbow is in the correct position on the backswing.

My thoughts on stepping up to the golf ball in more detail:

1. With no club in my hand, pick my target.
   Choose the precise spot on the green or fairway where I want my ball to land. (Be sure to take into account the roll you expect for a given landing spot)
2. Select my club, and take my grip.
   Through experience we learn club selections, only practice can tell you what club to select. I will not go into grip specifics but I’m an interlock grip fan. As a general rule, at address you should see two knuckles on your leading hand, with both V’s of your thumb and forefingers of both hands pointing towards your face.
3. Step up to the ball.
   First position the clubface square to the ball (in line with my target), then take my stance, with the ball positioned forward in my stance (forward for standard shots, back in the stance to play a punch shot under the wind).

So to save your ass, I’d like to shed some light on good versus bad methods. You may disagree with some methods because they may not improve readability of code, and that is your choice, but the ultimate aim of this article is to promote the most performance friendly method for a given situation.

Strings on Multiple Lines

If you work with PHP, sooner or later you will need to manage a multiple line string in code (whether it be for outputting text, or creating a SQL statement string). If you need to create a multiple line string, my advice is to use multiple lines within the ONE string.

Eg: Don’t do this:

<?php
$sql_insert_string = 'SELECT id, name';
$sql_insert_string .= 'FROM products';
$sql_insert_string .= 'ORDER BY name ASC';
?>

(performance unfriendly: PHP has to allocate memory for three strings and concatenate them)

Or this:

<?php
$sql_insert_string = 'SELECT id, name'
. 'FROM products'
. 'ORDER BY name ASC';
?>

(performance unfriendly: Even though this looks like one long string, PHP is really dealing with three strings and has to concatenate them to form the one string)

Instead, do this:

<?php
$sql_insert_string = 'SELECT id, name
FROM products
ORDER BY name ASC';
?>

(performance friendly: PHP has one string to deal with, single memory allocation, no concatenation)

Use Single Quoted Strings

I’m sure you know about PHP’s nice and friendly way of allowing you to put variables directly inside double quoted strings like this:

<?php
$years_old = 21;
$one_liner = "Hey good lookin, you must be $years_old this year";
?>

(performance unfriendly: unnecessary overhead)

This seems nice and handy I know, but for PHP, this means that ANY string with double quotes has to be searched for potential variables = unnecessary overhead.

Instead, stick to the single quote method. As I also work with VB.NET (where there is no double quote support for strings) this wasn’t a hard one for me to adjust to, but if you’re starting out, it’s important to not get into the bad habit of using double quoted strings if you can avoid it. You might think the overhead marginal, but add up all the double quoted strings in your ever-growing application, put your application under heavy load with shitloads of users hitting your webserver and you’ll be wishing you had written your strings in the single quote method.

This is the better version:

<?php
$years_old = 21;
$one_liner = 'Hey good lookin, you must be '.$years_old;
?>

(performance friendly: No double quotes here, yay!)

I can attest to this being true. I had a project a year or so ago that dealt with heavy mathematical operations (luckily the mathematical operations were already written and I just had to translate them to PHP). I had the bad habit of always writing variables within double quoted strings for various output. When it came time to analyse the performance, the client wanted every minisecond he could get. I had to find ways to knock a few seconds off execution time. The first thing I did was a mass find-and-replace operation to convert double quoted strings to the single quote method (not an easy operation), but when I was done we shaved a second off. That one second proved to me just how important this method is. Imagine an extra second load time for users when your webserver is under load :-/

Note: This same principle applies to array indexes:

<?php
//if using string indexes, do it like this:
echo $date_array['january'];
//not like this:
echo $date_array["january"];
?>

String Concatenation and Output

This is a pretty cool trick I didn’t know about until recently, but you can use commas to concatenate strings in PHP and it provides a performance benefit.

For example:

<?php
//while this looks like a single line of output:
echo 'SELECT id, name' . ' FROM products' . ' ORDER BY name ASC';
//to PHP it actually translates to:
echo 'SELECT id, name';
echo ' FROM products';
echo ' ORDER BY name ASC';
?>

(performance unfriendly: even though this looks like one long string, PHP is actually dealing with three separate strings here, and sending all three strings to output as shown in the translated section …hence unnecessary overhead)

Instead, use commas:

<?php
//this looks like a single line of output:
echo 'SELECT id, name', ' FROM products', ' ORDER BY name ASC';
//it actually translates to one line of output for PHP:
echo 'SELECT id, name FROM products ORDER BY name ASC';
?>

(performance friendly: PHP has one string to deal with, single memory allocation, no concatenation)

Choice of Functions

Always refer to the official PHP manual when confronted with a choice of potential PHP functions for a given situation. Many functions exist that appear to do the same thing, but if used unnecessarily can lead to unnecessary overhead/confusion in your applications.

For example, you will probably get some advice to look at using preg/ereg functions in PHP whenever you ask about string replacements, but if you need to do a simple string replacement (Eg. replace all ‘http’ with ‘https’) use the str_replace function. Only use the preg/ereg functions when you need to involve regular expressions …that is their purpose. And str_replace is for simple string replacements.

Now I say ’successfully’ because more than half the audience was sold on their little scam. And for big money too. We’re talking upwards of $12,000 for each sale. You might think crazy price, but for a fully product driven website, with the company holding your hand the whole way, that’s probably about the right price. The only problem is they were hinting at guaranteed success, and failed to mention how competitive the search industry is for any common product driven website. Sure, hand over your hard earned cash, get a website developed, but then what? How is anyone going to find your site over the thousands of other sites all similarly produced?

The truth is search engine marketing is a massively important part of the equation, and I’d  say you need to allow more than half of your initial project budget and time to search engine activities for the first year, otherwise you can expect to be getting minimal, if any, traffic to your fancy site. I won’t go into specifics about search engine techniques, because honestly I’m still learning myself (and it is a continuous learning curve), but I will be documenting my progress as I learn and succeed, so keep tuned. My point is simply to make you aware of scams like this one I witnessed, and to be very wary of anyone selling you a website that fails to mention the importance of ‘being found online’. If they don’t mention it, YOU bring it up. It’s your money and your future success. Be smart, ask the questions, analyse the answers. If you’re unsure about the answers you get, take your question and the answers you’ve got to the top search forums (type ’seo forum’ in google) and see what the experts have to say about your situation. You’ll find the nice guys more than happy to comment honestly and openly. Don’t ever be taken for a ride …and always remember that the people you deal with are often professional salesmen

I found this free little tool for generating different types of data online:

(http://www.generatedata.com/#generator).

I just plug in a few options and this generator gives me as much realistic data as I need to properly test my csv import application. Saves me more than a few minutes writing test data myself. Useful for load testing as well. Generate a few thousand lines of csv, import it to your database and test away. Of course, you can use MySQL functions to help generate a heap of INSERT statements as well, but this is another way

The problems come when you leave the small problems and move into medium-large scale problems with lots of interrelated subsystems all talking to each other. Or, more importantly, when you have a system with base classes and you start the coding of the base classes too quickly. End result - disaster! Coding is just like real world construction: If your foundations are crap, guess what? The final product (if you ever make it to a final product) will be flimsy at best. It (your application) will either fall over or will be subject to criticism for the rest of its short life because of what we call incomplete coding preparation.

Still feel like rushing into that programming? If you do you’re a knob (politically correct term for you morons that are giving programmers a bad name by jumping into programming too quickly, then blaming the designers and everyone else when things go to shit)

Being what I consider a good programmer means having the ability to read design documents and being critical of them. Don’t take the attitude that if the coding screws up, we can trace it to the design documents, so the designers will be to blame, not me. That’s the quickest way to failure. Instead, stand up, approach the designers and tell them of the errors or any questions you have. Feel unsure about a section of the design? Ask them! Think of it like this: If you, a professional programmer, cannot understand the design document, then the design is flawed.

A key concept you need to understand early in your programming life is that the overall goal of planning and design is to reduce risk. Asking questions of the design, if you (the programmer) don’t understand something, is all helping to minimise the risk and ensure the project’s success. Your project’s preparation needs to focus heavily on improving the planning and design so that the clear direction follows through to the programming stage. Ensuring good communication between design and programming is imperative to your project’s success and the wellbeing of everyone involved.

I know, I know, some programmers are out there reading this and saying to themselves “but my boss wants things done quickly and we don’t have the time.” Bad attitude and wrong decision.

Firstly, good design might be hard to master at first, but once your designers get in the groove of turning out quality well thought out designs, everything runs smoothly. The programmers can’t stuff anything up if the design is bulletproof, and if they do, they need a boot up the arse so they begin to follow the good direction of the design to a tee. What follows is a well oiled application making group of individuals that respect each others work and produce good results, which in turn gives the company a better reputation for quality work. The point is, good design may take time, but it takes less time than bad design stuffing up the programming stage, which will end up taking a LOT more time to fix and re-test. So if your boss doesn’t understand that, request a meeting and let them know, and if nothing changes, find a new boss because you deserve better

The admin design has had some serious modifications to vastly improve usability. No more menu clutter. Smart use of ajax technology where necessary. But I just can’t get over how clean and professional the whole package looks. Things are just intuitive. And the really cool part is I can use Windows Live Writer to write blog posts from my desktop without even needing to be logged into the website (not a huge bonus but still pretty cool)

I’d seriously recommend checking out wordpress’s latest and greatest stable offering. The interface is really second to none. Thanking you wordpress!

When I first read this concept I just didn’t get it (I’m a bit slow). But it’s really pretty simple. You just have to know your terms. A class defines the structure of an object, and to use that class, we instantiate an object of the class. So take the following php:

<?php
//create an instance of the Product class
$product_object = new Product();
//print the product's name
echo $product_object->product_name;

//create another instance of the Product class
$product_object2 = new Product();
//do other stuff
//...
?>

In this example, ‘Product’ is the class and ‘$product_object’ and ‘$product_object2′ are instances of the Product class.

We use the singleton pattern by creating a class with a function that creates a new instance of the class only if one does not exist. If an instance does already exist, it simply returns a reference to that object. This ensures you only have one instance at any one time, hence singleton.

So in the above php for example, if our Product class used the singleton pattern, ‘$product_object’ and ‘$product_object2′ would in fact be referring to the same instance of the Product class.

Why is this useful?

Well firstly I imagine this would use less system resources. If it’s only ever referencing one instance, memory usage would be kept to a minimum, so one could argue a performance advantage.

Secondly I could see this pattern useful in complicated systems where you need a be referencing a single object at any given time, perhaps a User object, to coordinate actions in different parts of the system, or sub systems. A user object is often referenced in many different parts of the system, so always referencing the one instance would be beneficial.

Real world example

Here is some example code from the PHP manual on how to create a class that uses the singleton pattern:

<?php
class Singleton{
	// $instance holds a single instance of the object
	private static $instance;
	// private constructor
	private function __construct(){}
	// the getInstance() method returns a single instance of the object
	public static function getInstance(){
		if(!isset(self::$instance)){
			$object= __CLASS__;
			self::$instance=new $object;
		}
		return self::$instance;
	}
	public function displayMessage(){
		echo 'I am a Singleton';
	}
}
$singleton=Singleton::getInstance();//return a single instance of the object
$singleton->displayMessage();// display message
?>

And here is another useful example I found that you can use that is more animated …run this and you’ll see the singleton output inform you that only one instance exists at a time

<?php
echo '1:';
$user_1 = CurrentUser::singleton();

echo '2:';
$user_1->counter();

echo '3:';
$user_2 = CurrentUser::singleton();

/* Singleton Class: CurrentUser */
class CurrentUser {
    // Hold an instance of the class
    private static $instance;
    private $counter = 0;

    // A private constructor; prevents direct creation of object
    private function __construct() {
        echo 'Constructing CurrentUser';
    }

    // The singleton method
    public static function singleton() {
        if (!isset(self::$instance)) {
            $c = __CLASS__;
            self::$instance = new $c;
        } else {
            echo 'CurrentUser already exists';
        }
        return self::$instance;
    }

    public function counter() {
        echo 'CurrentUser -> counter = ' . $this->counter;
        ++$this->counter;
    }
}
?>

(original source)

Design patterns speed up the development of a project by providing a proven and tested way of doing things. Reusing design patterns in your project helps to prevent any unforeseen problems, and provides a common ground for developers working on your project who are familiar with the patterns. This can help to improve your code readability and consistency of methods, which all help to provide a good software product.

Imagine you introduce a new developer to your project. If your current developers can say that the X part of the system uses the Decorator pattern, both developers have just saved a lot of time in teaching/learning curve, because the developers know what that means. It’s their ‘geek speak’ and allows them to explain a somewhat complicated concept very quickly.

My point is, if you want a future in the software industry, you need to be fluent in this geek speak so that you too understand these terms for quick introductions to new or old projects. What follows is examples of the common design patterns in software engineering with easy to understand examples for each pattern to help you learn and understand the concepts quickly.