Enter “Responsive Design,” or a one-size-fits-all solution for developing web pages and applications. The problem however, is that while for some sites this approach may work, it doesn’t for all sites. The more content you add, the more features you add, the more complex your site becomes… and let’s face it, there are some things you can do on a desktop browser that you really shouldn’t on a mobile (ie phone) display.

To solve this dilemma, a great idea was born. Let’s develop for mobile displays first… after all, for years we have taken a desktop first approach. The problem is that this doesn’t fix the problem, but only shifts it. While it makes sense to find the most relevant data and place it first, we have to keep in mind the formatting of the users device, and the purpose of the user for visiting our site on that device.

For example, if you are visiting CNN, you want news. You probably don’t care as much about their daily poll, and I’m guessing you don’t want to have to scroll through all 2,000 sections to find the stories you want. Instead, CNN wisely provides you with the most relevant news to you – with the option to browse to the more refined areas should you choose. Likewise, checking weather.com on your mobile device probably means you want to know your local weather, and could probably care less about what’s playing on the Weather Channel right now. Maybe you want to watch an episode of Storm Chasers, or take a look at videos from Hawaii, but for most people, they just want to know whether or not it’s going to keep snowing in April in Minnesota.

So keeping this in mind, we need to find a versatile solution. Sure we can create one site with responsive design to accommodate all these different devices, but we are still limited in our ability to provide a smooth, user friendly experience without hogging up all of the user’s wireless data. Too much and the site takes forever to load, causing users to simply flee… not enough on the desktop and users may not find it stimulating or useful enough.

Then again, we could create specific sites for every single device, one for the iPhone, one for the iPad, and 10,000 for the different sized and capable Android devices.

So why not join these two concepts? As mobile devices become more prevalent, we won’t be limited to cell phones, tablets, netbooks, and computers. Instead, people will be checking recipes on their refrigerator, local searches in their car, pulling up your site by clicking on your ad on TV, or even visiting your site using a pair of Google glasses.

The simple fact is, we can’t possibly make a one-size-fits-all solution that covers all of these dynamics. Well, maybe we can, but not for heavy content sites or web applications.

But we can streamline the process by utilizing responsive design within our specialized applications. We can develop a phone system that works on the majority of mobile devices, without sacrificing content and without maxing out wireless data.

Overall, the solution(s) depend on what’s best for your users, not what’s most convenient for you or your designers. It becomes an economic question, and while we are quick to jump to the savings, we also have to evaluate and take into consideration the possibility for revenues. Does a mobile friendly site make sense, well, will the benefits of usability increase revenues and customers enough to balance out or outweigh the costs of maintaining it. If so, even if it’s a draw, the user experience is worth it.

Keep in mind that we are in a fascinating time technologically speaking. We have new challenges as more and more users bog down data networks. At the same time, new technologies such as flexible glass are being perfected, and with the increased demand a whole new world of mobile and home technological possibilities.

If we get too stuck in the mobile first mindset, we may find ourselves having just the opposite dilemma. When someone wakes up and their wall lights up, they may find themselves stuck with a 320x480px website blown to fuzzy, unreadable proportions. We have to not only design for today, but with the future in mind. A future that isn’t restricted to mobile only, and in which mobile devices as we know it may become completely obliterated.

And economically, perhaps more important than designing for the future, we need to design for the user. Providing the most convenient solution for them in the present day.

DB::DBAL has been moved to http://dbal.mikestowe.com.

DB::DBAL is a lightweight Database Abstraction Layer that is designed to allow for multiple database types and connections simultaneously. DB::DBAL provides ease of use of use through query chaining, security via automatic where clause escaping, as well as code reusability through the ability to add universal events for table queries (pre/post fetch, insert, update, or save).

An example DB::DBAL MySQL setup and call might look like this:

// Require the DB Class
require_once('classes/DB.php');

// Setup a Connection (saving it is optional and allows you to go back and forth)
DB::MySQL()->connect('localhost','username','password')->saveConnectionAs('default');

// Select Database
DB::MySQL()->db('exampleDatabase');

$result = DB::MySQL()->table('MyTable')->select()->where('column = ?', $data)->fetchOne();
echo $result->name; //name column

DB::DBAL also maps the data to an object and allows for quick data manipulation and saving through the save() method:

$result->name = 'New Name';
$result->save();

Along with mapping and saving the new data, DB::DBAL remembers old data and allows for easy access of data that has been changed through the oldData() and changedData() methods:

var_dump($result->oldData()); // returns an array of Old Data

var_dump($result->changedData()); // returns an array of columns with old and new values
var_dump($result->changedData('name')); // returns the new value of the column name
var_dump($result->changedData('name', 'old'); // returns the old value of the column name

To retrieve the count of selected rows, affected rows, or insert id, DB:DBAL provides the following methods:

$result->count(); // number of rows in query
$result->affectedRows(); // number of rows effected by save/ insert/ update
$result->insertId(); // insert ID if a new record

DB::DBAL also allows for array based data insertion or record updating:

// Update All Records
DB::MySQL()->table('MyTable')->update(array('name' => 'New Name'))->save();

// With Where Clause
DB::MySQL()->table('MyTable')->update(array('name' => 'New Name'))->where('name = ?', 'Old Name')->save();

// Insert Record
DB::MySQL()->table('MyTable')->insert(array('name' => 'New Name'))->save();

DB::DBAL also contains a Models folder in the classes/DB/ folder. Models allow you to create table classes (based on database type, database name, and table name) that will have event methods run on certain actions. For example, you can create a postSave() method in the table class to perform a specific set of actions everytime data is updated or inserted into that specific table. This may mean formatting the data a specific way or porting data to other tables.

For more on models, read the ReadMe.txt file in the Models/ folder.

Installing DB::DBAL
DB::DBAL can be run on any server utilizing PHP 5.3+

Bugs

• No known errors

Awards (Yay) - listed in the order received
We’re working on this… lol

Usage
DB::DABL was released under the GPL version 2 license.

Download

Note – DB::DBAL is in pre-alpha release and is currently being developed. Please feel free to download, test, and commit changes to help improve this application. Future implementations will include MySQLi, other databases, and more caching options. Oh yeah, it will also include documentation – feel free to commit documentation/ doc blox as well!

Checkout a Repository

svn checkout http://...

Update local repository

svn update

Commit all changes in local directory

svn commit -m "message"

Commit specific changes

svn commit -m "message" file1 file2 file3

Revert or Undo Your Changes

svn revert file

List the last 5 revisions

svn log --limit=5

List the last 5 revisions for a specific file

svn log --limit=5 file

Show differences between repositories

svn diff

Show differences for a specific file

svn diff file

Show differences between revisions

svn diff -r revision1:revision2

Show differences between revisions for specific files

svn diff -r revision1:revision2 file1 file2 file3

Show differences compared to last revision

svn diff -c revision

Port Differences to VIM Editor

svn diff | vim -

For example, to build and process a form that contains 8 form elements and 2 content blocks, the code would be as follows:

<?php
require_once('form.php');
$form = new form;

//            SEND FORM TO               SUBJECT
$form->email('email@emailaddress.com','Form Test');

//  FIELD TYPE   DB COLUMN   LABEL     DEFAULT VALUE  REQUIRED  REQUIRED MESSAGE    ADD TEXT     OPTIONS (ARRAY)
$form->content('<h2 style="margin-bottom: 0px;">Welcome to My Form</h2><span style="font-family: arial; font-size: 12px; color: #666;">8 Fields, 2 content blocks... 14 lines of code<br /></span>');
$form->add('text',false,'What\'s Your Name','Bob',true,'Please Fill in Your Name','*');
$form->add('text',false,'What\'s Your Email','',true,'Please Fill in Your Email','*<br /><small><em>note: this script will automatically detect this when sending the email!</em></small>');
$form->add('text',false,'What\'s Your Name','Bob3',false,'Please Fill in Your Name');
$form->add('text',false,'What\'s Your Name','Bob4',false,'Please Fill in Your Name');
$form->add('text',false,'What\'s Your Name','Bob5',false,'Please Fill in Your Name');
$form->add('select',false,'What\'s Your Name','Bob5',false,'Please Select in Your Name','*',array('Mike'=>'Mike','Bob'=>'Bob','John'=>'John','Bob5'=>'Bob5'));
$form->add('radio',false,'What\'s Your Name','Bob5',true,'Please Select in Your Name','*',array('Mike'=>'Mike','Bob'=>'Bob','John'=>'John','Bob5'=>'Bob5'));
$form->add('checkbox',false,'What\'s Your Name','',true,'Please Check Your Name','*',array('Mike'=>'Mike','Bob'=>'Bob','John'=>'John','Bob5'=>'Bob5'));
$form->content('<span style="color: #990000;">By clicking the submit button you are agreeing that this is the coolest form class ever...</span>');
$form->build();
?>

Form Builder automatically adds CSS classes to the form fields, and allows for quick, easy CSS customization to the form as follows:

.form_error { width: 40%; margin: 0px auto; background: #f3f3f3; border: 1px solid #990000; color: #990000; font-weight: bold; padding: 10px;}

.form_success { width: 40%; margin: 0px auto; background: #f3f3f3; border: 1px solid #009900; color: #009900; font-weight: bold; padding: 10px;}

.form_label { width: 150px; float: left; margin-right: 10px;}

.form_field { float: left; }

.form_row { clear: both; border-bottom: 1px dotted #ccc; margin-bottom: 5px; padding-bottom: 5px; }

This results in the following form (note- the form has been submitted to demonstrate required field validation):

Installing Form-Builder
Form Builder can be run on any server utilizing PHP 5+

Bugs

• No known errors

Awards (Yay) - listed in the order received
We’re working on this… lol

Usage
smrtClass was released under the GPL version 2 license.

Download

echo (string) 042;

…

…

…

…

…

…

…

…

…

ANSWER:

34

Because the number starts with a zero, it is interpreted as an Octal number instead of a decimal. This means instead of returning 42 as one might expect, it returns the octal calculation:

0 = signify Octal
4 = 4 x 8 = 32
2 = 2 X 1 = 2
—————-
34

More cool tricks

if('ORANGE' > 'apple') {
    echo 'orange';
} else {
    echo 'apple';
}

…

…

…

…

…

…

ANSWER:

apple

The values are converted based on the ASCII alphabet, in which uppercase letters come before lowercase letters, and thus are assigned a lower value than the lowercase letters. This means that the word ‘apple’ is assigned a higher value than the word ‘ORANGE’ because of the case-sensitivity, making ‘apple’ greater than ‘ORANGE.’ When we change ‘ORANGE’ to lowercase, the otherwise same code would return ‘orange.’

PHP 5.4 is just around the corner, and with it several new features and enhancements.  Here are just a few of the features I’ve had the chance to play with that may be useful.

Binary Integer Notation

Previously in PHP, you were able to write integers as decimals (10), Octals (012), and Hexadecimals (0xA).   Now in PHP 5.4 you can use binary notation for integers by preceding the binary number with “0b” – such as (0b1010).

// Decimal
echo (string) 10; // 10

// Octal
echo (string) 012; // 10

// Hexadecimal
echo (string) 0xA; // 10

// Binary
echo (string) 0b1010; // 10

Session Status

PHP 5.4 introduces a new session function designed to explain the current status of the session. The session_status() function will return the following responses:

PHP_SESSION_DISABLED if sessions are disabled.
PHP_SESSION_NONE if sessions are enabled, but none exists.
PHP_SESSION_ACTIVE if sessions are enabled, and one exists.

For example:

<?php
echo session_status(); // echos PHP_SESSION_NONE
session_start();
echo session_status(); // echos PHP_SESSION_ACTIVE
?>

PHP 5.4 also introduces the SessionHandler class to provide more flexibility and standardization in how sessions are handled.

Arrays

Finally, in PHP you can now use the short bracket syntax for arrays.  While really not a huge deal, this aligns PHP with many of the other programming languages, and will probably make switching from another language just a little easier (although array(1,2,3) is pretty simple).

$oldArray = array(1,2,3);
echo (string) $oldArray[1]; // 2

$newArray = [1,2,3];
echo (string) $newArray[1]; // 2

function getArray()
{
    return array(1,2,3);
    // or return [1,2,3]; in PHP 5.4 ;)
}

// PHP 5.3
echo (string) getArray()[1]; // error

// PHP 5.4
echo (string) getArray()[1]; // 2

Class Instantiation Chaining

Also in PHP 5.4, class instantiation chaining was added, allowing you to chain off of the instantiation of a class by using parentheses.

class Test
{
    public function hello()
    {
        echo 'hello world';
    }
}

// in PHP 5.3 this would be an error
// in PHP 5.4 it echos 'hello world'
echo (new Test())->hello();

Traits

Ok, this is a super simple overview of traits, but the addition of traits provides the flexibility of “extending” multiple classes without having to go through an entire chain.  Unlike many languages, PHP Traits can also contain properties, however, if the class contains a property with the same name it will throw an E_STRICT warning IF the class property === the trait property, or a fatal error if the class property !== the trait property.

To use a trait, you would write something like this:

trait MyTrait()
{
    public $MyProperty = 'hello';

    public function MyMethod()
    {
        echo 'world';
    }
}

class MyClass()
{
    use MyTrait;

    public function DoStuff()
    {
        echo $this->MyProperty;
        echo ' ';
        $this->MyMethod();
    }
}

(new MyClass())->DoStuff(); // echos out 'hello world'

More to Come!

There’s a lot more features in PHP 5.4 that I still need to explore, including PHP Session Uploading, improved Closures, and a built in HTTP server.  So stay tuned and I will try to give a quick overview of those as well as soon as I can get enough time to play with them

Note: Code is based on PHP 5.4 RC 4

..

..

..

..

..

..

..

..

..

..

ANSWER:

True!

In PHP 5.4 Traits may contain properties as long as properties do not exist in the calling class. But beware, if the property already exists PHP will throw an error (fatal if the property isn’t identical to the trait property, and E_STRICT if it is).

trait demo {
    public $demo = 'this is a demo';
    public $test = 'this is a test';

    public function cool() {
        /* this is the method */
    }

    /* ... */
}

Valid

trait testTrait {
    public $demo = 'test';
}

class testClass {
    use testTrait;

    function test() {
        echo $this->demo;
    }

    /* ... */
}

E_STRICT Error

trait testTrait {
    public $demo = 'test';
}

class testClass {
    use testTrait;

    public $demo = 'test';

    /* ... */
}

Fatal Error:

trait testTrait {
    public $demo = 10;
}

class testClass {
    use testTrait;

    public $demo = 'test';

    /* ... */
}

Fatal Error:

trait testTrait {
    public $demo = 'test';
}

class testClass {
use testTrait;

    protected $demo = 'test';

    /* ... */
}

.

PHP Manual:
http://php.net/manual/en/language.oop5.traits.php

smrtClass is designed to provide an added layer of security to PHP applications, and while it does not provide 100% protection, it does signigicantly help to prevent malicious, dangerous, or malformed data from making its way into the applications crucial systems.

smrtClass also contains locking mechanisms to prevent data from being deliberately or accidentally modified.

CLASS METHODS

 
== smrtClass::add ==
smrtClass::add( $var_name, $var_type = ['string'|'int'|'bool'|'object'|'array',|'date'|'datetime'|'timestamp'|'email'|'url'], $value = null );

$test = new smrtClass();
$test->add('number', 'int');
$test->number = '10'; // converted to integer
echo gettype($test->number): // displays "integer"

$test->add('string');
$test->string = 'Hello World'; // set as a string

$test->add('emailAddress', 'email');
$test->emailAddress = 'test@test.com'; // validated to be an email and set as string

== smrtClass::addRegex ==
smrtClass::addRegex( $var_name, $regex, $value = null );

$test = new smrtClass();
$test->addRegex('numberOnly', '/^[0-9]+$/');
$test->numberOnly = 10; // valid
$test->numberOnly = 'ten'; // throws exception

$test->add('alphaOnly', '/^[a-z]$/i');
$test->alphaOnly = 'Hello'; // valid
$test->alphaOnly = 'Hello world'; // throws an exception because of the space

== smrtClass::set ==
smrtClass:set( $var_name, $value )

$test = new smrtClass();
$test->add('name');
$test->set('name', 'Michael');
$test->name = 'Michael'; // does the same thing as set

== smrtClass::remove ==
smrtClass:remove( $var_name )

$test = new smrtClass();
$test->add('name');
$test->name = 'Michael';
$test->remove('name'); // removes the name property
unset($test->name); // does the same thing as remove

== smrtClass::listTypes ==
smrtClass::listTypes()

returns an array of supported types such as string, int, bool, etc.

$test = new smrtClass();
$test->listTypes();

Installing smrtClass
smrtClass can be run on any server utilizing PHP 5.3

Coding Restrictions

1. smrtClass is limited to the same property naming restrictions as stdClass
2. smrtClass currently does not allow for data types to be changed

Bugs

• No known errors

Awards (Yay) - listed in the order received
We’re working on this… lol

Usage
smrtClass was released under the GPL version 2 license.

Download