Businesses may be created for a multitude of reasons, but one that is common to almost all business is the intention to make money. In plenty of cases, the money making aspect of a business is often considered its primary role. However, it is not as simple, and businesses must take up several roles and balance them appropriately. The most important role for any business is to innovate and create in order to improve and develop humanity.

If humanity does not advance it shall surely, ultimately crumble as many pressures are put on it. In recent times for example: climate change and depletion of natural resources — the end of our current era of certain technologies.

The concepts of value and business are dependant on the existence of humanity. After all, humans created them. Therefore, if business doesn’t play its part in the advancement of humanity, thus increasing its likeliness of eventually failing, businesses themselves will also cease to exist, or at least function effectively. Consequently all other roles of business are fundamentally underlined by the role to serve to humanity. However it is not the sole responsibility of business to develop humanity. Governments and individuals must also play their part.

Although the advancement of humanity should be a key priority of business, many do not give a significant enough focus to it in order to, for example, bolster profits.

The high priority of contributing to the progress of humanity gives rise to the role of providing employment for individuals. Each individuals possesses varying skills and to varying degrees. So that humanity continues progressing, everyone’s abilities should be used to their maximum via employment. Also, in the world we live in nothing is truly free, so one must have access to income of some kind. Paying salaries according to how much ‘work’ an individual does is a as-fair-as-it-can-reasonably-get way of supplying someone with income, whilst still respecting the primary role of business; to evolve humanity.

This need for employment gives rise to another role that business should put into high regard: providing goods/services to individuals which they could not have [easily] provided on their own. Certain goods and services can allow people to live their lives more efficiently and get more enjoyment out of it. Businesses that produce such goods and services give access to such items to people who lack the ability and or opportunity to produce the product themselves. Conversely however, personal development may be stifled. When things are easily available people may reject or dismiss the opportunity to learn new skills.

Another fundamental role of business is to add value to raw materials. In fact, this is arguably the basis of “business;” takes “X” raw-material as input, performs some process to add value and pushes out “Y” goods or service. So you may assume that this should be considered the most important role, however it must be appreciated that the whole process of adding value is done solely to make profit. This, as previously discussed, does not –or should not– take precedence over the businesses responsibility to contribute to humanity.

One of the main benefits of business is the fact that it can be used to distribute wealth. They pay taxes which is then, theoretically allotted by the government to those who is believed to need it. But the fact that this distribution is required suggests that there are more foundational issues, such as people not being paid appropriately according to the job they do. So, instead of businesses focusing their efforts on the role in the distribution of wealth, they should tackle the principal issues instead.

Yet another role of business is to bring money into the United Kingdom; or any country for that matter. There is little to no doubt that money coming in to UK has benefits. The money funds investment in education and healthcare via taxation for example. But, ultimately this means money must leave another country, potentially depriving them of the same investment, hence any local benefit may be negated.

In any case, nowadays people have the chance to, relatively easily, move to another country with more economic opportunities. So, placing a high-priority on bringing money to the UK is comparably not all that important.

In conclusion, business may indeed assume multiple roles, but these must come second to contributing to humanity. For, if it doesn’t, and too many businesses adopt this flawed prioritisation scheme, humanity will stumble and business will subsequently get destroyed, or be dramatically changed in unforeseen ways. Business depends on humanity, so it’s right that it contributes to its future direction. Besides, the betterment of humanity is in business’ interest for that reason.

One such part would be the asset management stuff. In previous projects having anything too sophisticated would have been overkill, but this time I felt it was the appropriate to do something a little more … elegant. My main motivation largely came from the fact that having asset-managing code all over the place is, frankly, messy. So, I derived the following requirements of my soon to be super-awesome-sexy-asset-thingy!

• Abstraction of the file-system. Worrying about case-sensitivity and whether I should be using forward or backslashes isn’t a very productive use of my time.
• Extensibility. Although in my case it was only used for handling graphics, audio and fonts, it should be easy to add the ability to handle arbitrary resources at will.
• Flexible, especially in regards to loading policies (Caching and such.)

from os import listdir, getcwd, sep
from os.path import join, split, normpath, isdir, isfile
from string import letters

assets = None

class Loader(object):

    def __init__(self, path):

        self.path = path
        self.reference = None

        fname = "".join(split(self.path)[-1].split(".")[:-1])
        self.flags = fname[fname.find("[") + 1:-1].lower()

        if "l" in self.flags:
            self.reference = self.load()

    def fetch(self):

        if not self.reference:
            self.reference = self.load()

        if "t" in self.flags:
            # Unbind the reference as to force reloading.
            ref = self.reference
            self.reference = None
            return ref

        return self.reference

    def load(self):
        raise NotImplementedError

class AssetLibrary(object):

    def __getattribute__(self, name):
        attr = object.__getattribute__(self, name)
        if isinstance(attr, AssetLibrary):
            return attr
        else:
            return attr.fetch()

def _gen_file_list(path):

    file_paths = []

    for entry in listdir(path):
        entry = normpath(join(path, entry))

        if isdir(entry):
            if not split(entry)[-1].startswith("."):
                file_paths.extend(_gen_file_list(entry))
        elif isfile(entry):
            file_paths.append(entry)

    return file_paths

def load(roots, loaders):

    global assets

    assets = AssetLibrary()

    file_paths = []
    for root in roots:
        file_paths.extend(_gen_file_list(root))

    for path in file_paths:

        extension = "." + path.split(".")[-1]
        path = ".".join(path.split(".")[:-1])

        for loader_class in loaders:

            if extension.lower() in loader_class.extensions:

                names = ["".join(c for c in seg.lower() if c in letters)
                                for seg in path.split(sep)][:-1]
                # Ignore the loader flags to get the "real" name...
                fname = path.split(sep)[-1]
                chars = []
                for c in fname[:fname.find("[")].lower():
                    if c not in letters:
                        chars.append("_")
                    else:
                        chars.append(c)
                names.append("".join(chars))

                lib = assets
                for name in names[:-1]:
                    if not hasattr(lib, name):
                        setattr(lib, name, AssetLibrary())

                    lib = getattr(lib, name)

                setattr(lib, names[-1], loader_class(path + extension))

Fairly sizable (for Python that is), weighing in at roughly 150 lines. The concept however, isn’t too complex. You have all your files arranged in sensibly named directories; “SFXs”, “Images” and so on. Essentially, load() will recursively search through these directories –provided by a list of strings as an argument roots– and build a tree-like object of AssetLibrary and Loader instances. AssetLibrary roughly translate to “a directory”, and Loader as “a file”.

AssetLibrary does a bit of magic to make sure everything works properly. The __getattribute__ method is overridden to handle instances of Loader in a special way. I say “special”, all it does is invoke the fetch method of the loader when accessed and return the returned value of that, instead of the loader it self. It’s more cosmetic than anything else and isn’t a requirement by any means.

I keep referencing “loaders”, yet have neglected to explain properly what they are.  The file analogy is a little misleading. Loaders are interfaces to the resources, rather than representing the resources directly; although this is handled transparently. The idea is that you’ll create your own sub-classes of Loader to handle the various types of assets you have. In most cases all you should need to do is implement the load method which should return an object that exemplifies a ‘usable asset’. For example, an image loader would return a pygame.Surface…

class GraphicLoader(Loader):

    # Define what file extensions are associated with this loader.
    extensions = [".jpg", ".jpeg", ".png", ".gif"]

    def load(self):
        print "Loading image:", self.path
        return pygame.image.load(self.path)

In some cases, something a little more fancy may be required. When you create a pygame.Font instance, you need to pass a size argument to the intialiser. There is no obvious way to do this…

class FontLoader(Loader):

    extensions = [".ttf"]

    class FontSizer(object):

        def __init__(self, path):

            self.path = path
            self.cache = {}

        def __call__(self, size):

            size = int(size)

            if size not in self.cache:
                self.cache[size] = pygame.font.Font(self.path,  size)

            return self.cache[size]

    def load(self):
        print "Loading font:", self.path
        return FontLoader.FontSizer(self.path)

This adds another layer between the file and the ‘usable asset’ so we can get our requested font-size. In order to keep it pretty, we introduce a FontSizer class which produces a callable that takes one and only argument: size. Then, it loads the font as per usual, storing it in a cache for faster access. In the end it would look something like…

# Load "My Awesome Font" at size 50
assets.fonts.my_awesome_font(50)

Now, what if you don’t want caching? No problem, just tell the FontSizer. You may have noticed that loaders have an attribute by the name of “flags”. It is the only real way to indicate the loading policy to use for each file. Each filename includes a series of one-character flags just before the file-extension, surrounded in square-braces.

my_file[flags].ext

Three flags are used by the Loader base-class, they are

• T,  ”tee”; the loader will temporarily load the asset, as in, it will not be bound to the loader, therefore, once all references are gone, it will be freed.
• L, “ell”;when specified, the loader will load the asset immediately (during initialisation) and bind the reference to itself.
• D, “dee”; similar to L except that the asset is only loaded upon first request. This is the default behavior.

You can of course define your flags as you wish. Parsing of the flags is handled in Loader.__init__, so nothing messy for you to do. Merely use membership test, if-in, on the flags attribute.

This solution may not be ideal for some, and I’d be lying to say if I was totally happy with it. But, it gets the job done, and manages to maintain it’s dignity in the process.

If you’re crazy enough and would like to use the any of the above in your own work, consider it LGPL’d.

Not too long ago I came across a brilliant tutorial on implementing 2D particle engines by RB Whitaker. Sadly it was aimed at the C#/XNA platform, which wasn’t much use to me. So, I decided to port the example to Python/PyGame. Surprisingly it was very easy and the resulting Python code is almost identical in most respects. (Yay C#)

The three resources required (circle.png, star.png, diamond.png) can be downloaded from the link provided above.

class Particle(object):

    __slots__ = ["texture", "position", "velocity", "angle",
                    "angular_velocity", "colour", "size", "ttl"]

    def __init__(self, texture, position, velocity, angle,
                    angular_velocity, colour, size, ttl):

        self.texture = texture

        self.position = Vec2d(position)
        self.velocity = Vec2d(velocity)
        self.angle = float(angle)
        self.angular_velocity = float(angular_velocity)

        if not isinstance(colour, pygame.color.Color):
            self.colour = pygame.color.Color(*colour)
        else:
            self.colour = colour

        self.size = float(size)
        self.ttl = int(ttl)

    def update(self):
        self.ttl -= 1
        self.position += self.velocity
        self.angle += self.angular_velocity

    def draw(self, surface):

        source_rectangle = self.texture.get_rect()
        origin = Vec2d(int(self.texture.get_width()/2),
                        int(self.texture.get_height()/2))

        # As there is nothing (AFAIK) like XNA's SpriteBatch.Draw() for
        # Pygame we'll implement it's drawing logic our selves.

        # The source_rectangle isn't really needed, because by default
        # the whole surface will be blitted, but is incldued to maintain
        # compatibility with the tutorial.

        texture = self.texture.copy()

        filter_ = pygame.surface.Surface(texture.get_size())
        filter_.fill(self.colour)
        texture.blit(filter_, (0, 0), None, pygame.BLEND_RGB_MULT)
        del filter_

        texture = pygame.transform.rotozoom(texture, self.angle, self.size)

        surface.blit(texture, tuple(self.position - origin),
                            source_rectangle)

class ParticleEngine(object):

    def __init__(self, textures, location):

        self.emitter_location = Vec2d(location)
        self.textures = textures
        self.random = random.Random()
        self.particles = []

    def _generate_new_particle(self):

        # Random().random() behaves exactly like Random().NextDouble()

        texture = self.random.choice(self.textures)
        position = self.emitter_location
        velocity = Vec2d(
                        float(1) * (self.random.random() * 2 - 1),
                        float(1) * (self.random.random() * 2 - 1),
                        )
        angle = 0
        angular_velocity = 0.1 * (self.random.random() * 2 - 1)
        colour = pygame.color.Color(
                                    self.random.randint(0, 255),
                                    self.random.randint(0, 255),
                                    self.random.randint(0, 255)
                                   )

        size = self.random.random()
        ttl = 20 + self.random.randint(0, 40)

        return Particle(texture, position, velocity, angle,
                            angular_velocity, colour, size, ttl)

    def update(self):

        total = 10

        for i in xrange(total):
            self.particles.append(self._generate_new_particle())

        for particle in self.particles:
            particle.update()

        # Filter out dead particles
        self.particles = [particle for particle in self.particles if particle.ttl >= 0]

    def draw(self, surface):
        for particle in self.particles:
        particle.draw(surface)

if __name__ == '__main__':

    # Set up display...
    screen = pygame.display.set_mode((400, 300), 0, 32)  

    textures = []
    textures.append(pygame.image.load("circle.png").convert_alpha())
    textures.append(pygame.image.load("star.png").convert_alpha())
    textures.append(pygame.image.load("diamond.png").convert_alpha())

    particle_engine = ParticleEngine(textures, Vec2d(0, 0))

    while True:

        screen.fill((0, 0, 0))

        for event in pygame.event.get():

            if event.type == pygame.QUIT:
                pygame.quit()
                exit()

        particle_engine.emitter_location = Vec2d(
                                                pygame.mouse.get_pos()[0],
                                                pygame.mouse.get_pos()[1]
                                                )

        particle_engine.update()
        particle_engine.draw(screen)

        pygame.display.flip() 

The Vec2d class is taken from the PyGame cookbook and will need to be in the namespace for the code to work.

Obviously, being Python, iteration can be a bottleneck, so large particle lists may prove problematic; although, I haven’t noticed any issues so far. We make use of __slots__ to minimise memory, and instance creation overhead. It is technically a premature optimisation, but how much harm can it do really? …Really?

Particle rotation doesn’t have much effect, due to an implementation difference with XNA’s SpriteBatch.Draw() and PyGame’s transform.rotozoom(). Seeing as I don’t know how SpriteBatch.Draw() handles angles, I couldn’t provide an accurate work-around. However, you can change the following line to demonstrate rotation:

# in Particle.draw
texture = pygame.transform.rotozoom(texture, self.angle, self.size)
# becomes...
texture = pygame.transform.rotozoom(texture, self.angle*100, self.size)

Please note that rotation can cause the texture to appear off-center, but this can most probably be fixed easily.

It’s hard to deny that the “Social Media” is a bubble. Investment in online companies is immense right now. Just look at Facebook, currently valued at around 50,000,000,000 shiny US dollars. That places a price-tag of the average Facebook user at $1,000! Why is this significant? Because “Social Media” companies’ wealth comes from it’s users. Now, I don’t care how good your advertising programmes are, you are not going to get them to click ads to the tune of one (whole) grand in any realistic timeframe.

However, I think I should be clear about this, I don’t actually think that Facebook it self is over valued. Facebook is at that point where it has acquired such a strong, involved user-base that it has cemented it self in the history books alongside the greats such as eBay and Google. It even has a Hollywood movie about it! A movie… about a website!

The “Social Media” bubble will burst because of it’s overvalued nature, and some day, these people who have been throwing their cash at it are going to realise that it isn’t likely that there will be another Facebook. This follows the proud tradition in the technology world that there should be One Ring To Rule Them All; to set the standards. Just a few examples…

• Business and personal computing: Microsoft
• Web search and advertising: Google
• Massively Multiplayer Online Gaming: Activision Blizzard
• Secure web financial transactions: PayPal

My purpose of writing this isn’t to whine about “Social Media” though. For that we have The Oatmeal. Instead, I want to explain why have a if-you-can’t-beat-them-join-them relationship with Twitter et al.

Although I hate have a strong dislike of the “Social Media” culture, I do consider it a force for good in the technology world. As is known, plenty of investment has been poured into the web on the back of the glossy button clad 140 characters per hour, status-updating bandwagon. This has led to the rise of many sexy new things for us to play around with.

The rise of “Web 2.0″ plus it’s younger, in-bred cousin “Social Media” has definitely helped provide a strong case for spending the time and money to produce the technologies that will allow us to make better, faster and generally more awesome stuff (think HTML5) for the web. Furthermore, it created the perfect catalytic environment for really cool existing tools that were previously, barely used/known, to be shown off to the whole world. Remember Google with “Suggest”. I doubt Ajax would have exploded onto the scene so violently –leading to great innovations in user interaction with web sites– if Google hadn’t of shown it off in all it’s magnificent glory in such a public way.

Although “Social Media” could, economically speaking, blow up in many people’s faces, I don’t care as long as it continues to cultivate improvements in the way the web works. Therefore in conclusion, as Jeff Atwood mentions in his post about the web 1.0 bubble, things come and go in this wonderful industry, and each one has the opportunity to leave a “meaningful legacy”. I hope “Social Media” will be one of them.

From past experience I’ve learnt that if you’re going to plan ahead, make sure you do it well. If you don’t, not only have you wasted your time, but you’ll find that your following a path that can only lead to certain, in most cases metaphorical, death. A good plan is the foundation of a good project, a bad one is only going to come back to bite you in the ass at some time.

How you choose to plan varies greatly from person to person. Some like to doodle on whiteboards. Some like to make flow charts. Some like to sit down and write a write fancy technical documents that have lots of hyphenated words, bullet-points and acronyms. I used to be a whiteboard doodler myself, but I think that might all be over.

This may seem obvious to some, but planning code, in code surpasses all other methods in terms of productivity, motivation and detail. By “planning in-code” I really mean: using early prototypes as the plan –this doesn’t mean you shouldn’t have a clear idea of what you’re trying to achieve before you do it however.

Seeing as you’re always writing code, you are constantly contributing directly to the end goal. Even if you decide to completely rewrite from scratch, move to a different environment or even simply decide you weren’t approaching the task in the right way, you always have working prototypes to visualise progress.

Another great benefit I’ve found is that you have complete control of the level you are abstracted away from the real dirty work. You get to control how much detail you go into. It also enables you to progressively approach these parts of the task, therefore you won’t suffer burnout.

My plan for the bulk of what will eventually make up the plug-in’s core logic is contained in one modestly-sized Python script. Now all I have to do is translate the appropriate bits to fit within the FireBreath framework.

I’m feeling good about this little side-project of mine, and I’m sure its the decent planning that is the reason as to why its going smoothly at the moment. I suppose this could all be considered part of the ideology of “agile development“. I’m not really qualified to say whether it is or not, but whatever it is, I like it!

FireBreath is a framework for abstracting away all the gritty stuff required for producing browser plug-ins. It works for both NPAPI compliant browsers (Firefox, Chrome, etc.) and those that make use of ActiveX controls. It should also work on Windows, Linux and Mac transparently without any major hic-ups. When I stumbled across it after seeing it mentioned on Stackoverflow, it was music to my ears. No faffing about. Getting straight to writing code that does something interesting.

Now, this was all looking lovely. It seemed perfect for my needs. I checked the latest beta out of Git fine. Setting up a project was a breeze with the “fbgen” utility. However, immediately after I hit a 2 metre thick, steel-reinforced, concrete wall of pain, suffering and WTFs.

FireBreath makes use of CMake, a cross-platform alternative to Make. The FireBreath developers provide a good rationale for using it, which I respect. But, this CMake dependency nearly put a permanent stopper in my grand dreams of stealing Flash’s crown as King of the Browser Plug-ins.

Now, I should make it clear that it wasn’t really CMake’s fault, rather, my incompetence. All I wanted to do was make use of Python’s C-API, therefore, I had to make a few simple modifications to the CMakeLists and off and away I would be. This turned out to be the most categoric evidence of my amateurism, ever!

I spent a whole week on-and-off just trying to solve this little problem. At first I tried the good ol’ trick of starting at it for a bit, then trying it again in the hope that I was able to intimidate it in to co-operation. When that failed I tried Google which, considering it was a niche problem I was having, wasn’t too helpful. For pretty much every query I tried it gave me the CMake tutorial (which I read) as the first result and a bunch of mailing-list entries which I had the displeasure of trawling through. Gradually I managed to build up the scraps of information I had found into solution.

With my first few attempts I didn’t make use of the FIND_PACKAGE directive in CMake. It wasn’t for the want of trying; I tried FIND_PACKAGE(Python), but it ultimately failed. Things started to look up when I realised that I was meant to be using “PythonLibs” instead of “Python” –a very simple mistake, but it took me an age to track down. Next step was to link the Python library to my plug-in. CMake provides a nice TARGET_LINK_LIBRARIES for handling this, but I couldn’t find out the correct way to use it (I only came across it by chance reading of an old mailing-list). Eventually I ended up with the following which appears to work…


SET(PYTHON_INCLUDE_DIRS "/usr/include/python2.6")
find_package(PythonLibs REQUIRED)
include_directories(${PYTHON_INCLUDE_DIRS})
target_link_libraries(${PROJNAME} ${PYTHON_LIBRARIES})

It struck me that it took so damn long to come up with a four line answer. I’m sure its just my amateur enthusiast unfamiliarity with “build processes” that was a major factor. None the less, it works (I think) now. Finally I can get to admiring the awesomeness of FireBreath.

So! Although the nano has a small 624cc engine you mustn’t forget that it runs on petrol, a hydrocarbon, so when the engine does what engines do, it produces carbon dioxide and other harmful stuff which negatively affects our environment.

By making cars cheaper you allow more people to purchase them. Which means more people driving. Which means more carbon dioxide (and stuff) is being released into our atmosphere! Also it means more fuel being purchased which could mean higher prices at the pumps! Not that it bothers me…

So by encouraging more people to drive –Which essentially that’s what they’re doing– we are adding more pointless pressure on our planet. The target market for the Nano –I believe– is the less well off people in the world. There must a fair few of people that don’t currently drive but if you get all them people driving you are releasing more CO2! Mobility for the less well off is fine, but not at the price of humanity. 

The Nano, although economically a sensible and great step forward, I feel it’s a step backwards on the environmental front. I’m no tree hugger, I do the small things which we’re told so often does so much good, but I do feel we should stop putting economics before the greater good that is protecting our planet from ourselves.

A small suggestion. Try your name it may produce an interesting combination! If not try other words like, xylophone or supercalifragilisticexpialidocious or if that still don’t float your boat just smash random keys!

_{I did honestly try to spell ‘supercalifragilisticexpialidocious’ by myself. I was close, but no cigar, so I just looked it up}

Nearly everyday I reach into my pencil-case and I pull out a pencil, pen or a ruler but I never notice the junk that hides away in there. There seems to be no end to it, and perhaps by coincident, or perhaps not, it is a very TARDISy shade of blue.

There is the usual stuff: several pens, a few pencils, a calculator and not forgetting the seemingly pointless set square. But there is also car insurance applications? Two coursework drafts, one of them not even mine! A maths test –which I never plan on handing handed back. Twelve sheets of blank paper. Pencil sharpenings from so long ago they’ve started decomposing. 132 centimetres worth of shattered rulers. Some plastic wrapping that appears to be for a ruler/geometry-set or small calculator, but it has absolutely no markings to indicate which. There is also the early blueprints of a cat mincing machine.

It truly does seem to be bigger on the inside than out. But ponder this, how comes there doesn’t seem to be a single pencil case IN THE WORLD that can fit a full length 30 cm ruler!?