I was getting the following error:

File “/Library/Python/2.6/site-packages/Django-1.3-py2.6.egg/django/db/backends/mysql/base.py”, line 14, in
raise ImproperlyConfigured(“Error loading MySQLdb module: %s” % e)
django.core.exceptions.ImproperlyConfigured: Error loading MySQLdb module: dlopen(/Users/eamonnfaherty/.python-eggs/MySQL_python-1.2.3-py2.6-macosx-10.6-universal.egg-tmp/_mysql.so, 2): no suitable image found. Did find:
/Users/eamonnfaherty/.python-eggs/MySQL_python-1.2.3-py2.6-macosx-10.6-universal.egg-tmp/_mysql.so: mach-o, but wrong architecture

This was a complete mix up between 32bit and 64bit Python libraries working together with MySQL.

To fix it I put the following in my .profile file

export PATH=$PATH:/usr/local/mysql/bin

export CC=”gcc-4.0″
export CXX=”g++-4.0″

export PYTHONPATH=”/opt/local/Library/Frameworks/Python.framework/Versions/2.6/lib/python2.6/site-packages/”
export DYLD_LIBRARY_PATH=/usr/local/mysql/lib/
export ARCHFLAGS=’-arch i386′
export VERSIONER_PYTHON_PREFER_32_BIT=yes

After adding this I ran a clean, build and install on the mysql-python library and everything worked! Phew!

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

I really like the stricter typing of signals compared to events.  For me, strict typing means that my code is checked by the compiler (instantly, at compile time) as apposed to being checked by the AVM (eventually, at runtime).  I have had countless times where I have seen code fail due to the event types declared in the handler method being wrong, even when the string values are stored as variables instead of using literals. The checking that event handlers are added correctly is not checkable by the compiler.  This means we need to either blindly hope it all works out or rely on testing.

Signals (out of the box) fixes this issue but there is still another issue for me, the contract between an event (also a signal) and its handler.  With events there are two contracts, the event type (the Event.type String) and the event data.  Signals (out of the box) handles the event type issue by moving the name of the type into an interface as a signal, which is a great idea!  The data problem is harder to solve.

There are two checks that should be performed on the data.

The first is validation. At the moment this is limited to type checking.  When you set up a signal, you specify that the signal should be an int, String etc.  I think this is a great start but I think there should be more (optional) validation checks available; range checks for ints and regex checks for Strings.  When these validations fail then the signal should have a built in mechanism to throw an InvalidSignalError.  This would tighten up the robustness of projects using signals and would definitely reduce the amount of code I write.

The second check is verification. This is a lot harder to check but is a much more valuable check to perform. I think this is up to developers to check when developing. I am currently using signals to send messages between objects. I like to keep the implementation of my objects hidden from others so when writing a class I am always mindful of what values are available to other objects. So, when writing a signal I often find myself doing the following:

public class ShowScreenSignal extends Signal
{
private static const MENU:int = 0;
private static const PLAY:int = 1;
...
public function ShowScreenSignal()
{
super(int);
}
public function dispatchMenu():void
{
dispatch(MENU);
}
public function dispatchPlay():void
{
dispatch(PLAY);
}
...
public function isMenu(message:int):Boolean
{
return message = MENU;
}
public function isPlay(message:int):Boolean
{
return message = PLAY;
}
...
}

This means in my controller/mediator I call signal.dispatchPlay() and in my listener/command I check signal.isPlay(message) to check the message. This means nothing knows about the message values other than the signal. I can change the message to be a String without changing any of my controllers/mediators/command. This is better encapsulation. This works really well when using RobotLegs + Signals as you can subtype your command classes and have a condition in your execute method if (message.isPlay(message)).

This is solving one problem. I want to have one signal with many handlers based on the message. eg:

public class ShowPlayCommand extends SignalCommand
{
[Inject]
public var message:int;
[Inject]
public var signal:ShowScreenSignal;
override public function execute():void {
if (!signal.isPlay(message)) {
return;
}
//do something
}
}

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Here is the PHP I used to get the feed of mypage.

<?php
//config
$appId = "999";
$appSecret = "I_LOVE_ROBOTS";
$feedURL = "https://graph.facebook.com/mypage/feed";
$limit = 10;
//script
$accessTokenUrl = "https://graph.facebook.com/oauth/access_token";
$parameters = "client_id=$appId&client_secret=$appSecret&grant_type=client_credentials";
$accessToken = file_get_contents($accessTokenUrl .  "?" . $parameters);
$parameters = "$accessToken&limit=$limit";
$result = file_get_contents($feedURL . "?" . $parameters);
?>

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

What is unit testing
Unit tests are methods that run in order to verify the output of a method is what is expected when given a predefined input. This is useful as you can check if your code does what it should. There is a whole world of information on this on the internet. Check out test driven development.

History
There used to be a few different unit testing frameworks – flexunit, fluint and asunit. asunit was the fastest to run but has not been too popular. I am not sure why. Fluint was a flex-centric testing framework with stuff like ui impersonator (mocking). Flexunit was the most used.

Current
Flexunit was taken on (again) by Adobe and merged with fluint. After adobe took it on again they named it version 4, probably to bring versioning inline with Flash Builder and flex. with this change they improved the API to introduce metadata for methods so that they are run before, after and as test methods. It is now distributed with hamcrest (same as the java hamcrest library) and a number of runners and listeners. It is the most used and it is the one i would recommend.

How it works
You write the unit test in any of the supported styles (flexunit 1, flexunit 4 or fluent or maybe even in another style) and you mark them to run with the associated runner (using metadata). You then run the tests using that test runner. Whilst the test runs a listener is also run. There are multiple test listeners, they are for different environments – to be run on a ci box, in the browser, in the IDE etc.

Continuous Integration
You cannot currently run unit tests without a flash player. You cannot currently run a flash player without a virtual frame buffer (think that is the term) or without a window manager running. With hudson (or jenkins now) you can install and run the vnc plugin, this has been the easiest way I have found so far. This takes care of all that stuff for you. It even deals with multiple vnc sessions at the same time if you have more than one hudson executor at a time.

Coverage and static analysis
You can get coverage from running flexcover and there is a flex pmd library released by adobe – there is the usual pmd offering and a cpd plugin.

How to run it all
you can run it all using maven (using the flexmojo stuff) or you can roll out your own ant stuff. Rolling out your own ant stuff is the way to go if you have a complicated dependencies system (like at my last job), otherwise if you just want to get the job done maven is probably the way to go.

I will attach a working example project tomorrow.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

• sourcing the ingredients
• preparing the ingredients
• preparing the workspace
• preparing the oven
• making the meal
• cooking the meal
• serving the meal

Using agile methodologies we would tackle each part of this process individually and then tackle the next only once it is completed.

As a novice chef, he would tackle getting the ingredients; Knowing what he am making, he would make a list of the ingredients and purchase only what was needed. As an experienced chef, he would buy more than what was needed, adding some for unexpected accidents. Either way, he would have completed the first task and would be ready to start the second. Within this first step we have some technical debt, we have made decisions that we need ingredients and which ingredients. As a junior chef, if he makes a mistake with some of the ingredients he am stuck. He have not allowed for any extra ingredients. Even as the experienced chef, he could face issues if the person we are cooking for changes their mind he is stuck. These are the obvious problems. There are more subtle issues that could occur. Our agile chef could be preparing a meal for somebody with an alergy. He need this knowledge in order to buy ingredients but may not find this out until the serving the meal stage. At first it looks like the agile chef had an impossible task of sourcing ingredients for a meal for people he knows nothing about. This is where the ‘business product owner’ comes in. This is usually a stake holder who has knowledge of the current business requirements. In this case, it would be the waiter. When taking the customers order, the waiter should check if the customer has any alergies. This is a common problem with projects I have been on. The business product owner does not know all of the customer requirements. The lack of requirements gathering is often blamed on ‘being agile’ and ‘being light on planning’. This reminds me of a saying used a lot in my school:

If you fail to plan, you plan to fail

This first simple task of sourcing ingredients could have caused the whole meal to be a failure. This illustrates the importance of both the chef and the waiter in this scenario. Without both playing their part we would fail at the first hurdle. This is why we need help with our meal. We need somebody who knows the ropes who can give both the waiter and the chef advice, to ensure our meal is a success. This is where the head chef and the head waiter come in. They are responsible for ensuring we are doing all that we should be. In the engineering world I believe this role is between a technical lead, a technical architect and a business analyst. Without knowledge of how to lead a team how can this person manage resources, conflict and moral (a head chef checks managing in their). Without knowledge of architecture how can they ensure the team are not making decisions that will cause problems in the future (the head waiter knowing the menu and its ingredients).

So far, my agile chef is not looking too ‘agile’. He cannot succeed on his own. This is not what agile is about. Having a small team (or one/two people on their own) is not an agile principle. It is peoples expectation of agile.

To recap, our agile chef needs a head chef to give guidance and a waiter to check requirements. This waiter also needs help, this is in the form of a head waiter. In order to cook our meal we need four people! This seems a lot, despite how complicated the first step has been.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Agile projects produce code that is under engineered.

I do not think this is a fault of agile methodologies. I think this is down to the management of the code base. This is where the self managing team needs to step up. The team needs to know when to refactor/invest in their code base. They need to know how to communicate with the business if deadlines are too tight and they need to think where they are going wrong if their code is inflexible so that it doesn’t happen again.
The main cause of under engineered code I have seen is people not thinking about the cost of change. This reminds me of a quote from my old technical architect:

Make a decision at the latest, most responsible time

This is really not that easy. I don’t think it is always possible to make a decision at the most responsible time. Sometimes there is not enough time to realise when the most responsible time is and sometimes you do not have enough information to make the decision. The result of this is what I used to see as technical debt. I used to see technical debt as the mistakes made when you were lazy or when you made a bad decision. It wasn’t until recently that I have seen every piece of code as technical debt. This reminds me of a quote from another technical architect I worked with:

The best code is no code

I now see this as:

No code = no technical debt = low cost of change

This may sound like I do not want to write any code, which is very far from the truth. I am starting to see the implications of writing code and all of the baggage that comes with it.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

What is agile software engineering?
I think it is best described quoting the agile manifesto:

Individuals and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration over contract negotiation
Responding to change over following a plan

That is, while there is value in the items on
the right, we value the items on the left more.

For me, agile software development is about breaking development into smaller parts (iterations), which are easier to define and manage. Each small part should be dealt with only once the previous one is completed and each part should be discussed with somebody who knows the current business requirements before it is started. This is to keep the feedback loop as small as possible. This means that the team’s work is always providing business value and is always aligned with what the business wants at the time.

Saying this is much easier than doing it. There are many difficulties avoiding up front planning:

• Planning is tough as people just want to get ‘stuck in’, so when a piece of work is completed they want to start the next piece as soon as possible, skipping/rushing planning.
• Planning is tough as people from the business are not always available for meetings. This means that planning has to wait or is rushed.
• Some people find that working on smaller iterations means they lose site of the ‘bigger picture’.
• It is harder to estimate the size of the whole project up front as there is no up front design.
• The code base must be of good quality to cope with change of requirements. There is a need to refactor the code base to keep it free from software rot.
• This methodology is new and people are not used to it. Trained/experienced people are hard to find.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

I am going to post a series of articles about the cool work I am getting up to at the moment. It will be some actionscript/facebook/video based articles so stay tuned!

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

It uses a urls file to interpret the incoming request, separating out the params from the action, eg /customer/1/delete would be interpreted as delete customer 1.

The urls file links the request to a view function. This view function uses the model objects to modify the values in the database and then passes them onto a template. This template then displays them!

The model objects are stored in a database and are defined using python. There is not really any need to know sql. Although, I would always suggest knowing it!!!

That is it, really! There are loads of great features that I will cover soon!

I am doing my first commercial project in DJango and it is going well! I will post on it once it goes live!

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

I am working on a secret project at work and I thought it would be good to share what I have learned. I want to point out that I had no 3d experience before I started this! So you should be able to do this too!

I have been using papervision to render a texture map. It takes a black and white jpeg which marks shallower and higher areas on a terrain. Papervision converts this into a 3d terrain, mountains and ditches. I also have a car which is loaded from a dae file. Papervision loads this file and renders it. I am then using Jiglibflash to create JBoxes, JSpheres and others. These ‘J’ shapes are used for the collision detection. You can even have a Papervision sphere inside a JBox and the physics engine will treat it as a box. It does all the collision detections for you. It takes care of friction and gravity. You can apply forces to the shapes. It is really straight forward handling simple shapes. The next stage of my project is to start describing complex shapes using these J shapes. It is going to be tough!!!

Using these libraries has been great! It has been a bit of a pain as Jiglibflash uses Papervision (you can also choose to use Away3D) and you need to ensure you use working sets of Jiglibflash and Papervision. A lot of the examples use strange combinations of versions so beware!

I will post the other stuff I discover as I discover it!

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.