According to Apple support Inactive memory is

information in memory is not actively being used, but was recently used.

For example, if you’ve been using Mail and then quit it, the RAM that Mail was using is marked as Inactive memory. This Inactive memory is available for use by another application, just like Free memory.

However, if you open Mail before its Inactive memory is used by a different application, Mail will open quicker because its Inactive memory is converted to Active memory, instead of loading Mail from the slower hard disk.

In many cases you will need to jump from a heavy application into another, and then you will need either to accept the system performance, which is not deadly bad, or use a simple command line to free your memory.

First, how to monitor your memory?
Mac OS X comes with Activity Monitor Application that gives you a glimpse about your system resources, one major resource is your memory.
Read Apple help on Reading system memory usage in Activity Monitor

Now, how to free the inactive memory without having to reboot?

Open your terminal app and run
purge

Checking the ManPage of Purge, purge task defined as force disk cache to be purged (flushed and emptied) with a description Purge can be used to approximate initial boot conditions with a cold disk buffer cache for performance analysis. It does not affect anonymous memory that has been allocated through malloc, vm_allocate, etc.

No need to download an app to free your memory and moreover, you do not need to buy an app for that purpose, it comes for free.

©2012 Don't Say Geek! Say Syntux!. All Rights Reserved.

but later she called complaining that she cannot send emails using our SMTP server so for me it was what the hell is going one? later I found that Postfix is picky about the order of your options so if you do reject_non_fqdn_hostname before permitting sasl authenticated users, those authenticated will not be able to send emails.

and this was new to me.

Tags: server mail, fqdn, smtp server, spamhaus, sorbs, zen, colleagues, spam, dnsbl, korea, hell, pbl, linux

©2012 Don't Say Geek! Say Syntux!. All Rights Reserved.

< ?php
$fixture = Array();
assertTrue(sizeof($fixture) == 0);

$fixture[] = "element";
assertTrue(sizeof($fixture) == 1);

function assertTrue($condition) {
if (!$condition) {
throw new Exception("Assertion failed.");
}
}
?>

Well, we could know if something went wrong if some Exception was raised, of course assertTrue is not the only thing you want to do, UnitTesting has gone far beyond that, usually UnitTesting frameworks provide a whole lot of features that you need for your testing.
Lot’s of Testing frameworks are available for PHP, I’m going to point to 2 of them, the first one is SimpleTest (http://simpletest.org/), it’s written in PHP 4 (Although they are going to migrate to PHP 5 when they reach version 2), so you can use it on both PHP 4 and 5 programs, also it includes a nice HTML reporter for some good looking html results the same test above could be written using this framework as:

< ?php
require_once 'simpletest/unit_tester.php';
require_once 'simpletest/reporter.php';

class TestingFixtureArray extends UnitTestCase {
function TestArray() {
$this->UnitTestCase(“Testing Fixture Array”);
$fixture = Array();
$this->assertTrue(sizeof($fixture) == 0);

$fixture[] = “element”;
$this->assertTrue(sizeof($fixture) == 1);
}
}

//run the Test
$test = new TestingFixtureArray();
$test->run(new HtmlReporter());
?>

Another Well know testing framework is known as PHPUnit2 (http://www.phpunit.de/), it’s available through the PEAR Repository, you can install it as
$ pear install PHPUnit2
It’s written in PHP 5, and is so widely used within PHP Developers, a good resource for learning how to use it is the free available online book PHPUnit Pocket Guide (http://www.phpunit.de/pocket_guide/index.en.php), the same example could be:

< ?php
require_once 'PHPUnit2/Framework/TestCase.php';

class ArrayTest extends PHPUnit2_Framework_TestCase {
public function testNewArrayIsEmpty() {
// Create the Array fixture.
$fixture = Array();

// Assert that the size of the Array fixture is 0.
$this->assertEquals(0, sizeof($fixture));
}

public function testArrayContainsAnElement() {
// Create the Array fixture.
$fixture = Array();

// Add an element to the Array fixture.
$fixture[] = ‘Element’;

// Assert that the size of the Array fixture is 1.
$this->assertEquals(1, sizeof($fixture));
}
}
?>

and you can run it on command line as
$ phpunit ArrayTest

Additional benefits that you can realize by thoroughly testing your code:

• Testing forces you to write code that is easily testable. This leads to looser coupling, flexible designs, and good modularity.
• Writing tests forces you to explicitly clarify your expectations of how your code is to behave, distilling your design into sharper focus from the beginning. Writing tests forces you to consider the universe of possible inputs and the corresponding results.
• Tests are very explicit way of communicating the intent of your code. In other words, test cases act as example and documentation, showing exactly how a given class, method, or function should behave. A test case defines how code works in a non-ambiguous way.

Finally, if your test suite – your set of test cases – is very thorough, you can say your code is complete when all of your test pass. Interestingly, that notion is one of the hallmarks of Test Driven Development.
Test Driven Development (TDD), also referred to as Test First Coding, is a methodology that takes testing one step further: you write your tests before you ever write any code. A nice, brief summary of the tenants of TDD is available at http://xprogramming.com/xpmag/testFirstGuidelines.htm, and a good introductory book on the strategy is “Test Driven Development: By Example” by Kent Beck. (The book’s examples are in Java, but it’s a quick read and gives you a very good overview and introduction to the subject.)

Agile Development
Recently, unit testing – in particular Test Driven Development – has been associated with agile Development methodologies such as Extreme Programming (XP)g that focus on rapid iterations of releasing functional code to customers and welcoming changing customer requirements as a natural part of the development process. Some good online resources for learning about agile development include:

• http://en.wikikpedia.org/wiki/Agile_software_development
• http://agilemanifesto.org/
• http://www.extremeprogramming.org

Tags: automated tests, sizeof, business development, array, functionality, element, nature of business, interface

©2012 Don't Say Geek! Say Syntux!. All Rights Reserved.

I’m currenlty working on a site where I want to improve performance of dynamic pages. One of the greatest techniques to do is to cache dynamic content and serve the generated output (HTML).

It’s not as easy as we all want it to be when you have all sorts of weird blocks on the page: User login area, random content, ..etc

As I had a very pleasent experience with eZ components last week, I decided to take a look at the components, but then i remembered it works on PHP5. This project is on PHP4, I had to look for an alternative and decided to use PEAR::Cache_Lite.

Example

In the figure above we can see that we have 4 content blocks coming from tha database, let’s assume this is our homepage. And let’s also assume that we are trying to get random content, e.g. 3 random blogs, 3 random posts ..etc

An example would look something like this before caching

[coolcode lang="php"]

$query = “SELECT title, username FROM blogs ORDER BY RAND() LIMIT 3″;
$result=mysql_query($query);

while( $row = mysql_fetch_assoc($result) ){

echo $row['title'];

}

[/coolcode]

Caching: Take 1

We can easily cache this block using Cache_Lite output caching as follows:

[coolcode lang="php"]

require_once ‘Cache/Lite/Output.php’;

$options = array(
‘cacheDir’ => ‘/tmp/site_cache/’,
‘lifeTime’ => 1000,
);

$cache = new Cache_Lite_Output($options);
if (!($cache->start(‘blogs_block’ ))) {
// Cache missed… start caching this block

$query = “SELECT title, username FROM blogs ORDER BY RAND() LIMIT 3″;
$result=mysql_query($query);

while( $row = mysql_fetch_assoc($result) ){

echo $row['title'];

}

}

[/coolcode]

Well, there’s a clear problem, after the first hit, the block will be cached, and anyone who vists the page during the lifetime of the cache will keep seeing the same block! This abuses the whole concept of serving random content. We need to figure out a solution…

Caching: Take 2

I came up with a very simple solution! I will make the content appear as random, but infact it is cached, just modify the line that starts the cache as follows:

[coolcode lang="php"]

if (!($cache->start(‘blogs_block’ . rand(1,10) ))) {
[/coolcode]

What this does is allow for caching of 10 blocks, this will do the trick, give the users 10 cached blocks. If we have 4 different content blocks and allow 10 random blocks each, we end up by having 10x10x10x10 =10000 different page combinations.

Caching: Take 3

While the solution above meets my needs, I need something a bit cleaner than having rand() everytime. The first solution I came up with was to write the following class that extends Cache_lite and allows for cache randomization. Download the Class.

Using the cache randomizer is very simple, here’s an example.

[coolcode lang="php"]

require_once ‘Cache/Lite/Output/Random.php’;

$options = array(
……….
);

$cache = new Cache_Lite_Output_Random($options);

//Set the number of random blocks to be cached
$cache->setRand( 10 );

if (!($cache->start(‘blogs_block’ ))) {
// Cache missed… start caching this block

$query = “SELECT title, username FROM blogs ORDER BY RAND() LIMIT 3″;
$result=mysql_query($query);

while( $row = mysql_fetch_assoc($result) ){

echo $row['title'];
}

}

//to disable caching and go back to normal behaviour to keep using the same object
$cache->clearRand();

//to change the number of random blocks for another block
$cache->setRand( 20 );
[/coolcode]

Conclusion

Random block caching is very useful when you want to acheive high performance, yet allow random content from a datasource (Database). If we had a page with 4 blocks, and allow 10 random blocks, we get (Theoritically) 10000 page combinations. Although we only have 40 cache blocks stored on the server.

Tags: pleasent experience, random posts, output html, output options, simple solution, dynamic content, php4, pear, all sorts, lifetime, array, blogs

©2012 Don't Say Geek! Say Syntux!. All Rights Reserved.

I got introduced to eZ components during my last visit to Norway to attend the eZ systems conference. I decided to give it a shot, and oh boy it’s just amazing, probably the cleanest and simplest API ever.

I managed to find the package “Mail”:

The components allows you construct Mail messages conforming to the RFCs. It has support for attachments, multipart messages and HTML mail. It also interfaces with SMTP to send the e-mail. Reading and parsing mail messages comes in version 1.1.

The package is well documented and includes many examples. Here’s the script I ended up writing (edited version):

[coolcode lang="php"]
< ?php
define( 'PHOTOS_DIR', 'email_photos/' );
define( 'FILE_PARSED_MAILS', '.fpm' );

require_once 'Base/src/base.php';
function __autoload( $className )
{
ezcBase::autoload( $className );
}

//get the list of emails that we alread processed
$parsedEmailsIds = array();
$parsedEmailsIds = @unserialize( file_get_contents(FILE_PARSED_MAILS) );

if( 'array' != gettype($parsedEmailsIds) ){
$parsedEmailsIds = array();
}

$pop3 = new ezcMailPop3Transport( 'mail.example.org' );
$pop3->authenticate( ‘username’, ‘password’ );

//get the list of emails from the server
$severEmailsIds = $pop3->listUniqueIdentifiers();
$emailsToFetch = array_diff($severEmailsIds, $parsedEmailsIds);
if( !count($emailsToFetch) ){
//no emails to get!
exit;
}

$set = $pop3->fetchAll(false, $emailsToFetch );
$parser = new ezcMailParser();
$parser->setTmpDir( ‘tmp/’ );
$mails = $parser->parseMail( $set );

foreach ( $mails as $mail )
{

//Get email parts
foreach( $mail->body->getParts() as $part ){
if( get_class($part) == ‘ezcMailFile’ ){

//get the destination file name after some cleanups
$fileName = nameToSafe( basename($part->fileName) );

//the new destintation filename, this function makes sure we get a unique file name everytime
$destFileName = PHOTOS_DIR . nameToSeq(PHOTOS_DIR,$fileName);

rename( $part->fileName, $destFileName );

}

//after we’re done, we need to update the file that stores the list of parsed emails
file_put_contents( FILE_PARSED_MAILS, serialize( $severEmailsIds ) );

?>

[/coolcode]

I’m sure there’s a better way to get the new emails only, probably with var_export()

Note: The only problem I faced, which is VERY strange, is the ability to fetch a single email or list of emails. Surprisingly, the API didn’t provide such feature. I did an ugly hack to “Mail/transports/pop3/pop3_transport.php” to function fetchAll(), I should have created another function, but I was in a hurry. Here’s the modified version:

[coolcode lang="php"]
/**
* @throws ezcMailTransportException if the mail could not be retrieved.
* @param bool $deleteFromServer
* @param array $messages
* @return ezcMailParserSet
*/
public function fetchAll( $deleteFromServer = false, $messages = null )
{
if( !isset($messages) ){
$message = $this->listMessages();
}
return new ezcMailPop3Set( $this->connection, array_keys( $messages ), $deleteFromServer );
}

[/coolcode]

Tags: package mail, mail body, solidarity campaign, mail messages, multipart messages, ez systems, attachements, edited version, fpm, rfcs, e mail, parsing, smtp, array, few days, attachments, email, norway, fi, images

©2012 Don't Say Geek! Say Syntux!. All Rights Reserved.