I found this site for Linux related learning. I found three pdfs that I really would love to read:

• Network Administration
• System Administration
• Shell Scripting

For my own reference, and for any one else who may be looking for something like this: Linux Learning

Labels: learning, linux, todo

Today, I had some home made desert made of fruits and condensed and evaporated milk. I believe that the amount of fat in these milks is really high. But the amount of the milk we added to it was little (2 teaspoons I think).

I started thinking - if I eat something thats 20 grams, how can it result in me gaining more that 20 grams of weight. Then this is how I figured it probably is like: a 100kb file in 1 file system when moved to a different file system may take up 110kb in the 2nd file system - because of the file system's structure and layout I am guessing. Similarly, the 20 grams of food is processed and converted to our body's file system, which may result in us putting more weight.

Thinking about it some more, I figured the above would be a violation of conservation of mass; this is what probably happens when we eat high fat things like the condensed milk, and later drink water or other fluids, the body starts retaining it to match the fat level. Thus we put on weight. The key to our weight would then be the amount of water in our body (which - the water retention - would depend on the other things we eat).

Labels: food, health, random, thoughts

When I opened Firefox today, I saw a link in the home page to "Why is Firefox the safest web browser?" page. I just loved this line that I read :)

An international community of security experts is working around the clock to make your web browsing safer...It's like having your neighborhood watch led by a group of highly trained ninjas...

Hehe...that brought up a smile on my face :)

Labels: funny, random

I was designing a site this weekend when I needed some weather data. I started looking for solutions - I found phpweather and I found it to be an excellent tool. However, when I tried to query some "less" known cities, it returned nothing. One of the cities that I wanted the data for did not exist and I was disappointed.

Knowing that I can use sites like the weather network and get the weather data, I figured I might as well write my own class to fill this void. Thus was born the YWeather. YWeather is a php class that provides a class interface to access data from Yahoo Weather. It makes use of the Yahoo weather RSS feed.

The YWeather class uses MagpieRSS to parse through the RSS feed. When a location id is specified, the class parses the feed and gives a class interface to the weather data, making it easy to integrate to any web application.

Here is a test script I created to test the class, this list provides a list of the features of the class (I am too lazy to type this out :P)

$w = new YWeather("CAXX0504");

"URL: ".$w->getURL()
"Title: ".$w->getTitle()
"Skies: ".$w->getSkies()
"Skies Image: getImage($w->getSkies())."' />"
"Temperature: ".$w->getTemperature()
"Latitude: ".$w->getLat()
"Longitude: ".$w->getLong()
"isPM: ".$w->isPM()
"Published date: ".$w->getPublishDate()
"Description: ".$w->getDescription()
"Current Conditions: ".$w->getCurrentConditions()
"Forecasts: ".$w->getForecastsText()

The Yahoo feed provides 2 days forecast:

$forecasts = $w->getForecasts();
"Forecast 0 Day: ".$forecasts[0]['day']
"Forecast 0 Skies: ".$forecasts[0]['skies']
"Forecast 0 Skies Image: getImage($forecasts[0]['skies'])."' />"
"Forecast 0 High: ".$forecasts[0]['high']
"Forecast 0 Low: ".$forecasts[0]['low']
"Forecast 1 Day: ".$forecasts[1]['day']
"Forecast 1 Skies: ".$forecasts[1]['skies']
"Forecast 1 Skies Image: getImage($forecasts[1]['skies'])."' />"
"Forecast 1 High: ".$forecasts[1]['high']
"Forecast 1 Low: ".$forecasts[1]['low']

The class may be downloaded from here.
downloads/YWeather_w_magpie.zip

Labels: php, project, YWeather

What?

The strategy pattern is a design pattern designed to accommodate situations when there are multiple ways of doing some/similar thing(s). For instance this might be something along the lines of, if you are designing a media player - you would have different algorithms for playing the different media types. You could use the strategy pattern, as it deals with a common problem of playing a media file, except there are multiple ways it could be done (which algorithm depends on the media type).

How?

Each strategy is made into its own class, in our example above they may be classes like:

Class PlayWAV;
Class PlayMP3;

Each of the above class would implement the IStrategy interface (defined below):

Interface IStrategy {
// This is the function that is called to execute this strategy
public function execute();
}

A pseudo-code (may look similar to PHP code) implementation would look like this:

class PlayWAV implements IStrategy {
// Constructor: Information needed to execute the strategy may be passed through the constructor
public function PlayWAV(File fileObject);
// This needs to be implemented to satisfy the interface; this is the function that would be called to execute the strategy
public function execute();
}

class Context {
public function main() {
...
if (filetype(...) == "WAV") {
$strategyA = new PlayWAV(...);
$strategyA->execute();
} else {
$strategyB = new PlayMP3(...);
$strategyB->execute();
}
...
}
}

Why?

Why the heck would you do this? and not just code everything using an if/else? Well, this provides a clean separation - each strategy is its own entity - this reduces any tight coupling that may be formed knowingly or unknowingly. Since this is build with loose-coupling, you can change each without worrying about affecting the other, and new strategies may be developed independent of the application code and be integrated into the application with ease.

Example

This whole post was explained using an example, another great one can be found here. This one uses the strategy pattern for form validation in PHP.

And now with that I will end this post. Ciao.

Labels: patterns

Observer Pattern: When objects have a one to many relationship, i.e. many objects need to be updated when one object changes, and the number of these objects is not known ahead of time, this pattern can be used to implement it.

We begin by implementing 2 interfaces:

• IObservable: This is the object that gets observed - whose change would affect other objects
  
• IObserver: This represents objects that are the observers

Here is a pseudo-code implementation of the interfaces:

Interface IObservable {
// The attachObserver function adds the passed object to an array
public function attachObserver(obj);
// The detachObserver function removes the passed object from the array
public function detachObserver(obj);
// Notify all the objects in the array - loop through the objects and call the update method
// Note: All the elements in the array implement the IObserver interface and hence
// support the "update" method
public function notify();
// Function would be called by the Observers to get state information about the object
public function getState();
}

Interface IObserver {
// The method that performs the action that needs to be done on change of the observable
public function update();
}

The actual observer and observable classes would implement these interfaces.

Two examples of where you might be using this:

• In a web application, you may register screens with your business model objects (representing underlying data) - hence when the model gets updated, the screens get updated automatically.
• Another example may be, say you are making a game - and you when 1 object performs a task - such as a commander issuing a fire order, all units within the commanders range should fire (they would have registered with the commander object - and as they observed a change, they perform an action).

We have covered what the observer pattern is, how it is coded, and two examples of where it may be used. The answer for the why is the same as why use design patterns (see the post on Design Patterns in general). With that I will end this post. I hope someone, someday, somewhere (may be myself) will find this useful. :)

Labels: patterns

Design patterns: are general solutions to commonly occurring software design problems.

Why patterns? Some problems occur often is software design, and these general solutions avoid having to reinvent the wheel over and over again. The patterns have been looked at by so many people and has been refined well that when they are understood and implemented correctly they can save time, will work efficiently and enable more effective/productive discussions among developers.

I have been exploring patterns recently and I thought I would post about them here

Labels: patterns

Google's chrome is out and its in beta. My very first impression of chrome, was mediocre. I didn't know why another browser? and what is special about this one? It's new different look did not dazzle me either. I didn't spend much time on it though...there was work to do (I was at work and stumbled upon it when I was going to do a search).

Labels: random