Software development in the real world

WorldTimeEngine: How to show all times in user’s local time zone

2009-08-15T07:34:28Z

When I visit some site and it shows me that some action performed at some time – it confuses me a little, because I don’t know in which time zone is this time.
Sure, you can spend some time to read about one’s time zone settings and rules, BUT Don’t make me think. Every website uses his own rules for time setting – some uses GMT zone, some says something like: London or New York or Moscow time.

I, as a potential user, will be much more satisfied if I would see the only one explanation:

All dates and times are in your local time zone settings.

Sounds easy, yet powerful. And on the other hand – hard to implement such flexibility.. But it’s really not.

Recently, I was working on some site, where exact clear time was essential. It was scheduled message sending feature. We had users from many countries in great variety of time zones.
My first idea about how this feature can be implemented – was in involvement of time zones select option, where user can choose his time zone to say to us his local time. But this isn’t very reliable because in one particular GMT time zone many can be located lots of countries with their own time setting rules.

Every single country decides every year when DST transitions will occur. There can be any number of offset transitions during the year: 0, 1, 2, 3, 4 etc. There can be offset transitions that aren’t DST transitions. For example, in 1946 Hawaii changed its standard time offset from -10.5 hours to -10 hours–and this had nothing to do with DST.

So we couldn’t count neither on GMT zone to be sure for 100%, nor for country’s capital GMT offset(Russia, USA, Canada and so on).

The answer was very simple and beautiful.

There is WorldTimeEngine service, which provides a simple API for retrieving user’s local time based on his IP address. It costs not so much, and this information can be cached for quite a long period of time.

I’ve written some simple class, which calculates offset between our server’s time(London, GMT+0) and user’s local time, then it saves this offset to the IP address – Offset dictionary stored in database. So, when we show some time-related information, we implement this offset for every single timestamp – and user always see all info in his local time settings.

Very useful.

Memory Palace method example: Strategy pattern

2009-07-30T13:17:39Z

This post is a sequel of previous How to start using Design Patterns post, describing the Memory Palace memorization method. I recommend you to read it before starting to read this post.

For example, I can use my sitting room as a basis for the remembering path. In this room I have the following objects:
Table, big bright window, lamp, sofa, picture on the wall, small bookcase, CD rack, telephone, television, DVD player, chair, mirror, black and white photographs, etc.

I want to put all the units required for remembering the StrategyContext implementation in that room. I’ll start from window and will move to the door out of the room.

When I hear the word “strategy”, the first image comes to my mind is an ancient roman warrior with armors. “Context” associates with Jacuzzi for me(something that surrounds you). So I “see” the roman warrior sitting in the Jacuzzi(pay attention at bubbles and moist air in the room).

Here is an example implementation of the GoF Strategy pattern, main concept of which we want to remember:
I’ve taken it at Strategy PHP example from software pattern catalog:

class StrategyContext {

private $strategy = NULL;

//bookList is not instantiated at construct time

public function __construct($strategy_ind_id) {

switch ($strategy_ind_id) {
case “C”:
$this->strategy = new StrategyCaps();
break;
case “E”:
$this->strategy = new StrategyExclaim();
break;
case “S”:
$this->strategy = new StrategyStars();
break;
}

}

public function showBookTitle($book) {

return $this->strategy->showTitle($book);

}

interface StrategyInterface {
public function showTitle($book_in);
}

class StrategyCaps implements StrategyInterface {
public function showTitle($book_in) {
$title = $book_in->getTitle();
$this->titleCount++;
return strtoupper ($title);
}
}

class StrategyExclaim implements StrategyInterface {
public function showTitle($book_in) {
$title = $book_in->getTitle();
$this->titleCount++;
return Str_replace(‘ ‘,‘!’,$title);
}
}

class StrategyStars implements StrategyInterface {
public function showTitle($book_in) {
$title = $book_in->getTitle();
$this->titleCount++;
return Str_replace(‘ ‘,‘*’,$title);
}
}

class Book {
private $author;
private $title;
function __construct($title_in, $author_in) {
$this->author = $author_in;
$this->title = $title_in;
}
function getAuthor() {
return $this->author;
}
function getTitle() {
return $this->title;
}
function getAuthorAndTitle() {
return $this->getTitle() . ‘ by ‘ . $this->getAuthor();
}
}

$book = new Book(‘PHP for Cats’,‘Larry Truett’);

$strategyContextC = new StrategyContext(‘C’);

echo $strategyContextC->showBookTitle($book);

After I see the robot made from LEGO constructor, which holds the E letter in its manipulator-hand at the picture at the wall.

After that I see the robot’s manipulator is getting out of picture and moves the letter E to the opposite corner of the room, while the roman warrior has got out of the Jacuzzi and moved to those part of room. Manipulator gives this E letter, and while it falls down to the warrior’s hands it transforms into the exclamation mark(assign the strategy property an StrategyExclamation implementation – $this->strategy = new StrategyExclaim())

Now let’s move to particular StrategyExclaim implementation:

I’ll use the kitchen for that class. I see the warrior standing near the table, holding the knife. He wants to cut the tasty cake in form of exclamation mark, lying on the table(StrategyExclaim).

Near the sink I the the ostsilograf with right sine function on them. At the end of room, I see the black “magic” curtains, like those in circus. And after that I see the top of the curtains lowering(опускаются), until we can see the book’s, standing behind the curtains, top part with its title(function showTitle($book));

Now, If I’ll walk this path I’ll can remind this pattern implementation. It is important, to now only remember every line of implementation, but more of core concepts(main parts), which will help you to remind the implementation.

Because remembering the source code is not a linear information, you’ll have to be creative and find the way of grouping the concepts and make a cross connections between them.

It is strongly recommended for you, to make your own “story”, because your own feelings and imagination images means much more to you, than other peoples perception, hence are remembered faster and stronger.

Our main purpose is not just in fast remembering the pattern, but in stay it with us for a quite long period of time. After first learning I reminisce the remembered information in my imagination, without looking at the paper or laptop

1) after 15 minutes

2) after an hour

3) after about 6 hours

4) on the next day

5) .. week

After that, if you want this information to stay in your long-term memory all you have to do is to reminisce this information on a monthly basis. It will be enough.

I’m using the technique to memorizing different types of information: UNIX shell commands, foreign language words, framework constructs, etc.

stackoverflow

2009-03-05T18:32:16Z

Finally have decided to register at stackoverflow.

I like to talk on software development related topics, asking question and provide some recommendations to other developers. Sometimes I face different unique challenges, which is not described in the software dev books – in that cases all you can do is to rely on your own experience.

One head is good. No, not like that One good head is good, but a community is much better. In that way our experience summarize in solving particular problems, and answering particular questions.

I like the community it has, type of questions and discussions manner.

How to start using Design Patterns

2009-02-28T07:00:01Z

I remember myself procrastinating in using of Design Pattern in production code, after reading the information about the GoF patterns.

On the paper everything looked very easy and understandable. But after you might fall in trap of fear of using this knowledge in production code, because:

You have a very limited time dedicated for the task. So you can’t find the time to do the things “in right way”
You haven’t enough experience of some particular Design pattern, so you don’t know how to exactly implement in real problem solving. So you spend more time and get out of time scope for task and schedule. So you decide to refuse “the hard right way”, and implement an easy and dirty “temporary” solution.

If you refused to implement the pattern, you haven’t improve your experience with this pattern. It is an infinity loop: you can’t implement because you don’t have a required experience. Time passes, and you will have the exact same problem in future, and the initial conditions(level of experience with particular pattern) are still low.

I was in this loop for a couple months. And after I recognised this behaviour habit, I’ve asked for help more my more experienced co-workers. The advice was simple and easy:

You can’t succeed without failure. If you want to become more experienced in Object Oriented design and Design patterns, you have to have a will in this trend, and still moving nonetheless the periodic temporary failures.

How to remember software design patterns

2009-03-05T17:51:12Z

Who likes to learn from the scratch the same issues over and over again. Assume, that nobody.

But sometimes we have to do so with design patterns, because that is not the case we have a close contact with every of 23 classic software design patterns.

I don’t remember, who wrote that:”we uses implementation patterns every hour, we uses design patterns much rarely, and we use architectural patterns mostly at the start of the project”.

And when we don’t use some of our knowledge for quite a long period of time, we actually loose this knowledge, and will have to learn it again, when we need it.

I think, that design patterns are worth remembering, because it is not the case, when you’ll have to forget it later, because something new will appear. Software design patterns are core solutions for constantly appearing daily design tasks. And mostly, it doesn’t attached to particular programming language, or framework(but every implementation has its own differences).

So, here I want to tell you about, the method for memorizing the lists of structured data.

It is more like intro-to-method post. In next posts, I’ll try to explain with examples, how you can learn the implementations of Software design patterns.

So, Memory palace(method of loci/journey) method:

To use this technique, remember a room that you know good. There are many objects in room. You have to choose the path(sequence) of those objects(no matter in what direction, but I have to know the “path” well) and know that sequence.

After that you have to associate images representing the information you want to remember with the objects on the path, one-by-one.

You may not limit yourself by just one room, you can go from one room to another, go out to street and so on as you like. The most important is that you have to know that path(significant point, associated with information unit you will associate with), and can walk it in your mind back and force.

To reminiscent all the information you have remembered, all you have to do is just to walk the path and “look” at those significant points, referenced somehow with information units.

I also strongly recommend you to get familiar with wikipedia’s article on “Method of loci“.

Here is the post describing the using of this method for Strategy Design Pattern memorization.

Session management after automated deployment best practices

2009-01-09T19:17:58Z

Now, I’m working on automated deployment platform for LAMP
environment, using Apache Ant.

Now it looks, something like that:

1. blocks all requests, and display “Website is under construction”
page.
2. implement database schema updates
3. update the application’s source code
4. unblock all the requests and hide “Website is under construction” page.

I thought, that we need the following:
after third, and before fourth point I want the webserver to drop the sessions of already loggined users. I think, this practice is useful for automated deployment, because there might
be significant changes in sessions handling and in the application
core itself, so it is better to drop users’ sessions and force them to
login again.

Because it is an automated deployment and usually take very small time, so we can’t wait when loggined user’s session will expired.

The solution for the problem depends on where does the application stores sessions – files in system tmp folder, application tmp folder, database or some custom session-handling mechanism.

We store our session in the database, in single table called `sessions`. So when we need to drop the sessions, all we have to do is to execute SQL command: “TRUNCATE TABSE `sessions`;”. This can be done automatically, from command line. For example, like that:

mysql –user=your_username –password=your_password your_database_name -e ‘TRUNCATE TABLE sessions’

It is quite simple solution and most important working solution, in most cases it is enough, BUT
it is not ideal, and can be improved.

We decided to do it another way:
new build can have just minor updates, which don’t refer with sessions in any way, so we should save user’s session in that case. Build manager, or person responsible for deployment should to know such details, whether sessions must be dropped after deployment or not(just hide unnecessary details), because it is developer’s responsibility to “tag” the build with “drop the sessions”, if it is necessary. This process, has to be automated too.

Then we started to think, how we can make that. The solution was simple and straightforward – give this responsibility to database SQL deltas automated updates mechanism.

We use DBDeploy for the task, which handle plain SQL format for SQL updates.
So when developer sees the need of sessions drop after deployment, all he have to do is to add the “TRUNCATE TABLE `sessions`;” SQL command to new SQL delta script.

This solution, of course, becomes useless if sessions are stored in tmp folder, as default option in php.ini file. In that case, I wan’t to recommend you to drop the session files manually from that folder, but better stop apache web server before, for avoidance of conflicts.

Index page “Under construction” while deploying

2008-12-27T20:50:50Z

I have noticed a few times earlier on different sites an index pages with title “Please be patient, while we are deploying new software version. You’ll like it”. And one day, I decided that it is the time, to integrate the similar feature to our automated deployment process.

I think, that this page has to show user some indication of action progress(real or fictional), not just a static page, user has to refresh to see if it is finished or not. What user has to do – is just open once the site, see the message, that it is “Under construction”, and stay the page for a while.

It has to refresh itself until the time, deployment has finished. After that it has to load index page of new version’s website.

I wan’t to tell you, how and when this new index page is setting up. Right, all the deployment processes can vary a lot depending on the software it deploys, environment it uses, deployment tools etc.

What is highly recommended in most cases:

1. Install new index page with “Under construction” message

2. block all the web site’s pages, except index

== different actions here(DB updates, server restart, caching refresh etc.) ==

3. unblock all the pages(except index)

4. delete “Under construction” page

That is how, I did it:

It is an Apache Ant build file, with the following contents:

<?xml version=“1.0″ encoding=“UTF-8″?>
<project name=“Under construction page” basedir=“.”>

</project>

To install our “Under construction” page – just run:

ant show-splash-screen-while-deployment

It will backup your default .htaccess file, and replace it with new one, which catches all the queries and redirect it to the root of the web site.

And when deployment will be finished, run:

ant hide-splash-screen-while-deployment

It will restore your default .htaccess file.

In attachment, you can find all those files you need to do the same.

That solution is not the best, and is not for types of projects.If you like the idea, mostly you’ll need to modify it to your demands and your environment.

Download an attachment

Have fun!

Versionable static content deployment

2008-12-27T22:26:04Z

Recently, at some project, we planned to dedicate some time to improve our deployment and build packing process, so we can use the solution in future projects.

What we decided to do:

make a pack of all the Java scripts and CSSes, to reduce the page load time
make a static content versionable

If first is quite a common practise, I wan’t to tell more about the second point, on example.
We use an automatic deployment system. So installing of new software version can be done easily and takes little time. So, for example, if we faced some serious bug with CSS, something is very bad with User Interface and the problem is with some external CSS directive.

If we will just change solve the problem, locally in those CSS file, make a build and upload it to the server we’ll have some users, with loggined sessions and cached CSS files in browser. We have uploaded the fixed version of CSS, but user still see the old one, with bugs.

The same problems can arise with all the static content(java scripts, CSS files, images). So we decided to make that content versionable too. Main purpose is to force the browser to load new version of those content, when we deploy new version.

That is how we decided to do that:

if we change all the paths in HTML, to static content with some unique postfix, such as, for example “styles.css?ver1.2″ or “logo.png?ver39″ or even “logo.png?UUID-UUID-UUID-UUID-UUID”, we’ll force all the browsers to reload the files. But, we have found that actual CI build number(not UUID or revision) works best for us, because it some bug arises we can know for sure, in what build is it, to make a bug fix and deploy new version.

I automated the process making the unique URL postfixes for static content while packing build, ready for deployment, by using the Apache Ant and sed. Here is the example:

That command search for all the files recursively in the build.dir folder, and replaces all the matches “BUILD_NUMBER” to build.number value.

To make this command run your view templates have to look like that:

So it will still works in development environment.

There are different ways of setting ${build.number} variable, depending on your repository vendor(if you want to tag it by revision number), continuous integration server(by using its build number), generate some unique string(UUID) and assign its value to the ${build.number} variable, or even to install ${build.number} value manually, but it is not desired.

For, example, here are some ideas:

http://www.zorched.net/2006/07/20/getting-the-revision-number-of-your-subversion-working-copy/

http://code.google.com/p/bamboo-ant-tasks/

You can reduce code duplication by using the wrappers for outputting the links for static content(images, javascripts and CSS).

phpUnderControl

2008-12-27T18:53:10Z

Recently, I had an invitation to participate to some project, which where in development for about a year. The product was quite successful, but stack holders decided to improve its performance, reduce bug-level, develop lots of new features, otherwise get a more loyal customers and make it more profitable. So, for the start, let me tell you about the environment. It was the following:

absence of automated process of deployment
zero unit-tests code coverage
quite low skills of working with repository

So, the consequences are not unexpected:

big amount of bugs, even in production
deployment was quite rare, difficult and sometimes error prone(especially in the case, when there was need to rollback to previous version)
software integration problems
DB integration problems
consequently, low motivation for producing lots of new code, because it is always scary and many unpredictable bugs arises in different places

Significant part of those problems can be eliminated by improving the development and deployment process. That is what we decided to do, at first. So, after that I decided to talk with the people, mostly involved in the planned switch – developers, QAs and the system administrators.

The most important fact, that I noticed at first was, that all the team members has performed a motivation and eager to make the switch. So, we decided to start with CI server, first.

After demands clarification and resources analyzing, we decided that our CI system looks like:

open source, free of charge CI server
no need for advanced features, such as pre-tested commit, distributed testing. YAGNI, for the start.
unit-test runner, functional tests runner(Selenium), code coverage analysis, code static analyzers(duplication, code convention format, cyclomatic complexity)

After some researching, we have found ourselves choosing between Xinc(written in pure PHP) and phpUnderControl(as a plugin for CruiseControl) CI server.

I don’t like PHP language that much, to choice CI server, written on it So I decided to choose CC. Maturity of the product, its community and available plugins were the main arguments.

phpUnderControl is a tool, giving us all the power of CruiseControl, and has almost everything, ” right from the box” that usual PHP project CI server wants to have.

After working for quite a long period with the Bamboo CI server, I feel myself very comfortable with phpUnderControl. It has all the base benefits, Continuous Integration can give for a small-to-medium size project. And what I liked especially in phpUnderControl, is that it didn’t take me much time to setup all the required features.

As a consequences, a couple months later, working with that scheme, I can say that level of bugs has decremented in some scale. Mostly, because of those people who writes unit-tests for their code. No they runs all the time, developer commits its code to repository, and we can see the feedback from code very fast.

One more interesting point, I’ve noticed, that static code analyzer increases the code quality in some way For example, if some developer worked on the code, other may not see very often, so he can leave it in unrefactored form, and no one can notice that. But when code analyzer tells him, that, for example, cyclomatic complexity of some of the method is enormous, or the class length in LOC is too long, developer might feel ashamed of them, and will refactore the messy code.