PHP Warning:  PHP Startup: Unable to load dynamic library 'C:\Program Files (x86)\PHP\ext\php_curl.dll' - %1 is not a valid Win32 application. in Unknown on line 0

Then try copying the libeay32.dll and ssleay32.dll files from your PHP installation and put them into your Apache /bin directory. Finally got it working after much unsuccessful googling and banging head against the wall.

This is where I feel we are with our current government.  It has become slow and inefficient.  It is difficult to manage and does not meet the needs of the people.  Most everyone agrees that our government is broken regardless of their political opinions.  I hear often that the solution is to vote the current people out of office.  But I don’t believe this solves anything because the problem is with the system as a whole.  It doesn’t matter how good willed and motivated of a person we put in office, they aren’t going to be able to make a difference.

Take President Obama for example.  Whether you agree with him politically or not, you pretty much have to agree that he was highly motivated in 2008 to make a difference.  Did he make a difference?  Not much.  However, I don’t believe it was for a lack of trying.  It’s just not possible with the current system of government that we have in this country.

We vote the republicans into office, nothing happens, so we get angry and vote the democrats in, nothing happens.  We get angry again and vote the republicans in and we just keep continuing the cycle.

I think it is time for a rewrite.  We have learned a lot from our current government, and from other governments.  We have seen what is successful and what is not.  The economics and philosophies have change a lot over the course of our countries history and we need a government designed for it.  I believe that with a proper democratic process, we could write a new system of government that would be much more effective and relevant.

Let’s rewrite our government!

https://occupywallst.org/

https://www.facebook.com/OccupyWallSt‎

“I am a most unhappy man. I have unwittingly ruined my country. A great industrial nation is controlled by its system of credit. Our system of credit is concentrated. The growth of the nation, therefore, and all our activities are in the hands of a few men. We have come to be one of the worst ruled, one of the most completely controlled and dominated Governments in the civilized world no longer a Government by free opinion, no longer a Government by conviction and the vote of the majority, but a Government by the opinion and duress of a small group of dominant men.”

-Woodrow Wilson, after signing the Federal Reserve into existence

The fix is pretty simple, just add this line to your subversion config file

global-ignores = *.o *.lo *.la *.al .libs *.so *.so.[0-9]* *.a *.pyc *.pyo *.rej *~ #*# .#* .*.swp .DS_Store nbproject

On Windows:
C:\Users\[your username]\.netbeans\7.0\config\svn\config\config

On Mac/Linux:
/home/[username]/.svn/config

Waiting for footings to dry

After 24 hours the footers are ready to build on…

The finished footings

Close up of a footer

Posts places on footers

Notches for beams cut into posts

Another view of the completed posts

Beams bolted to posts

Hanging the joists

Another view of the completed beams

Another view of the joists being installed

Installing the deck boards

Completed joists

Installing the gate

Another view of the completed joists

Putting the deck boards down

The finished deck

Finished Deck

Here is an example of the configuration. The first array specifies fixed routes (routes without any regex in them). This is separated from the regex array for simply for speed. Each element in the array represents a route. The key is the URI and the array that it points to has the controller and the method to call for that route. Any slashes before and after the URI are removed when searching for a match, so you don’t need to put those in your routes. Also, an empty key represents the index

1
2
3
4
5

$config['routes']['fixed'] = array(
    '' => array('SupportPages', 'index'),
    'contact' => array('SupportPages', 'contact'),
    'support/help' => array('SupportPages', 'help'),
);

The regex array has the same format, except that you can put regular expressions in for the routes. This is a lot more complex and requires that you be fairly familiar with regular expressions. Anything that you put in parenthesis will be converted into a parameter to the method that you call, so in the example below, the SupportPages class with the test method would be called and the number from the URI would be passed as the first (and in this example, the only) parameter. Also, if you omit the method in this array, it will try to use the first match in the regex as the name of the method to call.

1
2
3

$config['routes']['regex'] = array(
    '/^test\/([0-9]+)$/' => array('SupportPages', 'test'),
);

To use the code, you will need to set up your web server to send all requests to index.php and then put the code below into your index.php file. On line 46, the file that contains the code for your control is simply included. This can be modified to whatever your file structure happens to be. You could remove this line altogether and create an __autoload function.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

$controller = null;
$action = 'index';
$params = array();
 
// Make sure we have a clean uri to work with
$uri = trim(str_replace('index.php', '', $_SERVER['REQUEST_URI']), '/#');
 
// Check for a fixed route
if (isset ($config['routes']['fixed'][$uri])) {
   $route = $config['routes']['fixed'][$uri];
   $controller = $route[0];
   $action = $route[1];
} else {
   // No match, check if we have a match in the predefined regex routes
   foreach ($config['routes']['regex'] as $pattern => $route) {
      if (preg_match($pattern, $uri, $matches)) {        
 
         // Found a match, set the controller
         $controller = $route[0];
 
         // Set the action, if the action is not specified, then it is
         // set to the first match
         if (! isset ($route[1]) || $route[1] == null) {
            $c = explode('/', str_replace($matches[0], '', $uri));
            $action = (! isset ($c[1]) || $c[1] == null) ? 'index' : $c[1];
            array_shift($matches);
         } else {
            $action = $route[1];
         }
 
         if (count($matches) > 1) {
            // There were params found, so dump the first value in matches.
            // The rest of $matches contains the parameters.
            array_shift($matches);
            $params = $matches;
         }
         break;
      }
   }
}
 
if ($controller == null) {
   header('Status: 404 Not Found');
   exit;
}
require $controller . '.php';
$c = new $controller();
call_user_func_array(array($c, $action), $params);

For completeness, here is a really simple controller to see how one might be structured. To work with the sample code above, this file would be named SupportPages.php and would be stored in the same directory as index.php. Again, you could make this into a much more robust system by modifying line 46 to match your prefered directory structure.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class SupportPages {
 
   public function index() {
      echo 'index';
   }
 
   public function contact() {
      echo 'hello';
   }
 
 
   public function test($param) {
      echo 'The Param is: ' . $param;
   }
}

The echo and print methods are virtually the same.  They are both built into the language so they are faster than function calls.  The one thing that makes them different is that print returns whether it was successful or not while echo does not return anything.  This puts a little overhead on print that echo does not have.  So unless you need the return value, stick with echo.

echo 'Testing';

print 'Testing';

2. Single quotes vs double quotes

Double quotes has the ability of embedding variables within the string and also translating other escape characters.  With single quotes, what you see is what you get.  The string is exactly as you typed it.  Because PHP has to do extra work in checking a double quote string, using single quotes is faster.

echo 'Testing';

echo "Testing";

3. Use commas for multiple parameters

So at this point your using echo, and your putting your strings in single quotes.  But what do you do when you need to echo a variable, since we aren’t using double quotes, we need to use . to concatenate it right?  wrong.  PHP has a built in operator that is not well known but a comma can be used to specific multiple parameters to the echo command in much the same way that you would specify multiple parameters to a function.  This is much faster than string concatenation with the period operator.

echo 'You are ', $percent, '% correct';

echo 'You are ' . $percent . '% correct';

4. Use lowercase reserved words

You probably already do this for the most part, but because PHP is case insensitive to keywords you can write code with reserved words that are in capital letters.  Words such as echo, class, foreach, can all be written in capital letters. For example, ECHO, CLASS, and FOREACH will all work just fine.  Because PHP stores these words internally in lowercase, it is fastest to use them in lowercase.

While almost everyone already does this, there are some cases where you may not.  The keywords true and false are faster than using TRUE and FALSE.

echo 'Testing';

ECHO 'Testing';

return true;

return TRUE;

5. strtr vs str_replace vs preg_replace

The three of these function have their place and are all useful for difference circumstances. strtr is the simplest of the functions and is also the quickest. While it has the capability of handling multiple characters, don’t use it for that, use str_replace instead. strtr is fastest for single character replacement. str_replace fastest for multiple character replacement. And only use preg_replace if you really need regular expressions.

strtr($str, 'a', 'b');

str_replace('a', 'b', $str);

strtr($str, 'abc', 'def');

str_replace(array('a','b','c'), array('d','e','f'), $str);

str_replace(array('one', 'apple'), array('two', 'orange'), $str);

strtr($str, array('one' => 'two', 'apple' => 'orange'));

6. require() vs require_once()

Use you really need require_once(), you should always be using require(). If you do find yourself using require_once often, you should look into why that is, because in most cases a well structured program should not need require_once.

7. Use static methods in your classes

If you are writing object oriented code, check your function to see if they can be static methods and if so declare them static. Calling static methods are significantly faster than calling regular methods because PHP has a lot less bookkeeping to worry about with a static method.

8. Pre increment/decrement instead of post

It is faster to use ++$count; than it is to use $count++; This is because of the internal workings of PHP. When a value is pre-incremented or decremented the change happens to the variable but when it is post-incremented or decremented, a temporary variable is created the value is incremented or decremented and then copied back into the original variable.

++$count;

$count++;

9.pathinfo() vs basename()

The pathinfo function comes with some options that can be used to get information about a path. If you use these options, chances are there is a better way. PATHINFO_BASENAME returns the base name of the path, but so does basename() and it is 7% faster than using pathinfo. The same applies to using PATHINFO_DIRNAME. Use the dirname() function instead. dirname() is 53% faster than pathinfo.
It’s also worth noting that finding the directory name is nearly 10 times faster than finding the basename of a path.

basename($path);

pathinfo($path, PATHINFO_BASENAME);

dirname($path);

pathinfo($path, PATHINFO_DIRNAME);

10. Finding the application root directory

A common task in a PHP application is finding the root directory that the application sits on top of. This is useful for two reasons. First, it can be used as a reference to finding all other files, particularly for require and include statements. Also, using the full path instead of relative paths requires less overhead on the part of the operating system.

The best way to find the root directory is to use dirname(__FILE__), or if you are using PHP 5.3 you can use __DIR__ and save yourself an extra function call. This will give you the directory portion of the current file. You can then use this to find any other file in your applications hierarchy.

Another method is to use $_SERVER['DOCUMENT_ROOT']; While this in theory should work, and usually does, a poorly configured web server can have this pointing somewhere else then where you would expect.

dirname(__FILE__)
__DIR__

$_SERVER['DOCUMENT_ROOT']

define('ROOT', __DIR__);
require(ROOT . '/include/functions.php');

require('include/functions.php');

11. Don’t use error suppression

The @ character can be used in front of a statement to suppress errors, however it is advised not to use this for a couple of reasons. First, it’s a hack. Errors are there to tell you that something is wrong with your code, simple ignoring it is not a fix. Second, it is slow.

$a = isset($_POST['a']) ? $_POST['a'] : null;

$a = @$_POST['a'];

12. Multiple isset

If you need to check to see if multiple variables are set, you can do so with a single isset call rather than multiple.

if (isset ($a, $b, $c) { ... }

if (isset ($a) && isset ($b) && isset ($c)) { ... }

13. switch case vs if elseif

If you have several else if statements in your code, it may be possible to covert this into a switch .. case statement. Using a switch .. case statement is typically faster.

14. Avoid function calls within loops

This applies to any language, but PHP, as an interpreted language is even more susceptible to this than other languages because compiled languages like C and C++ are able to do a bit of optimizing to move stuff outside of the loop for you. So whenever possible move whatever you can outside of the loop. Sometimes this is less obvious like the example below.

$count = count($a);
for($i = 0; $i < $count; $i++) { ... }

for($i = 0; $i < count($a); $i++) { ... }

15. Derived classes vs base classes

Calling a method in a derived class is faster than calling one in the base class. This is because PHP first looks for the function in the top most class and works it’s way down. So a method in the base class will be the last place it looks before giving up and the derived class will be the first place it looks.

While it would be a very bad idea to structure your classes based on this bit of information, I do believe it is worth noting and being aware of when writing your code.

16. call_user_func_array

The call_user_func_array() function is fairly slow, but if you know how many arguments your function accepts, you can call it much faster without call_user_func_array. Even if you don’t, you can nearly double it’s speed with this switch .. case statement:
(where $c = the class you are calling, $m = the method, and $p is an array of the parameters to call the function with)

switch(count($p)) {
        case 0: $c->{$m}(); break;
        case 1: $c->{$m}($p[0]); break;
        case 2: $c->{$m}($p[0], $p[1]); break;
        case 3: $c->{$m}($p[0], $p[1], $p[2]); break;
        case 4: $c->{$m}($p[0], $p[1], $p[2], $p[3]); break;
        case 5: $c->{$m}($p[0], $p[1], $p[2], $p[3], $p[4]); break;
        default: call_user_func_array(array($c, $m), $p);  break;
    }

17. Use arrays instead of objects when appropriate

Sometimes we can go too far in our endeavor to make everything object oriented. OOP has a cost, and if your data is able to be stored as an array do it. Don’t create an object out of it just for the sake of object oriented programming. Objects carry a lot of overhead with them that arrays do not have. So if all you need is an array, don’t make it an object for no reason.

18. isset instead of strlen

I don’t personally care for this optimization as I think it makes the code not very readable. But the idea is that if you need to check to see if a string is a certain length, you can do so quicker with isset than with strlen. So, for example, if you needed to check to see if a string was shorter than 10 characters, you could do so with

isset($string{10})

would return false if the string was shorter than 10 characters.

19. unset arrays

If you are using arrays in your code, you can sometimes save some memory by using unset() to free the memory when it is no longer needed. This isn’t needed as often as it may appear at first glance. When trying to determine whether to unset a variable, keep in mind that when your function exists, any local variables will be freed anyways, so you usually only need to do this when you are using an array for a temporary time, then are allocated more memory right after that.