disfunksioneel

backing up your delicious bookmarks

2011-04-28T00:49:00.000-07:00

As some may have heard, delicious is being acquired by AVOS. You can transfer your bookmarks, but I decided to make a backup of my bookmarks, just in case.

The quickest way I could think of, was using the RSS feed.

Log into your account on the web and get the URL for the "Private RSS Feed" at the bottom of the page. Change the last part of the URL to be larger than the number of bookmarks you have saved on delicious.

Ex. change

"http://feeds.delicious.com/v2/rss/user_bob?count=15"

"http://feeds.delicious.com/v2/rss/user_bob?count=1000"

in the URL.

You can safe the page your browser displays when you enter the URL, or you can use wget or another utility to download the feed.

The data is now in your hands and it's up to you to keep it safe.

High resolution dependency graph

2011-04-06T14:13:00.000-07:00

I generated a high resolution Gentoo Linux package dependency graph.

Packages are ordered according to their complete Gentoo package name. The result is that the graph shows groupings of packages with lots of dependencies or reverse dependencies. These groupings typically fall under dev-*, kde-*, gnome-*, x11-libs or media-*.

Text labels are only generated for packages with more that 10 dependencies or reverse dependencies. The numbers in brackets after the package name, is the number of dependencies followed by the number of reverse dependencies.

Packages grouped by categories (1600x1600)

A package of particular interest is app-text/sword. It has a total of 165 reverse dependencies!! This is very large number of packages that depends on app-text/sword! All of the packages that depends on app-text/sword seems to be different modules specifically for sword.

A nice picture of (dependency) hell

2011-04-04T13:53:00.000-07:00

"Dependency hell" refers the difficulty that arise when installing a software package that requires a lot of other software packages to be installed. The required software packages (or dependencies) may themselves require other software packages to be installed.

To give a better idea of why this can be difficult, I created the following graph.

63988 Dependencies between 14319 software packages

This graph shows the dependencies between software packages in the Gentoo Linux operating system. In total there are 14319 packages with 63988 dependencies between them!

Packages are drawn on the circumference of the circle and a dependency is indicated by a line draw from one package to another. The color of a package is randomly generated, while the color of a line is determined by the package that is required by the other packages.

Every package has a line starting on the rim of the circle drawn radially outwards. The length of the line is determined by the amount of other packages that depend on the package.

Here is a closeup of a small part of the graph:
The most common dependencies are development tools. This is a list of the 15 packages with the most reverse dependencies:

Package	# of reverse dependencies
dev-lang/perl	1559
dev-util/pkgconfig	1195
dev-lang/python	1047
x11-libs/gtk+	1042
sys-devel/libtool	950
app-arch/unzip	878
sys-devel/automake	818
sys-devel/autoconf	766
dev-libs/glib	652
x11-libs/qt-gui	612
virtual/jdk	588
sys-apps/sed	575
x11-libs/libX11	545
app-admin/eselect-python	496
dev-util/cmake	455

The graph was created with data obtained from the Gentoo Portage tree and drawn using the Python Image Libray (PIL).

Working towards software quality

2010-12-09T08:06:00.000-08:00

Software quality remains to be an illusive topic. It's hard to define, measure or enforce.

One way to to define software quality is how well functional and non functional requirements are met. This implies that requirements exists and are accurate. It also implies that the quality of the software changes whenever the requirements change! This is typically the type of software quality that will keep your manager and your client happy, for the time being...

For software that will be used and modified after the initial requirements have been satisfied (most software fall into this category), quality needs to be measured on a deeper level. Aspects like maintainability, changeability, testing, etc comes into play. This however remains hard to measure and enforce.

There are however certain things that contributes to software quality that aren't that hard to measure or implement. Here is a list with some of those things:

Requirements
Software design
Coding standards
Version control
Bug tracking
Source code documentation
Code reviews
Automated clean builds
Automated testing
Code analysis tools
Config management
User interaction

It may be worthwhile to elaborate on topics such as requirements, design and documentation. These are things that can cause considerable overhead when done incorrectly. It a good idea to approach requirements, designs and documentation as tools that are used to arrive at a certain point. As such they contribute to the quality of the software, but does not necessarily represents the system in its current state.

Having all of the above mentioned things in place will not equate to high quality software. It still remains something that needs to be propagated and pursued by all involved parties.

Deep indentation

2010-03-15T06:02:00.000-07:00

Having many levels of indentation can seriously hamper readability (and thus the understandability) of code. These indentation levels are normally a result of nested conditional statements and try-catch blocks.

How many levels are too many?

Many people feel that 4 levels of indentation is the limit. This is not a hard rule, but serves as a good guideline.

Another guideline is that your source file should never contain a line of code that gets wrapped around or needs side scrolling. Unfortunately this is dependant on your screen resolution and font size. For some people the limit is at 80 characters (the Linux kernel uses this measure) other people feel that this measure is outdated and wastes screen real estate.

The basic idea is that whenever the amount of indentation levels make it difficult to understand the code, it's too many.

How do I fix it?

One way suggested in “Refactoring: Improving the Design of Existing Code” by Martin Fowler is replacing the conditional with Guard Clauses. Ex.

method body
if condition1 is true
  if condition2 is true
     …
  else
     …

can be replaced with

method body
if condition1 is false
  return
if condition2 is true
  …
else
  …

Sometimes it is possible to rework the logic of the method. You may find that some conditionals are excessive or that it can be simplified further.

Many times though, this is an indication that other problems exist in your code. Things like methods that are too big, constant testing for null, using lots of “Type Codes”, implementing different states in one object, etc. In a lot of these cases, addressing the other problems will also fix the problem of multiple indentation levels.

Method stubs and Unused Code

2010-03-08T00:29:00.000-08:00

A common thing we all do is creating stub methods on a class and implementing methods we do not immediately use. Both can lead to errors and incorrect results in parts of the code that use method stubs or (previously) unused code.

Method Stubs

Method stubs are functions that aren't implemented. The method body is normally empty, or returns a hard coded value in order to compile. Luckily they are easy to spot. There's nothing wrong in using method stubs when writing and testing the initial interface of a class, but no method stubs should be left hanging around in your code! If you do have method stubs, this can be corrected in one of two ways:

Remove the method stub
Implement the method stub

Most of the time you should remove it. You should only implement a method stub if it is actually used!

Unused Code

Another problem that is more difficult to spot is unused (and untested) code. If you are writing a library that are used by other people you cannot easily determine what methods are used and which ones are not. In this case your test cases should test all methods (actually all code paths).

The best way of avoiding unused methods, is to only create a method when you need it. This is stating the obvious, but we all tend to implement methods we don't use immediately (or ever). Lets look at an example:

A common class we all need and code at some stage is a Vector class. There are many well defined operations that can be performed on a vector, like calculating the length, converting it to a unit vector, addition, subtraction, dot product, cross product, etc. It is very easy to quickly go and define a vector and all the methods for working with it.

Chances are good that you do not immediately need all the methods that you thought up for you class and that that they will contain bugs. Once again, there are two ways of solving this:

Use the method (in a test case)
Remove the method

Option 1 should be executed if you still foresee that it is very likely that the method will be used in the near future or if the implementation entailed a large investment of effort. Most of the time you should strongly consider removing the method.

To sum it up: When writing code, be minimalistic, when using existing code, remove clutter.

Regards

Dirk

Code Smells

2010-02-22T02:09:00.001-08:00

From Wikipedia: “In computer programming, code smell is any symptom in the source code of a program that possibly indicates a deeper problem.”

We all need to get things done and most of the time we need to do them in a hurry. Unfortunately the result is that our code are not always a clean as it should be. Fortunately we are not alone in this world and other people experience the same problems that we do.

Code Smells are one of those things that can help us to identify when we are doing things that may hurt ourselves in the future. We may not always be able to fix them, but whenever you encounter a Code Smell, see if you can either justify it or fix it.

Code Smells are not the problem themselves, but they indicate that other problems exist in the code. Solving them is important, but it is even more important to understand why they are bad.

Code Smell for the week: Huge methods/functions

Whenever a method becomes too big it gets hard to follow the logic of the method. Such a method should be broken down into smaller methods that groups together related functionality. If the refactored methods then contains unrelated functionality, consider moving them to separate classes.

When doing the refactoring of big methods, it is common to encounter problems like the constant use of a shared variable throughout the method. This is in its own a Code Smell and may be mentioned at a later stage.

When is a method TOO big?

The size of a method is not the only determining factor. Whenever your method performs more than one definable thing, it's probably too big.

Another telling factor is the levels of indentation within the method. If you start having more than 4 levels of indentation in one method, you have good reason to believe that the method is too big. In methods that are too big, it can become very hard to follow the indentation levels.

Some things to consider:

Don't overdo it. Functions that are too small can hamper the readability of the code.
Don't expose functions to the global name space unless needed.

Please discuss Code Smells amongst each other. It is often more important to know why code smells are bad rather than knowing how to fix them. Knowing why they are bad will most likely result in us producing less Code Smells.

From the attic

2009-09-03T14:46:00.000-07:00

Most programmers have a stash of old software projects somewhere. I decided to go and dig up those projects I have and commit them on github. They can all be found

Minesweeper (c++)
I wrote Minesweeper because of my ego back in 2002. A friend of mine was going on about how difficult it is to implement minesweeper, so I decided to see how difficult it could really be. It can now be found here. Here is a screenshot of what it looks like:

Tetris (c++)
This is another classic. Every aspiring game programmer (overeager teenager) have probably written a clone of Tetris. This was my attempt, it's called Blockys Bow, can't remember why I called it that? You can find the source here

Connect More than Three (java)
I enjoyed playing the plastic version of this game, so I decided that that's enough reason to create an intangible one. This was done in Java, some of my first code therein.

Snake (java)
Last and probably least as well. At some time in my life I was clearly bored, didn't have many friends or more disturbingly found it interesting enough, who knows? Point being, I implemented a snake like game in java. As you can see from the screen shot below, everything didn't work like is should. Enjoy the source if you want.

Well, that's all for today. If I receive any motivation (in the form of comments or your projects on github) I'll dig up that stash of pascal code thats lying around somewhere.

A visual haXe example

2009-05-03T15:16:00.000-07:00

This example will show you how to create a simple maize-style background in haXe like the picture below:

First we need to create the maize graphic. We do this by extending the flash.display.Sprite class. Lets call the derived class MaizeBackground.

class MaizeBackground extends flash.display.Sprite
{
    public function new()
    {
        super();
    }
}

This will create an empty sprite that does not show anything. In order to add some graphics we must either add another flash.display.DisplayObject containing some graphics to the sprite (like a Bitmap, MovieClip or another Sprite) or we must draw something on this sprite using the graphics property of the sprite.

We are going to use the graphics property of the Sprite. So lets add a method called redraw to our class and use this to draw the maize. We should call to this method in the constructor:

class MaizeBackground extends flash.display.Sprite
{
    public function new()
    {
        super();
        redraw();
    }

    public function redraw()
    {
        graphics.beginFill(0xFFFFFF, 1.0);
        graphics.drawRect(0, 0, 800, 600);

        var color : Int = 0x000000;
        for (y in 0...60)
        {
            color = color ^ 0xFFFFFF;
            for (x in 0...80)
            {
                var prev = false;
                if ( Math.random() < 0.10 && !prev )
                {
                    graphics.beginFill(color, 1.0);
                    prev = true;
                }
                else
                {
                    graphics.beginFill(color ^ 0xFFFFFF, 1.0);
                    prev = false;
                }
                graphics.drawRect(x*10, y*10, 10, 10);
            }
        }

        var filterArray = new Array();
        filterArray.push(new flash.filters.BlurFilter(5, 5, 9));
        filters = filterArray;
    }
}

The logic for the redraw method is reasonably straight forward. We look at the maize as being divided into rows and columns.

Step through the image row by row.

Alternate between black and white rows

For every column in the row there is a small possibility of drawing the inverted color.

Finally we apply a blur filter to make the crude maize look a little better.

An important thing to note is that the filters only get applied when we assign something to the filters property of a flash.display.DisplayObject. If we simply pushed the new BlurFilter to the filters property, the filter would not have been applied.

Save this class in a text file called MaizeBackground.hx

Now we need to create a main class and add the sprite to the stage. Create a class called MaizeExample:

class MaizeExample
{
    static function main()
    {
        flash.Lib.current.addChild(new MaizeBackground());
    }
}

Save this class in a text file called MaizeExample.hx

Finally we need to create a compile file for the haXe compiler and compile the swf. Create a file called compile.hxml with the following contents:

-swf maize.swf
-swf-version 9
-main MaizeExample

Save the file in the same directory as MaizeBackground.hx and MaizeExample.hx and run haxe in that directory.

This should produce a swf file that can be opened using Adobe's flash player or browser plugin.

The MaizeBackground example could benefit from many improvements:

Add size properties to determine the size of the maize.

Play around with the different filters available in the flash.filters package

Change the size of the cells to be determined by a property

Any comments or suggestions are more than welcome!

Installing NekoVM and haXe on Gentoo

2009-03-19T10:52:00.000-07:00

Installing NekoVM and haXe on gentoo is done best by using the ebuilds provided by Daniel Turing.

To install the overlay, you need Layman and Subversion. Have a look at Gentoo Overlays: Users' Guide to set up layman if you haven't done so already and make sure you have emerged subversion.

Manually download the text file layman-haxe.txt using your browser or wget:

$ wget http://svn.xinf.org/haxe-gentoo-overlay/layman-haxe.txt

Open up the text file with your favourite editor and replace the line

src="http://xinf.org/haxe-gentoo-overlay"

with

src="http://svn.xinf.org/haxe-gentoo-overlay"

alternativeliy use

$ mv layman-haxe.txt layman-haxe.backup
$ sed 's#src="http://#src="http://svn.#g' layman-haxe.backup > layman-haxe.txt

now check out the overlay using

$ layman -o file:///path/to/file/layman-haxe.txt -f
$ layman -o file:///path/to/file/layman-haxe.txt -a haxe

You can now install the neko, haxe and swfmill that's in the overlay using

$emerge neko haxe swfmill

To install the latest version of NekoVM (1.8.0 at the time of this writing), you first have to create a local overlay. Follow the instructions on gentoo-wiki.com to do this.

Create the following directories in your local overlay: dev-lang dev-lang/neko dev-lang/neko/files

Copy 50_mod_neko.conf and 50neko from the layman haxe overlay into the dev-lang/neko/files directory. Copy this text into dev-lang/neko/files/neko-1.8.0-gentoo.patch. Copy neko-1.7.1-r1.ebuild from the layman haxe overlay to dev-lang/neko/neko-1.8.0-r1.ebuild.
(update: here is a link for the patch for neko 1.8.1)

Download neko-1.8.0.tar.gz into your distfiles directory. All that's left to do is to generate the manifest file. Use

$ ebuild neko-1.8.0-r1.ebuild digest

to generate the digest file. You will need to execute this command as a user with privileges to write to the dev-lang/neko directory.

Now you can emerge the latest version of neko!

Update: the haxe and neko ebuild together with the patches can now be found at github

Over to KDE4.2

2009-02-14T01:17:00.000-08:00

After some initial struggles (gentoo-user mailing list) I have managed to update to KDE4.2.

I will not say that this applies to everyone, nor will I make a sweeping statement like "KDE is back", but, KDE is back on my desktop and I'm reasonably happy with it!

I'm using a reasonably dated machine, AMD Athlon XP 2500, NVidia GeForce FX 5200 128MB and 640MB DDR333. Not the greatest machine, but after disabling all desktop effects, things are running quite smooth.

I decided to give the new Kickoff menu a go since KDE4.1.3. Although it's not what I am used to, it is still not something that will completely deter me from using KDE4. After all, if I really can't adapt, I can always go back to the classic style menu.

There is however a few things that I think could be improved. The first thing is adding shortcuts to the bottom panel. I always keep a few icons in my panel - konsole, the home folder and firefox at least. When I wish to add an icon to the panel , the widgets need to be unlocked. I feel that even when the widgets are locked, you should still be able to add icons to the panel. Having different context menus depending on the locked status of the widgets are a big confusing. For me the main advantage of locking the widgets is the absence of that configuration bar next to desktop applets. But, this is also no show stopper, I only need to add shortcuts for my favourite applications once.

Another thing didn't work that great was Okular. I opened "Learning CMake", but it was painfully slow. I haven't had time to test it with another PDF reader like xpdf or kpdf, so maybe it's just the PDF document?

But overall I'm impressed with KDE4.2. From now on this will most definitely be my default desktop!

Open source flash workflow

2008-11-12T12:47:00.000-08:00

I needed to do a project in flash and I needed to find a way to do so on my favourite OS - gentoo linux.

After browsing through a lot of google search results, and links on osflash.org I found what I was looking for. Unfortunately I could not find a single utility to do everything, but true to the linux spirit I found multiple separate utilities that could be used to accomplish what I wanted.

First and most important is haXe. haXe is a open source web programming language. It can compile to javascript, php and swf and the syntax and semantics felt familiar enough for me (I'm used to C++). Using haXe you can produce swf files that can be opened using Adobe's flash player.

The second important utility that I found was swfmill. swfmill compiles xml and resources into swf. This is very usefull as it allows you to build resource libraries that you can use from your haXe code.

I decided to use make as the build system - didn't want to learn too many new things at once.

I used vim as my code editor since I wanted to test what doing a whole project in vim would be like and syntax highlighting exists for haXe!

For graphics I used a combination of gimp and inkscape.

This combination of utilities enabled me to create a flash application without needing to buy the Flash SDK, windows, photoshop or anything for that matter. It could also be possible to target an older version of flash like flash 7, which could then be opened using the open source gnash!

Putting haXe to wood

2008-10-20T12:20:00.000-07:00

After using haXe for a personal project and finding it quite useful I decided to do a little write-up on what I did.

Being related to a certain individual (my sister) with a dream to establish an "audio visual print and digital" magazine (PostBox), the duty of creating the digital part was naturally bestowed upon me. I needed to create a cross-platform DVD interface (the kind of interface you view on you pc, not your dvd player).

The DVD contains photos, music, video and articles from various artists. All of this content needed to be handled in an efficient way that works on any PC regardless of the software installed (read codecs). This led me to flash.

But this didn't completely satisfy me, I also had another consideration: I am most at home in a linux environment (gentoo specifically) and I wished to do all the work in this environment. (okay, so I like the idea of free software as well)

This led me to haXe! After taking a look at the community and trying haXe out for a play project (which I may still finish someday), I decided that this was the tool to use.

I have had to solve many problems (some with plenty of time, other with way too little sleep and a tight deadline) and I wish to discuss some of those.

In this series of posts I wish to discuss the following topics:

The flash linux workflow
Getting started with haXe
Creating a generic audio player
Creating a generic gallery
Shared libraries in haXe
Preparing video and audio for use with flash

And for those asking the obvious question - I will make the source code that I'm not too embarrassed about available under some open source license, BSD or GPL.

Please leave all your suggestions and any questions you may have!