In conjunction of my previews post, that you can find [here](/blog/you-hate-wordpress-this-can-reunite-you), we will see how to simplifying plugins and themes developments using a framework and a template engine.

## Developing plugins with Herbert

[Herbert](http://getherbert.com) is a WordPress plugin framework that provides a structured and standardized approach to building plugins. The framework aims to keep business logic separate from template code, so that back- and frontend developers aren’t tripping over each other. Herbert utilizes Composer to handle the framework’s dependencies. Template code is stored in views, which uses the Twig PHP templating engine.

### How to?

The complete guide is available in the official website at the next page:

> [Getting Started](http://getherbert.com/0.9)

## Theming with Twig And Timber

WordPress is a great platform, and it’s as versatile as a platform can be. Proof of that is that it currently powers more than 23% of the internet as we know it. Historically though that has not always been the case and there’s one thing that made WordPress stand out: **Themes**.

The WordPress theming industry is pretty large and everyday we see new businesses pop-up, offering their own themes. The choices are practically limitless, and you can find whatever you need.

One of WordPress’s strong points is also -in my opinion- its weakest point. WordPress uses old and deprecated PHP stuff, and a mixing of PHP/HTML for is themes.

Some CMSs in order to address that problem has decided to make things a bit better for their developers and use and MVC approach to separate data and view models, using a real templating language for their templates.

By examples, [Drupal](https://www.drupal.org) and [Laravel](http://laravel.com) both work with [Symphony](http://symfony.com), which in turn utilizes the [twig templating engine](http://twig.sensiolabs.org).

### Installing Timber

Let's now see how to install Timber using our `composer.json` file from my previous post. The only things you need to do, is to require the `timber-library` using the next command line:

~~~shell script
composer require wpackagist-plugin/timber-library
~~~

### How to?

Without create another post about using Twig into WordPress, I prefer refer to you this great article explaining everything your need to know:

> [Simplify Your WordPress Theming With Twig And Timber](https://premium.wpmudev.org/blog/simplify-your-wordpress-theming-with-twig-and-timber/)

### Bonus: Debug bar

The team being **Timber** plugin has also developed a `Debug Bar` using the [WordPress Debug Bar](https://wordpress.org/plugins/debug-bar/) . Once installed, the Timber Debug Bar gives you access to the current template name, its absolute location on your server and the full contents of the context (array) sent to the template.

To install the **Timber Debug Bar**, execute the next commands:

~~~shell script
composer require wpackagist-plugin/debug-bar↵composer require wpackagist-plugin/debug-bar-timber
~~~

WordPress: Simplifying plugins and themes developments

WordPress and the love of developers!
-------------------------------------

Everyone knows WordPress, and everyone knows that developing with WordPress is a pain is the ass ( If not, I can't do anything for you :( ).

The most common answer about people loving WordPress so much is: **extensibility**.

From the past years WordPress provides a lot of themes and plugins and this is why people will choose WordPress compared to other CMS.

However, WordPress as a big dark sides for developers, it uses old and deprecated stuff, do not use a template engine for rendering views, and so on about many things...

It's 2016, why not using new features?
--------------------------------------

Let's now see how we can integrate in WordPress some cool stuff, already used by many developers.

### Composer

[Composer](http://getcomposer.org) is a dependency manager for PHP that has been gaining steam lately. Your first question is most likely `what is a dependency manager and why do I need one?`. Almost any code you write probably ends up depending on 3rd party libraries. All of these libraries (projects, frameworks, files, etc) become **dependencies** of your project. Composer lets you declare the dependencies for a project, and it will install and manage them.

#### 1\. Installing composer

Installing Composer is pretty simple with one caveat: **It requires PHP 5.3** to run. Follow the [instructions](http://getcomposer.org/doc/00-intro.md#installation-nix) for either \*nix, OSX or Windows.

I suggest installing Composer globally and then you can just use the `composer` command from anywhere.

#### 2\. Project Setup

To start using Composer in your project, all you need is a `composer.json` file.

This file describes the dependencies of your project and may contain other metadata as well.

In this example bellow, we will add some optional metadata to name properly your WordPress application:

1.  your WordPress app name
2.  a WordPress app description
3.  finally, some information about yourself

~~~json
{
    "name": "davidsanchez/sources",
    "description": "Package to build WordPress sources for davidsanchez.me",
    "authors": [
        {
            "name": "David Sanchez",
            "email": "david38sanchez@gmail.com"
        }
    ]
}
~~~

### Integrating with WordPress

We are now ready to see how to use Composer with WordPress. When you think about a typical WP site, the easiest example of dependencies are plugins. But there’s something more fundamental to realize: **WordPress itself is a dependency**.

If we think about it, we’re creating a site, or application, that depends on WordPress. The WordPress core is a 3rd party library that is required for your application to work. This is difficult to understand at first due to how WordPress sites are usually structured.

The best solution right now is to use a **fork** of WordPress with a already added `composer.json` file.

[https://github.com/johnpbloch/wordpress](https://github.com/johnpbloch/wordpress) is currently the most popular/accepted package.

It’s simply an auto-updating fork (syncs every 15 minutes with the official WP repo) that includes `composer.json` **wordpress-core-installer** package. You can view it [here](https://github.com/johnpbloch/wordpress/blob/master/composer.json/).

Under, your `authors` metadata, we will add the next lines to require WordPress core:

~~~json
{
    "require": {
        "johnpbloch/wordpress": "~4.5"
    },
    "extra": {
        "wordpress-install-dir": "wp"
    }
}
~~~

That’s it.

We just require `johnpbloch/wordpress` with the version of WordPress that we want and then tell Composer we want WordPress installed to `wp`.

### WordPress Packagist

Fortunately, the awesome people at [Outlandish](http://outlandish.com/) have created a repository of WordPress plugins called [WordPress Packagist](http://wpackagist.org).

Basically, they mirror every WordPress plugin and add a `composer.json` file that requires `composer-installers` and sets their package type to `wordpress-plugin` or `wordpress-theme`.

Their instructions are simple too:

1.  Add the repository to your `composer.json`
2.  Add the desired plugins and themes to your requirements using `wpackagist-plugin` or `wpackagist-theme` as the vendor name.
3.  Run `composer update`
4.  Plugins and themes are installed in `wp-content/plugins/` and `wp-content/themes/`

So, we will now add the require metadata to tell Composer to get the WordPress plugins and themes from the [WordPress Packagist](http://wpackagist.org):

~~~json
{
    "repositories": [
        {
            "type": "composer",
            "url": "https://wpackagist.org"
        }
    ],
    "extra": {
        "installer-paths": {
            "content/mu-plugins/{$name}/": [
                "type:wordpress-muplugin"
            ],
            "content/plugins/{$name}/": [
                "type:wordpress-plugin"
            ],
            "content/themes/{$name}/": [
                "type:wordpress-theme"
            ]
        }
    }
}
~~~

After that, you will be able to go to the [WordPress Packagist](http://wpackagist.org) and add your WordPress plugins and themes into your `composer.json` file.

### Restructuring WordPress

Like we said before, with Composer WordPress will be a depency, this is why people choose to put the WordPress's core into a directory named `wp/`.

No matter which direction you choose when installing WordPress in a subdirectory there is a certain amount of restructuring that needs to be done to make it work. Mainly three things need changed:

1.  WordPress needs to be bootstrapped from the new location using an `index.php` file
2.  The `wp-content` folder will only contain the default plugins and themes from WordPress
3.  Any environment/config files (e.g. `.htaccess`/`wp-config.php`) also need to be in the root path

So our directory structure should now look something like this:

~~~text
/
|
|-- wp-content/
|-- wp/    <-- Our directory install location for WordPress (not stored in Git repo)
|-- .htaccess
|-- index.php
|-- wp-config.php
|-- .gitignore
|-- composer.json    <-- If using Composer
`-- local-config.sample.php
~~~

#### Bootstrap index.php

This part is relatively simple. We’re going to install WordPress into the `wp` subdirectory, so we need to tell our webserver where to find WordPress. As everything is routed through the main `index.php` file (see `.htaccess`) we can simply create a bootstrap `index.php` file with the following contents:

~~~php
<?php
// WordPress bootstrap
define('WP_USE_THEMES', true);
require __DIR__ . DIRECTORY_SEPARATOR . 'wp/wp-blog-header.php';
~~~

#### Environment config

You’ll notice the `local-config.sample.php` file in the root directory above. While this is not technically necessary it’s a good idea to split up environment-specific config information (such as database credentials and secret keys) from the “global” config information stored in `wp-config.php` (such as the table prefix and the wp-content location).

The idea here is that the `wp-config.php` file will hold any “global” config information and then load the correct “environment” config file as required. So for your production site you can deploy a `production-config.php` file which can be loaded by `wp-config.php` if it exists (we don’t store it in the Git repo though for security purposes) and if `production-config.php` doesn’t exist fall back to `local-config.php` which assumes you are working on a local development environment.

The content of our new `wp-config.php` file should look like:

~~~php
<?php
// ===================================================
// Load database info and local development parameters
// ===================================================
if (file_exists(__DIR__ . DIRECTORY_SEPARATOR . 'production-config.php')) {
    define('WP_LOCAL_DEV', false);
    include __DIR__ . DIRECTORY_SEPARATOR . 'production-config.php';
}
else {
    define('WP_LOCAL_DEV', true);
    include __DIR__ . DIRECTORY_SEPARATOR . 'local-config.php';
}

// ========================
// Custom Content Directory
// ========================
define('WP_CONTENT_DIR', __DIR__ . DIRECTORY_SEPARATOR . 'content');
define('WP_CONTENT_URL', 'http://' . $_SERVER['HTTP_HOST'] . '/content');

// ================================
// Language
// Leave blank for American English
// ================================
define('WPLANG', '');

// =========================
// Disable automatic updates
// =========================
define('AUTOMATIC_UPDATER_DISABLED', false);

// =======================
// Load WordPress Settings
// =======================
$table_prefix = TABLE_PREFIX;

if (!defined('ABSPATH')) {
    define('ABSPATH', __DIR__ . DIRECTORY_SEPARATOR . 'wp' . DIRECTORY_SEPARATOR);
}
require ABSPATH . 'wp-settings.php';
~~~

#### Sample config

You will need to rename the `local-config.sample.php` to `local-config.php` to use it. It should look something like this:

~~~php
<?php
/** The name of the database for WordPress */
define('DB_NAME', 'local_db_name');

/** MySQL database username */
define('DB_USER', 'local_db_user');

/** MySQL database password */
define('DB_PASSWORD', 'local_db_password');

/** MySQL hostname */
define('DB_HOST', 'localhost'); // Probably 'localhost'

/** Database Charset to use in creating database tables. */
define('DB_CHARSET', 'utf8mb4');

/** The Database Collate type. Don't change this if in doubt. */
define('DB_COLLATE', '');

/** The Database tables prefix */
define('TABLE_PREFIX', 'wp_');

/**
 * https://codex.wordpress.org/Editing_wp-config.php#Debug
 */
define('WP_DEBUG_DISPLAY', true);
define('WP_DEBUG', true);

/**
 * Salts, for security
 * https://codex.wordpress.org/Editing_wp-config.php#Security_Keys
 */
define('AUTH_KEY', 'put your unique phrase here');
define('SECURE_AUTH_KEY', 'put your unique phrase here');
define('LOGGED_IN_KEY', 'put your unique phrase here');
define('NONCE_KEY', 'put your unique phrase here');
define('AUTH_SALT', 'put your unique phrase here');
define('SECURE_AUTH_SALT', 'put your unique phrase here');
define('LOGGED_IN_SALT', 'put your unique phrase here');
define('NONCE_SALT', 'put your unique phrase here');

/**
 * https://codex.wordpress.org/Editing_wp-config.php#WordPress_Upgrade_Constants
 */
define('FS_METHOD', 'direct');
~~~

### Install WordPress using Composer

Now that we have our working `composer.json` file, let’s actually install WordPress and his dependencies by running `composer install` in a terminal.

You hate WordPress? This can reunite you!

#### Deprecation

Without creating an article to install PHP7, I prefer to share with you this great post: [How to Install PHP 7.0, Apache 2.4.17, & MySQL 5.6 on Ubuntu 15.10 & 14](http://tecadmin.net/install-php-7-0-apache-2-4-mysql-5-6-on-ubuntu/).

So, the following information in my article bellow are now deprecated and was only effective to the nightly version of PHP7.

Preamble
--------

~~~shell script
sudo nano /etc/apt/sources.list
deb http://archive.ubuntu.com/ubuntu jessie main
aptitude update
~~~

Using early access repo
-----------------------

Add Zends PHP7 early access repo:

~~~shell script
echo "deb http://repos.zend.com/zend-server/early-access/php7/repos ubuntu/" >> /etc/apt/sources.list
~~~

To install PHP7 nighly build:

~~~shell script
apt-get update && apt-get install php7-nightly
~~~

Installing Apache 2.4
---------------------

~~~shell script
aptitude install apache2 apache2-mpm-worker libapache2-mod-fastcgi
~~~

Then create the file `/etc/apache2/conf-available/php7-fpm.conf` with the contents:

~~~apacheconfig
<IfModule mod_fastcgi.c>
    AddHandler php7-fcgi .php
    Action php7-fcgi /php7-fcgi
    Alias /php7-fcgi /usr/lib/cgi-bin/php7-fcgi
    FastCgiExternalServer /usr/lib/cgi-bin/php7-fcgi -socket /var/run/php7-fpm.sock -pass-header Authorization
</IfModule>
~~~

Then enable the new mods and config:

~~~shell script
a2enmod actions fastcgi alias
a2enconf php7-fpm
a2dismod mpm_event
a2enmod mpm_prefork
service apache2 reload
~~~

Install of MySQL
----------------

~~~shell script
aptitude install mysql-server mysql-client
~~~

Build and configure PHP7
------------------------

To get, build and install PHP7 from sources, you will need some tools to be installed in your linux. Use the next command to install the needed tools:

~~~shell script
aptitude install git make autoconf build-essential libt1-dev libgmp-dev bison re2c libxml2-dev libcurl4-openssl-dev libssl-dev libsslcommon2-dev libbz2-dev libjpeg-dev libfreetype6-dev libmcrypt-dev libmysqlclient-dev libaspell-dev
~~~

Create a temporary directory:

~~~shell script
mkdir ~/tmp
cd ~/tmp
~~~

Clone sources from git repository:

~~~shell script
git clone https://git.php.net/repository/php-src.git
~~~

You can now build and configure your env

~~~shell script
cd php-src
./buildconf
./configure \
    --prefix=/usr/local/php7 \
    --with-config-file-path=/usr/local/etc/php7 \
    --localstatedir=/usr/local/var \
    --sysconfdir=/usr/local/etc/php7 \
    --enable-mbstring \
    --enable-zip \
    --enable-bcmath \
    --enable-pcntl \
    --enable-ftp \
    --enable-exif \
    --enable-calendar \
    --enable-sysvmsg \
    --enable-sysvsem \
    --enable-sysvshm \
    --enable-wddx \
    --with-curl \
    --with-mcrypt \
    --with-iconv \
    --with-gmp \
    --with-pspell \
    --with-gd \
    --with-jpeg-dir=/usr \
    --with-png-dir=/usr \
    --with-zlib-dir=/usr \
    --with-xpm-dir=/usr \
    --with-freetype-dir=/usr \
    --with-t1lib=/usr \
    --enable-gd-native-ttf \
    --enable-gd-jis-conv \
    --with-openssl \
    --with-mysql=/usr \
    --with-pdo-mysql=/usr \
    --with-pgsql=/usr \
    --with-pdo-pgsql=/usr \
    --with-firebird=/usr \
    --with-pdo-firebird=/usr \
    --with-pdo-odbc=unixODBC,/usr/ \
    --with-oci8=instantclient,/usr/lib/oracle/12.1/client64/lib \
    --with-pdo-oci=instantclient,/usr,12.1 \
    --with-interbase=/usr \
    --with-gettext=/usr \
    --with-zlib=/usr \
    --with-bz2=/usr \
    --with-recode=/usr \
    --with-mysqli=/usr/bin/mysql_config
~~~

You can now make and install sources

~~~shell script
make
make test
sudo make install
~~~

We now need to create a symlink:

~~~shell script
sudo ln -sf /usr/local/php7/bin/php /usr/bin/php
~~~

add to /etc/apache2/sites-enabled/000-default.conf or other vhost conf file:

~~~apacheconfig
AddType application/x-httpd-php .php .phtml
~~~

### php.ini

~~~shell script
cd /usr/local/etc/php7
sudo nano php.ini
~~~

paste the code:

~~~ini
max_execution_time=600
memory_limit=128M
error_reporting=1
display_errors=1
log_errors=1
user_ini.filename=
realpath_cache_size=2M
cgi.check_shebang_line=0

zend_extension=opcache.so
opcache.enable_cli=1
opcache.save_comments=1
opcache.fast_shutdown=1
opcache.validate_timestamps=1
opcache.revalidate_freq=60
opcache.use_cwd=1
opcache.max_accelerated_files=100000
opcache.max_wasted_percentage=5
opcache.memory_consumption=128
opcache.consistency_checks=0
~~~

Common errors
-------------

### Unable to locate gmp.h

~~~shell script
ln -s /usr/include/x86_64-linux-gnu/gmp.h /usr/include/gmp.h
~~~

### libfbclient, libgds or libib\_util not found!

~~~shell script
aptitude install firebird2.5-dev
~~~

### Cannot find header file(s) for pdo\_odbc

~~~shell script
aptitude install unixodbc-dev unixodbc-bin unixodbc
~~~

### Cannot find libpq-fe.h. Please specify correct PostgreSQL installation path

~~~shell script
aptitude install libpq-dev
~~~

How to install PHP7 nightly on Linux

Dwoo is a PHP5 oriented object template engine who was started in early 2008.

Since I took over this unmaintained project 2 years ago, I put online a new website and focus on a 2.x version without having the success I expected in my development, by lack of time.

After a while of inactivity and accumulation of issues, it’s now time to get this project back-on-tracks!

The first step was to put online a complete official website redesigned, including the full documentation of Dwoo. Like a lot of people asked me before, documentation of the branch **1.x** is now back on the documentation section.

For now, I can’t say much about development in the near future, I can just affirm that:

*   Dwoo 1.x will no more evolving, this version is still **UNMAINTAINED**
*   Dwoo 2.x is still in beta and will stay like that!
*   IF I start to work again on this project sources, I will go directly for a **Dwoo 3.x** supported only by **PHP7**.

I will inform you about that in this blog in the beginning of 2016!

Dwoo.org is looking better!

GitHub is a popular web-based Git repository hosting service, which offers all of the distributed revision control and source code management functionality of Git as well as adding its own features.

Since may 2013, GitHub announced [Octokit](http://octokit.github.io), a new lineup of GitHub-maintained client libraries for the GitHub API. This means Octokit provide officially 3 libraries written in **Ruby**, **Objective-C** and **.NET**.

However, third-party libraries are available in other languages and particularly in PHP. At this time you can find at least 9 libraries to interact with GitHub API in PHP but none of this libraries provide a full support for all GitHub API features.

This library as been developed to help you to use all the features of GitHub API v3 easily as possible. This library, like the GitHub API is sparate in 2 distinct parts:

1.  The **Client** part who will be used to get informations about a repository, a user, a commit, …
2.  The **Server** part, called **WebHooks** that can be used to get events from GitHub API

Features
--------

This library provide the next features:

*   Supports all methods (**Activity**, **Enterprise**, **Gists**, **Git Data**, **Issues**, **Miscellaneous**, **Organizations**, **Pull Requests**, **Repositories**, **Search**, **Users**)
*   Supports **Basic**, **OAuth** and **OAuth2** authentications.
*   Able to create a **WebHooks** server.

Minimum requirements
--------------------

To run this library in your web server, you’ll need the most recent PHP version of the branch 5.6.x. for some security and dependencies reasons.

> This library is only compatible with PHP 5.6.1 or above. So please upgrade your PHP version if you have a lower version installed.

You will also need the [cURL](http://php.net/manual/en/book.curl.php) extension enabled in your web server.

### Dependencies

This library use some dependencies to work with.

Here are the dependencies this library need to be installed with:

*   [Scion/DesignPatterns](https://github.com/Scion-Framework/DesignPatterns)
*   [Scion/Cryptography](https://github.com/Scion-Framework/Crypt)
*   [Scion/File](https://github.com/Scion-Framework/File)
*   [Scion/Http](https://github.com/Scion-Framework/Http)
*   [Scion/Stdlib](https://github.com/Scion-Framework/Stdlib)
*   [Scion/Utils](https://github.com/Scion-Framework/Utils)
*   [Scion/Validator](https://github.com/Scion-Framework/Validator)

Installation
------------

To get the latest version of this **GitHub API library** simply use composer.

1.  You need to add this library to `composer.json` file:

~~~shell script
$ php composer.phar require scion/githubapi
~~~

1.  Then you can install this library and all the dependencies using:

~~~shell script
$ php composer.phar install
~~~

Client
------

~~~php
<?php
// This file is generated by Composer
require 'vendor/autoload.php';

// Create a Client object
$client = new \Scion\GitHub\Client();
~~~

WebHook
-------

Webhooks allow you to build or set up integrations which subscribe to certain events on GitHub.com.

Complete documentation is available at [https://developer.github.com/webhooks/](https://developer.github.com/webhooks/).

For using a WebHook, you need an instance of `Scion\GitHub\WebHook` class like:

~~~php
<?php
// This file is generated by Composer
require 'vendor/autoload.php';

// Creating WebHook instance
$webhook = new \Scion\GitHub\WebHook();
~~~

Authentication
--------------

This library supports all authentications provided by the GitHub API v3. You can use the **Basic Authentication**, **OAuth Token** or the **OAuth2 Key/Secret pair** authentication for the **Client** and **WebHook** classes, like described here:

### Basic Authentication

~~~php
// Username only
$client->setHttpAuth('username');

// Username & password
$client->setHttpAuth('username', 'password');
~~~

### OAuth Token

Go to [Authorized applications](https://github.com/settings/applications) to `Generate new token`, then you will be able to provide your 'token'.

~~~php
// sent in userpwd
$client->setToken('xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx');

// sent in a header
$client->setToken('xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx', \Scion\Github\Client::OAUTH2_HEADER_AUTH);

// sent as a parameter
$client->setToken('xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx', \Scion\Github\Client::OAUTH2_PARAMETERS_AUTH);
~~~

### OAuth2 Key/Secret pair

Go to [Authorized applications](https://github.com/settings/applications) to `Register new application`, then you will be able to provide yours `client_id` and `client_secret`.

~~~php
$client->setClientId(''); // Set client_id
$client->setClientSecret(''); // Set client_secret
~~~

> You can find the full documentation of this library in the [wiki section](https://github.com/Scion-Framework/GitHubAPI/wiki) of the GitHub repository.

A complete PHP library for GitHub API v3

Introduction to PHP7

As you can see, my website had a new design, this is due because I moved from France to Montréal, Canada.

Searching a job as a PHP developer and/or Web integrator, I needed a new website more Web2.0 and where recruiters can see all my work.

A new design for a new start...

Scion-Framework is a complete open-source framework designed to optimize the development of web applications by way of several key features. For starters, it separates a web application in parts using MVC design pattern with a 100% object-oriented code.

It contains numerous tools and classes aimed at shortening the development time of a complex web application. The end result of these advantages means there is no need to reinvent the wheel every time a new web application is built!

Scion-Framework is written entirely in PHP and compatible with PHP 5.5. It is compatible with more than 10 relational database management system including MySQL, PostgreSQL, SQLite, and more. It runs on Unix and Windows platforms.

Scion-Framework was built in order to fulfill the following requirements:

*   Easy to install and configure on most platforms (and guaranteed to work on standard Unix and Windows platforms),
*   Compatible with all PDO DBMS,
*   Simple to use, in most cases, but still flexible enough to adapt to complex cases,
*   Compliant with most web best practices and design patterns,
*   Very readable code, with comments, for easy maintenance,
*   Including the last features of the latest PHP version,
*   Include a Wizard to create easily a new project.

To know more about Scion-Framework, you can go to the official documentation here, still in writing.

Why using Scion-Framework?
--------------------------

PHP is a very easy to use programming language, that's the reason why it's loved by the web development community. It's easy to use nature and learning curve has attracted a lot of users. But PHP has one downside. Most experienced developers don't love coding PHP due to its little object orientation, and its often nasty codes. With Scion-Framework, any PHP developer from beginner to expert will all get to write standard codes which we see in the Java or the .NET worlds.

So the major reason why you should use Scion-Framework for your PHP work is to ensure that your codes are of standards, and you follow the best practices which go a long way to help teams of developers from beginners to experts to easily work together with the PHP programming language.

Scion-Framework solves the problem of beginners, and intermediate developers who have nasty codes and are killing the overall work of the team. With the well documented and standard practices of Scion, a developer in France can write the code and a developer in Australia can optimize the code without asking a lot of questions, because everything will clearly be a model, view or a controller, and it will be easy to understand what it was meant for exactly.

Key features of Scion-Framework
-------------------------------

Scion-Framework has some very good latest PHP features that makes it stand out from all other PHP frameworks. The features include:

*   **Fully Object Oriented:** Object oriented programming is an industry standard since the introduction of C++. Many developers working with Java programming languages are comfortable with Object and classes, and they prefer the order it brings to programming. Scion-Framework being fully Object oriented, it automatically brings this order and industry standard programming to PHP witch is really helpful.
*   **MVC:** this framework is engineering with the well-known software design pattern Model View Controller (MVC). The Model View Controller software design pattern guides engineers to design their software codes into three separate parts which includes:
*   **Models:** The objects that manipulate data sources and data stores,
*   **Views:** The HTML and CSS files with inline PHP codes that present the user interface and controls to the application users,
*   **Controllers:** Objects in charge of the business logic, displaying the page (views), and routing the click actions from the views to the model and back to the views.
*   **In built templating:** Scion-Framework like most other standard web frameworks has a very easy to use template engine. Like Symfony, Scion embedded is own template engine for greater ease of use and compatibility. The new version of Dwoo, the Smarty compatibility template engine is embedded.
*   **Robust RDBMS:** RDBMS stands for Relational DataBase Management System. Using PDO to connect to the database drivers, Scion-Framework include a powerful DBMS witch is compatible with almost everyone database drivers such as PDO.
*   **Powerful routing system:** Scion-Framework provide a json-based routing system config file because it's easy to edit a json file and it's faster to load a json file than an ini or a yaml. This routing system include powerful features likes: regex, methods, output format and wildcard. All features are available [here](https://github.com/emulienfou/Scion-Framework/wiki/The%20Basics).
*   **Traits inheritance:** A new feature introduced in PHP 5.4 to overcome such issues, traits is a mechanism for code reuse in single inheritance languages such as PHP. A Trait is intended to reduce some limitations of single inheritance by enabling a developer to reuse sets of methods freely in several independent classes living in different class hierarchies. Traits are used in Scion-Framework inside the MVC pattern.
*   **Namespaces:** since PHP 5.3, namespaces are used in all most popular PHP frameworks. Namespaces remove the need for long, PEAR-style class names (e.g. Middleware\_ContentTypes) while still avoiding class name collisions with other libraries.

License
-------

Scion-Framework is licensed under GNU Lesser GPL v3 and is free to use in Open Source and closed commercial projects.

Introduction to Scion-Framework

I’m delighted to launch my new portfolio website and blog! This site will be a home for all my freelance and professional development works, and a space to share thoughts, ideas and works in progress through this blog.

As you can see, it has received a complete redesign. Now built on my own scripts (framework and CMS), my new website now features blog posts, a twitter feed and more updates to my portfolio content.

Finally take a look at the portfolio pages. I’ll be posting more portfolio work over the coming weeks.

Welcome to my new design website!

Dwoo changes ownership, this made the website design was restylized.

In this new version of the official website of Dwoo you would find complete documentation for developers as well as designers. But also a forum to ask all your questions to ask for help, new features, to report a bug or just to discuss about Dwoo.

There is also a FAQ that will answer the most frequently asked questions. A list of features that offers Dwoo is also available for the end you have at your disposal a benchmark for evaluating the performance of Dwoo compared to its various competitors (such as Smarty, …).

Finally, you will find in this blog different announcements from the site but also in relation to the outputs of new versions.