I worked on a project where I wrote this code. The class below eats up to 2536 bytes of memory, but make sure to read this whole post for the surprise!

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

class array_to_object
{
    function __construct($data=null, &$node=null)
    {
        foreach ( $data as $key => $value )
        {
            if ( is_array($value) )
            {
                if (! $node )
                {
                    $node =& $this;
                }
 
                $node->$key = new stdClass();
                self::__construct($value,$node->$key);
            }
            else
            {
                if (! $node )
                {
                    $node =& $this;
                }
 
                $node->$key = $value;
            }
        }
    }
}

The code above creates a new stdClass, PHP’s built-in class and uses it to create properties out of the array’s keys inside the object.

Basically, this $arr['hello'] = ‘world!’; becomes this $arr->hello = ‘world!’;

Now, here comes the surprise!

Hardcore one liner

1
2
3
4

function array2obj($data) 
{
    return is_array($data) ? (object) array_map(__FUNCTION__,$data) : $data;
}

The function above does the same thing, except it uses 72 bytes of memory and it’s much more optimized!

Related posts:

1. How to Inherit from Multiple Objects (Workaround)

As of Aug 4th, there have been 192 reports of a problem with security patch VS90SP1-KB971092-x86.exe, whereby if C++ components were not installed with Visual Studio, the security patch will fail with the message “VC Libraries QFE Patch does not apply, or is blocked by another condition on your system.”

To report the problem and to find a suggested workaround please go to:

• KB971092 won’t install

Microsoft Connect have posted the following concerning this fix: “We are rerouting this issue to the appropriate group within the Visual Studio Product Team for triage and resolution. These specialized experts will follow-up with your issue.” However as of 4 August, no follow-up has been posted.

Editing HTML with Microsoft Expression Web 3

As an experiment, I am editing this entry with Expression Web 3. Whilst if does lacks the folding editor feature of Visual Studio 2008, it is a capable editor. It does have a good spell-checker, something is missing from VS2008. Whilst Expression Web now has source control, it is only to Team Server.

An alternative reader for PDFs

I am trying out an alternative PDF reader from Foxit, one of many compact and fast alternatives now available to Acrobat. Why not Acrobat to read PDFs? Acrobat does not provide a simple download, but requires a boot-strapper.

• http://www.foxitsoftware.com/downloads/index.php

NUnit 2.5.1

NUnit 2.5.1 has now been released. In the new future, I will be upgrading my projects to use it. More about it next time.

• http://www.nunit.org/index.php?p=download

1. Expresso

This allows the development, analysis and testing of regular expressions. It also provides a useful library of expressions. Before pasting a regular expression into your code, you should test them. It needs free registration to use beyond the trial period.

• License
• Download

2. NUnit

"NUnit is a unit-testing framework for all .Net languages. Initially ported from JUnit, the current production release, version 2.5, is the sixth major release of this xUnit based unit testing tool for Microsoft .NET. It is written entirely in C# and has been completely redesigned to take advantage of many .NET language features, for example custom attributes and other reflection related capabilities."

Why should you unit test? Unit testing allows you to test your code against known values and check its performance. Once written, unit tests can be run whenever required and never require a mug of coffee to keep them awake. If there is any concern about a given situation, you can set up a unit test to reproduce that scenario and check that the code behaves as expected.

The bottom line however is that a high code coverage set of unit tests allow you to sleep well at night!

• License
• Download

3. Programmers File Editor

Programmers File Editor is a simple multi-window text editor. Virtually any editor is better than Notepad and PFE wins not just be being able to editor view more than one file at once but you can write macros in it. It also the highly unusual feature of being able to run DOS command and capture the output.

• License
• Download

4. Component One Intellispell Community Edition

This Add-on for Visual Studio allows spell-checking of your HTML and other program files, albeit one file at a time.

• License
• Download

5. GhostDoc

This is an Add-on for Visual Studio 2005 and 2008 (2010 is supported in the latest). It allows you to create skeleton XML documentation with just a few blanks for you to fill in.

• License
• Download

6. Microsoft FxCop 1.36

FxCop is a Microsoft tool for static checking of compiled code. Whilst at times it just nags over trivial points, even one of the more serious problems left unfixed can cause problems in production that may not apparent during testing. For example a missing dispose can give rise to problems during intensive use of an application.

• License
• Download

7. Microsoft Source Analysis for C# a.k.a. StyleCop

Style Cop provides a source checker for C# that complements FXCOP. Whilst some of its rules requiring extraneous blank lines are best turned off, it does provide a valuable check of source code. It fails to find xml file headers if in a region. FxCop and StyleCop are both good servants but poor masters as they will both find problems but it requires the skill of the programmer to determine if a fix is required or if the warning should be ignored.

• License
• Download

8. Secunia Personal Software Inspector

Like Windows Update, it scans the software on your machine, but this warns not just about some windows programs but about many other programs such as Firefox and Microsoft Office.

This item is free only for personal and not commercial use.

• License
• Download

Related posts:

1. Useful tools on CodePlex and elsewhere

Codeplex is an open source projects hosting website. You can create, share, contribute an use the projects hosted on the website and even provide feedback.

1. Sandcastle Documentation Compiler for Dot Net Libraries

Sandcastle produces help files in a number of formats from XML comments in C# or VB.NET projects. If you unfamiliar with the syntax of XML comments, please see jelle.druyts.net/2005/01/16/XMLCommentsQuickReference.aspx

To set it up you need the next project on my list.

• License
• Download

2. Sandcastle Help File Builder

The help file builder provides a GUI interface to setup and compile Sandcastle help file projects.

• License
• Download

3. HTML Agility Pack

This provides tools for programmatically fetching HTML pages and extracting information from them.

• License
• Download

4. HTML Text Writer 2

This utility program allow you to convert HTML into C# or VB.NET code to emit the HTML. This is a first step to writing a custom control where the nature of the HTML to be produced cannot be done by the built-in controls. This application is purposely licensed LGPL to allow both Commercial and Non-Commercial use.

• License
• Download

5. Common Data

This provides a series of components for building ASP.NET web sites covering such functions as hashing password, encrypting, decrypting and filtering user input. Much of it is available in both C# and VB.NET. This application is purposely licensed LGPL to allow both Commercial and Non-Commercial use.

• License
• Download

6. XHTML Fixes

This provides a demonstration of some simple fixes to achieve XHTML compliance as measured by the W3C tests at validator.w3.org. This application is purposely licensed LGPL to allow both Commercial and Non-Commercial use.

• License
• Download

7. Postscript – CodeBurner for Firefox

This free add-on for Firefox from SitePoint allows lookup of HTML elements and how they are supported across browsers. The SitePoint Site states: "The license that comes with it is about how you can redistribute the extension, not how you can use it yourself. Once you’ve installed it in Firefox you can use it however you want – there’s no restriction on what kind of projects you can use it with."

• License
• Download

Related posts:

1. 8 More Useful Tools for ASP.NET

Related posts:

1. PHP 5.3

So let’s create a virtual development environment using the latest software bundles.

With the help of this tutorial you will install the following softwares:

• VirtualBox
• Apache 2.2.x
• MySQL 5.0
• Ubuntu 9.04 as the guest OS
• …and of course PHP 5.3

1. Install VirtualBox

I prefer VirtualBox from Sun mainly, because it’s free and it’s easy to work with. You can use another virtualization product such as VMWare or Parallels for Mac OS X.

If you want to go with VirtualBox then download it from the link above or from this link. I happen to have it already installed on my Mac, so I won’t go into details.

2. Download Ubuntu

This step is pretty straightforward. Download the ISO image from this direct link.

3. Setup Ubuntu in VirtualBox

Once downloaded you have to add the ISO file as a CD/DVD image in Virtualbox. Open the Virtual Media Manager (File->Virtual Media Manager) window, open the CD/DVD Images tab and click Add

Once this is ready, we have to create a new virtual machine to load it successfully. Go to the main VirtualBox window and select New. Name it to Ubuntu PHP 5.3 and select Linux for operating system and Ubuntu for the version.

Next, select at least 512 MB base memory size.

On the next window make sure you select the Create new hard disk option.

Once finished, mount the Ubuntu ISO by going to the settings page of the virtual machine, selecting Storage -> CD/DVD-ROM tab. On this window check Mount CD/DVD Drive and select the ISO image file.

Finally, start the virtual machine.

4. Install Ubuntu inside the virtual machine

I will show you a quick overview of the installation process.

Once finished installing the OS make sure you shut it down and unmount the ISO image.

5. Install Apache and MySQL

Thanks to Brandon Savage for writing a tutorial on installing and compiling Apache, MySQL and PHP 5.3 on Ubuntu. I will take the steps from that tutorial and illustrate it here.

Installing Apache and MySQL is pretty straightforward. Just open the Terminal and write the following lines.

The first line installs Apache 2.2.x and the second line installs MySQL 5.0. Alternatively you can skip writing sudo if your user has root privileges.

1
2

sudo aptitude install apache2 apache2-mpm-prefork apache2-prefork-dev apache2-utils apache2.2-common
sudo aptitude install mysql-client mysql-client-5.0 mysql-common mysql-server mysql-server-5.0 mysql-server-core-5.0

The tricky part is installing the necessary libraries in order for PHP 5.3 to function correctly. Fortunately Brandon Savage deals with this issue too. Just write the following line into the console:

sudo aptitude install libtidy-dev curl libcurl4-openssl-dev libcurl3 
libcurl3-gnutls zlib1g zlib1g-dev libxslt1-dev libzip-dev libzip1 libxml2 
libsnmp-base libsnmp15 libxml2-dev libsnmp-dev libjpeg62 libjpeg62-dev 
libpng12-0 libpng12-dev zlib1g zlib1g-dev libfreetype6 libfreetype6-dev 
libbz2-dev libxpm4-dev libmcrypt-dev libmcrypt4

6. Installing PHP 5.3

First, download the source from the website. Just write the following commands:

1
2
3

cd ~
wget http://us3.php.net/get/php-5.3.0.tar.gz/from/this/mirror
tar xvfz php-5.3.0.tar.gz

Before executing the following configure command restart your virtual machine, because there is the possibility that Apache or MySQL is not properly loaded.

After restarting go into the folder where PHP was extracted. Mine is ~/php-5.3.0

1

cd php-5.3.0

Then execute the configure command:

./configure –with-apxs2=/usr/bin/apxs2 –with-mysql=/usr 
–with-mysqli=/usr/bin/mysql_config –with-pgsql=/usr –with-tidy=/usr 
–with-curl=/usr/bin –with-curlwrappers –with-openssl-dir=/usr –with-zlib-dir=/usr 
–enable-mbstring –with-xpm-dir=/usr –with-pdo-pgsql=/usr –with-pdo-mysql=/usr 
–with-xsl=/usr –with-ldap –with-xmlrpc –with-iconv-dir=/usr –with-snmp=/usr 
–enable-exif –enable-calendar –with-bz2=/usr –with-mcrypt=/usr –with-gd 
–with-jpeg-dir=/usr –with-png-dir=/usr –with-zlib-dir=/usr –with-freetype-dir=/usr 
–enable-mbstring –enable-zip –with-pear

You should see something like this:

Create the make files by executing the make command:

1

sudo make

Then compile and install PHP:

1

sudo make -i install

As Brandon Savage states, the -i will ignore a nasty error that is caused by Ubuntu: "Ubuntu uses an unusual configuration for Apache which causes the installer not to know how to install PHP properly. This will produce a fatal error and cause the install to stop. The -i flag tells it to ignore the errors."

7. Configure PHP 5.3

After compiling PHP go to this directory…

1

cd /etc/apache2/mods-available

… and create two files. The first file is called php5.load

1

sudo nano php5.load

Write the following line into the file:

1

LoadModule php5_module /usr/lib/apache2/modules/libphp5.so

Save and create the second file called php5.conf

1

sudo nano php5.conf

Write the following lines into this file:

1
2

AddType application/x-httpd-php .php .phtml .php3
AddType application/x-httpd-php-source .phps

Almost finished. Load the configuration and restart Apache:

1
2

a2enmod php5
/etc/init.d/apache2 restart

That’s it! Now you can test if PHP is properly loaded by going to /var/www and creating an index.php file:

1
2

cd /var/www
sudo nano index.php

Write the phpinfo() command into the file:

1
2
3

<?php
    phpinfo();
?>

Enjoy your new development environment. Oh, if this tutorial was useful to you don’t hesitate to comment and share it with others.

The aim of MVC is to promote good programming practices and code reuse by separating a web application into three layers: data, presentation, and the interaction between the two. By separating these elements from each other, one can be easily updated without affecting the others.

Having a good understanding of MVC will be extremely helpful for anyone who is interested in learning a web framework like the ones mentioned above. Many frameworks are built around Ruby on Rails’s implementation of MVC, so understanding the core concepts well makes learning other similar MVC frameworks much easier.

To understand MVC, we will look at each layer in some detail. Throughout this article, I will use the classic example of a blog to show how the concepts of MVC work in a real application. In short, the model represents the data. The view represents the user interface (the web page), and the controller facilitates communication between the two.

The three layers of MVC in detail are:

The model

The model represents the data in the application. “Data” in this context means the nouns, or things, in the application that can be abstracted (generally using a database). For example, blogs store posts in a database. In an MVC application, this would imply a model called Post. Post would tell the application what type of data a post contains, which is usually a title, a date, and some body text.

In addition to defining the data that a “thing” would contain, it’s also the model’s job to interact with the database where the actual data for posts are stored, and to implement all logic relating to the creation, fetching, updating, and deleting, and other data manipulation of posts. The model is also built on top of an object-relational mapping (ORM), a system that connects the elements of the model object to the appropriate fields in the database. It will automatically handle all interaction with the database, allowing the developer to avoid writing SQL altogether.

The code in the model is often referred to as business logic. Business logic is all the rules that define data and how to interact with it. By isolating the business logic from the presentation layer, it is easier to write and maintain the logic for the application in a way that is both reusable and transportable (perhaps to another framework) without conflicting with the way the user interacts with it on the web page.

A common example of business logic is validation rules. When a new blog post is made, the application developer may want to ensure that the post has been given a title. This would be enforced by the model, because it is a rule applying to the expected format of the data.

When the new post is submitted via web form, the model looks at the data it receives and checks if it conforms to any validation rules that apply. If there are any errors, such as an empty title field in this case, the model rejects the data, and sends an error back to the user. If the data passes validation, the model will open a connection to the database and save a new post record, using its ORM.

It is a common mistake for developers just beginning with MVC to think of models as simply a fancy name for a database. It’s important to remember that the model is not the database, it’s an abstraction of the data itself, and everything the application knows about what the data is and how it works is part of the model. It is considered good practice to put as much of the code as possible into the model. Try searching Google for fat model, skinny controller for additional details on this idea.

The view

The view is the presentational layer of the application: the user interface. The view will look familiar to web developers who have done mostly procedural programming. For the most part, the view is simply the HTML page. Small bits of inline logic are included, such as simple loops to create tables or just printing dynamic data like in any other server-side script.

The goal in creating a good view is to have as little logic as possible – save the heavy lifting for the model and the controller. A view should be simple enough that someone who only works with markup and doesn’t program, like a designer, can work with it easily.

There will be a different view for each different page in an MVC application. In our blog example, the pages for viewing all blog posts, viewing a specific blog post, adding a new blog post, or editing an existing blog post will all be separate pages, and hence, separate views. Web frameworks that use MVC usually offer a method of dividing the view into even smaller sections to further modularize code.

There are many elements of a single page that will be in common with other pages on a site. Consider the logo and branding, navigation, and footer text. These are usually the same on all pages. To keep from repeating all this code in every view, the view offers us a layout (in Rails parlance), an HTML template that contains all the markup in common to multiple pages. When a page loads, the framework will take the specific view for that page and insert it into the overall layout.

MVC frameworks typically offer other features in the view as well, such as helpers, classes that can be included in order to speed up common tasks such as encoding HTML entities or formatting times and dates. Another common feature is what is referred to in Rails as a partial.

A partial is to the view what the view is to the layout. It’s simply a very small chunk of reusable markup that can be inserted wherever it’s needed. A partial might be used in our blog example to contain the markup for an individual blog post. On the page that shows us one specific entry, this partial would be used just once, but on the index page, where all recent posts are shown, the partial would be called in a loop.

Partials are simply another way to organize the code into small chunks, following the programming practice called Don’t Repeat Yourself (DRY), which is one of the core philosophies of rapid development frameworks like Rails.

The controller

Think of the controller as the translator between the view and the model. The controller receives requests from the view (the user), decides what to do, communicates with the model as necessary to send or retrieve data, and then prepares a response for the user to be delivered back to the view. If models are the nouns of your application, the controllers are the verbs.

The controller is made up of actions, methods that operate on a model. Our blog would have actions for creating, viewing, editing, and deleting blog posts. When a user follows a link in the application, the request is sent through what is called the dispatcher, which accesses the appropriate action in the appropriate controller.

If a user goes visits a link to a single blog entry, the dispatcher will call the blog controller’s show action. The controller will then ask the model for the data for the blog post that the user is requesting. When the controller receives this data from the model, it will set variables with that data and pass it on to the view.

Again, it is common for new MVC developers to put most of their code into the controller. After all, it is the controller that receives data and decides what to do with it. In best practice, the controller will not do any manipulation of data or user interface itself, it will merely translate between the view and the model. It will present the model with requests for data that it can understand, and it will provide the view with data that it knows how to format and present to the user.

The big picture

Now that we’ve seen the details of the M, the V, and the C, let’s try to get an understanding of the big picture by looking at how they all work together. The diagram below illustrates a standard request cycle in an MVC application.

A typical MVC request cycle

The process begins when a user takes an action on a web page – submitting a form that adds a new blog post, for example. The request is sent to the blog controller, which extracts the data submitted via the HTTP POST request and sends a message to the blog model to save a new post with this data.

The model checks the data against its validation rules. Assuming it passes validation, the model stores the data for this new post in the database and tells the controller it was successful. The controller then sets a variable for the view indicating success.

Finally, the view displays this message to the user back on the web page, and they know their new blog post has been successfully created. If, for some reason, validation of the data failed, the model would alert the controller of any errors, which would set a variable containing these errors for the view. The view would then present the original form along with the error messages for any fields that didn’t validate.

Though there is a lot to take in when first learning MVC, it’s really not as complicated as it sounds. Just remember that the model is the data, the view is the user interface, and the controller is the mediator. Even if not using a web framework that uses MVC design, the principles of separating presentation and business logic in an application are very helpful in creating clean, compact, reusable code that will be fun and easy to work with. Once the concepts of MVC are mastered, learning a new framework is a breeze.

“PHP 5.3.0 is a newly developed version of PHP featuring long-awaited features like namespaces, late static binding, closures and much more.”

It is scheduled on June 30th

(via) Lukas Smith

I’m considering to re-brand the website, creating a new theme and writing more interesting articles.

So stay tuned!

It is created for web developers who are working / testing SQL queries a lot. The nice thing about this tool is that it gets the query results via AJAX, so you don’t have to refresh the page, it has a SQL syntax highlighter and a basic profiling tool.

It is written in PHP and jQuery, using ADOdb as a database abstraction layer and CodePress for the SQL editor.

It’s completely open source, you can find it at: code.google.com/p/sql-query-tester

If you want to contribute or suggest features don’t hesitate to comment here or on the project’s groups page.

Screenshot: