Share on Facebook

For all the talk of object oriented design and patterns on this blog I sometimes question my own take on objects. What are objects? What are their roles? 

Most of my experience in the professional realm has been in ‘enterprise architecture’ (until recently) where layered approaches are king. Most the systems I have worked on and even designed concentrated on distributing layers, database layers, business object layer, presentation layer, and UIs (views). With this approach objects besides the aforementioned layers act as simple data types (or data transports). They tend to by strongly types and are not really aware of the state they carry. It is the business object layer or presentation controllers that are aware of the objects states. The ‘enterprise’ layer approach even through objects and classes are involved it seems more like functional programming where data types (often referred to as domain types) are defined. 

What about the other style of objects where they encapsulated and operate on their own internal representation? 

I have recently been working on an implementation of a non-collectable card game and it has brought the questions I have to the forefront.  With the PHP CodeIgniter framework, which I am using to implement the game, the controller deals with the model and the view indirectly through load method calls and operate on function defined in both layers. Most examples I have seen of the framework in action use simple arrays to communicate data from the database and view. I am attempting to use objects that contain state as the glue between the interfaces. This falls more in line with my experience and not a classical view of objects. I have often believed that this was a better approach to separate areas of concern when a database changes the code for that interface is one place versus spread across a high number of objects.

Is the classical view flawed? When is it appropriate? When is it beneficial to use a classical object approach?

Share on Facebook

I finally downloaded Google’s new browser Chrome. I had intended too the day it was released and procrastinated it for two more days. I downloaded it last night and have been playing with it off and on since then.

What does Chrome mean for web developers? For one thing it means that all development will need to be testing in yet another browser. One of the biggest pains in web development is programming in such a way that sites and page behave consistently across all browsers that support different standards of the same technology [cascading style sheets [CSS] is a good example of this). 

On the positive side chrome has some nice built in features like the browser has a nice element inspector built in that seems pretty solid.  It behaves almost exactly like the plug-in FireBug for FireFox, which is an invaluable tool for debugging pages and seeing how other implement the presentation of a page.  Since Chrome uses a multi-thread approach to the implementation, each tab has its own memory space and process, it has a built in ‘task manager’ feature (just like Windows OS Task Manager) that allow viewing a pages performance in the browser.  It will be exciting to see future features designed to make a web developers life easier.

From a user perspective I think the browser is awesome. It is fast, clean, and sleek. I really like the address bar behaving like a command line, a search box, and an intelligent history … clearly a brilliant idea to give it the user more power. You can drag and drop tabs into their own windows, can recover accidently closed tabs, and much more. I personally look forward to seeing the impact this beta browser will have on the browser market all together. They are certainly pushing the envelope.

Share on Facebook

One of the things I was working on tonight was manipulating an image, of a card, through PHP code. I was please to find that doing so did not require the addition of a library. Installations of PHP v5 has v2.x of the GD library bundled with the PHP installation. GD is an open source code library for the dynamic creation of images.

The first thing I had to do was verify that my host had GD enabled by creating a PHP file with the code below and placing it on the server and browsing to the file.

1
2
3
4
5
6
7
8
9
10

$array=gd_info ();
foreach ($array as $key=>$val) {
   if ($val===true) {
      $val="Enabled";
   } 
   if ($val===false) {
      $val="Disabled";
   }
   echo "$key: $val <br />\n";
}

It told me that GD was enabled and what types of image files it was configured to work with. First off I wanted to work with an existing image versus creating one from scratch (which either is possible). I created a stock card image (pictured below) to work with.

What I wanted to with this stock image was to add text to it. With the GD library the way to this is with the function imagestring. I created a simple class to manipulate the image, keep in mind this class is very much in sandbox mode and does not represent the final implementation.

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

class ManipulateGifImage {
 
	var $filename = '';
	var $fileObj = null;
 
	function setFile($file) {
		$this->filename = $file;
		$this->fileObj = @imagecreatefromgif($this->filename) or die ($errmsg);
	}
 
	// add text
	function addText($textToAdd,$position=0) {
 
		$strArray = explode(' ',$textToAdd);
 
		$str = '';
		$len = 0;
		$linepos = $position + 40;
		foreach($strArray as $word) {
			$len += strlen($word) + 1;
			if($len <=27) {
				$str .= $word . ' ';
			} else {
				imagestring($this->fileObj,2,10,$linepos,$str,imagecolorallocate($this->fileObj,0,0,0));
				$linepos += 10;
				$str = $word . ' ';
				$len = strlen($word) + 1;
			}
		}
		imagestring($this->fileObj,2,10,$linepos,$str,imagecolorallocate($this->fileObj,0,0,0));
	}
}

Using this class I was able to manipulate the image. You will notice that the addText function has logic for writing out lines of specific length and then moving the position to add the rest of the text on a new line position. This was done so the longer text could be added to the image by wrapping it in the image versus letting it fall off the edge.

To use this class I added the following code to the PHP file that displayed the manipulated image in the browser.

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

// file type
header("Content-type: image/gif");
 
$imageManip = new ManipulateGifImage();
$filename = 'images/card_front.gif';
$imageManip->setFile($filename);
 
$imageManip->addText('This is some text that shows up on the card. I am testing managing wrapping words and that is the reason this text is so long.');
 
imagegif($imageManip->fileObj);
 
imagedestroy($imageManip->fileObj);

The imagegif function streams the image object to the browser. Also notice that I set the headers content type so the browser would know what to do with the streamed image. I also followed that with imagedestroy to free the servers memory used for holding the image object.

Here is the resulting image:

Not hard. I have a long way to go with manipulating the images for the card game but this was a pretty straight forward proof of concept.

Share on Facebook

Ubiquity for Firefox from Aza Raskin on Vimeo.

Share on Facebook

In classic AJAX applications, web browser (client) cannot be notified in real time that the server data model has changed. The user must create a request (for example by clicking on a link) or a periodic AJAX request must happen in order to get new data from the server.

As I am discovering this is not a straight forward technique. Comet can be very resource intensive. It is interesting to note that most commercial or referenced implementation of comet involves custom written web-servers designed to handle the requirements of this technique to specifically deal with the many detractors. Having to deal with lost connection, proxies that cache portions of response, and firewalls that automatically close HTTP streams after a certain period (to name a few) are all issues that may need to be addressed when attempting to implement comet.

In a current personal project I need to implement a push from the server so that it can notify users of events caused a particular user causes an event to happen on the server. In essence there will be a shared application state that users can affect and there is a need for all users in the same ’server session’ to be notified. I am going to explore my options and comet was the first thing I ran across showing promise.

Stay tuned.

Share on Facebook

I never made the connection between Lifehacker and a process called GTD. It instantly made sense that they have an obsession with task lists in featured articles. I have been reading the site for a couple of months by ‘cherry picking’ articles from the RSS feed I have on my iGoogle home page. After I read a couple of articles about GTD all the dots connected. Lifehacker is all about getting things done. Talk about not seeing the forest through the trees.

So what is GTD? GTD is a workflow method for organizing task, projects, priorities, and life. It is based on a book by David Allen called, appropriately, ‘Getting Things Done (GTD)’. Better than me rattling on about the process let me offer some links that I found useful:

Wikipedia’s entry on GTD
A Primer on Getting Things Done
Huge List of GTD & Productivity Sites/Blog
Lifehacker
A Year of Getting Things Done: Part 1, The Good Stuff

I plan on giving this a spin to see how it effects my productivity and focus.

Share on Facebook

Below is an example of how to draw a circle composed of absolutely positioned div tags with a period character.

1
2
3
4
5
6
7
8
9

$radius = 100;
$cent_x = 300;
$cent_y = 300;
 
for($i = 1; $i < 360;$i++) {
	$pos_x = $cent_x + ($radius * cos($i));
	$pos_y = $cent_y + ($radius * sin($i));
	echo '<div style="position:absolute;top:' . round($pos_x) . ';left:' . round($pos_y) . ';">.</div>';
}

Share on Facebook

Model-view-controller (MVC) is an architectural pattern used in software engineering. Successful use of the pattern isolates business logic from user interface considerations, resulting in an application where it is easier to modify either the visual appearance of the application or the underlying business rules without affecting the other.

MVC if often referred to as a design pattern and in a lot of ways it is, though it has more to do with the architecture of an application. The general definition of MVC involved three parts, the model, the view and the controller. Makes sense, huh?

The model represents the domain specific information on which an application runs. More times than not, the model use a database as the persistent storage mechanism for this information. Even through other mechanisms can be used the model is main goal is to encapsulate data access and domain specific logic.

The view is the front end representation of the application, typically a user interface, although a programmatic API could also be considered a view.

The controller processes and responds to events coming from either the view or the model. It becomes the interface between the model and view. It can be used to control navigation, business logic, and a host of other things.

I have seen a large number of different implantations of the MVC patterns and have struggled with and argued about where business and domain logic should reside and the best way to implement it. This comes to no surprise given the history of the pattern and the fact that is has been the center of many holy wars in the technological industry and academic circles.

Two sub-types that I like to use in describing two major paths the pattern has gone are referred to Model 1 and Model 2 MVC.

In Model 1 architecture, requests are made of the view and the view handles all responsibilities for the request, validation, business logic, display logic, and generating a response (including navigation). This leads to problems with duplicate code and state control in the view. It makes it harder to move or change the interfaces implementation and can lead to maintenance nightmares. Model 1 tends to couple the presentation logic with business logic. One distinction that must be made clear is that the code behind in ASP.NET applications and a Java servlet’s in Java is considered part of the view (though a servlet can be more flexible given the fact that it can be called by a number views).

In Model 2 architecture, the presentation is deliberately separate from the content. The context of the application is maintained by the controller. The controller is often used to control navigation from one view to the next. The view can be implemented to contact the model (JavaBeans) or model interaction can be brokered by the controller (Microsoft’s UIProcess, Web Client Software Factory and Apache Foundation’s Struts Actions).

In web development, I have had great success with using Model 2 that has extremely light weight, ‘dumb’, views where the controller controls navigation, maintains state (including state persistence), and brokers all communication with the model. I have also wrestled with the downside of Model 1.

Share on Facebook

From the CodeIgniter website:

CodeIgniter is a powerful PHP framework with a very small footprint, built for PHP coders who need a simple and elegant toolkit to create full-featured web applications. If you’re a developer who lives in the real world of shared hosting accounts and clients with deadlines, and if you’re tired of ponderously large and thoroughly undocumented frameworks

Looking at the available functionality in the framework my first impression was the framework was a mish-mash of libraries bought together under an organized directory structure. While that may be true (still not clear on it) but it does has a module loader that allows the mapping of the libraries in a configuration file. It claims to be lightweight and it seems someone could take the approach of only adding the libraries that will be used. I plan on digging for to understand what the core CodeIgniter files are versus optional libraries to allow a skeletal loading of the framework.

One thing that caught my eye was that the framework had a MVC (model view controller) framework which I am a fan of and often through that it was something that PHP lacked. I plan on blogging on the MVC framework next.

Share on Facebook