For instance, imagine that you have to wipe some data in vectors after its use. This is common in secure programming, to avoid sensible data to remain in memory longer than really needed.

It’s very easy, just program your own allocator:

#include <memory>

template <class T>
class wiper_allocator : public std::allocator<T>
{
 public:
  void deallocate(T* p, size_t n) {
    // we set memory to zero and the deallocate it
    (void) memset(p, 0, sizeof(T)*n);
    std::allocator<T>::deallocate(p, n);
  };
};

Then, if you are declaring unsigned char vectors this way, for instance:

std::vector<unsigned char> my_vector;

You must just change it like this:

std::vector<unsigned char, wiper_allocator<unsigned char> > my_vector;

And it’s done! Data is automatically wiped on deallocation! You’ll never forget!

You could also wipe data when object is destroyed, but it’s a little bit more resource intensive, and some STL libraries (Microsoft’s for instance) don’t work well this way.

Of course you can improve this one. For instance, you may want to avoid memset, because disassembler tools usually recognize footprints of common functions. You could use your own inline version to make it safer.

You could also also allocate non-swappable memory, so that sensible data is not paged to disk. But this requires non-c++-standard calls to operating system services.

C++ and the STL are huge subjects, but when you get into them, you’ll love them too!

You know, sometimes we are not prepared for adversity.
When it happens sometimes we’re caught short.
We don’t know exactly how to handle it when it comes up.
Sometimes we don’t know just what to do
when adversity takes over.
And I have advise for all of us
I got it from my pianist Joe Zawinul who wrote this tune.
And it sounds like what you’re supposed to say
when you have any kind of problem.

It’s called Mercy, Mercy, Mercy.

P.S.: I was about to but tickets for Joe Zawinul at Grec Festival, in Barcelona, but it’s the same day the company I work for celebrates a dinner with all the workers. What a pity this unfortunate coincidence! Well… these dinners are fun too!

I find steganography (hiding information so that it remains unnoticed unless you know it’s there) a very interesting subject. If you read my blog you already know that.

I thought it would be great to hide data in lists of things. I could permutate the order of elements, so that information is contained in that order. If we have n elements in a list, we have n! permutations of those elements… so we can hide log2(n!) bits.

I’ve implemented a little program that does that. It’s called stegotation. The worst part of implementing it was to convert from a binary stream to a mixed-base number (a permutation can be thought as a number that has a mixed-base in all its digits: n, n-1, n-2, …., 3, 2, 1). I had to do it as in school times: dividing. But the numbers are so big! Fortunately Python comes to the rescue with built-in multi-precision numbers. Great!

The program encodes the data as follows:

• It compresses the data using zlib.
• Prepends a length field (2 bytes).
• Pads with random data till we have floor(log2(n!)/8) bytes.
• Converts this to a big number.
• Converts this to a mixed-base number by dividing by 2, 3, 4, ….
• Encodes these numbers as a word list.

Decoding the data is just the same backwards.

I was about to add a password (to derive a symmetric key from it and encrypt data with it using, for instance, a stream cipher), but it would complicate everything if I want you to test it. It’s very easy to implement if you want.

Ok. Now the example. I have a list of bands that performed in the Primavera Sound 2005 festival last weekend. It’s called bandlist.txt. Then I hide a message. It’s very short (because the list of bands is small), only a enumeration of some bands I liked.

stegotation.py hide bandlist.txt chronicle.txt bandlistwithhiddenmessage.txt

The resulting list is called bandlistwithhiddenmessage.txt.

To recover the message, you only need to type:

stegotation.py recover bandlistwithhiddenmessage.txt recovered.txt

I hope that someone will succeed in decoding the data and tells me which bands I liked.

Dilbert’s Salary Theorem

Engineers, Teachers, Programmers and Scientists can never earn as much salary as business executives and sales people.

This theorem can now be supported by a mathematical equation based on the following three postulates:

• Postulate 1: Knowledge is Power (Knowledge=Power)
• Postulate 2: Time is Money (Time=Money)
• Postulate 3: (as every Physics student knows) Power = Work/Time

It therefore follows: Knowledge = Work / Time
and since Time = Money,
we have: Knowledge = Work / Money

Solving for Money, we get: Money = Work / Knowledge

Thus, as Knowledge approaches zero, Money approaches infinity, regardless of the amount of Work done.

Conclusion: The Less you Know, the More you Make

I know I said I wouldn’t use MATLAB again but Octave instead. I lied. This afternoon I was a little bit bored and began playing with images and tiny scripts (almost one-liners).

First of all, let me introduce you my cat. It’s called Trasto, a catalan word that means piece of junk, although in catalan it’s not as offensive as in English

These are just a few quick experiments. The leit motiv of all is reducing colors of the image (although not much).

Playing with flat structuring elements

First of all I played with a disk structuring element. The intention was to make flat homogenous regions of color.

This is my first try:

cn=4096;
cs=colorcube(cn);
t=ind2rgb(imerode(rgb2ind(i,cs),strel('disk',3)),cs);

t looks like this:

To smooth the image a little bit while presenving homogenous regions I used median filtering:

t2(:,:,1)=medfilt2(t(:,:,1),[5 5]);
t2(:,:,2)=medfilt2(t(:,:,2),[5 5]);
t2(:,:,3)=medfilt2(t(:,:,3),[5 5]);

This is how t2 looks like:

Now the same image using 1024 colors. Keep in mind that palette of 1024 colors is made using colorcube, which doesn’t use image data to choose the values, so the resulting image has much less than 1024 colors. We could use some adaptative process to choose them if we wanted to, and we’d probably see that adjacents colors in the cat would be more similar from each other than they are now (and probably would happen just the opposite in other places).

And what about non-flat structuring elements?

Perhaps the image has too much detail to seek homogeneous colors. We could try to use non-flat structuring elements, like ball, and see what we get. For instance, let’s use ball with radius 2 and height 1.

cn=1024;
cs=colorcube(cn);
t=ind2rgb(imerode(rgb2ind(i,cs),strel('ball',2,1)),cs);

We apply median filtering, as before:

Using greater height values we can get funny things (for instance radius 5 and height 5) due to saturation:

And with median filtering:

Texturing the image using shaped structuring elements

What happens if we use a cross as a structuring element?

cs=2048; t=ind2rgb(imerode(rgb2ind(i,colorcube(cs)), 
[1,0,0,0,1; 
 0,1,0,1,0; 
 0,0,1,0,0; 
 0,1,0,1,0; 
 1,0,0,0,1]), 
colorcube(cs));

Reducing the number of colors the effect is much more visible:

We obviously don’t use median filtering here because we would eliminate the texturing effect of the crosses.

If we use horizontal lines as structuring elements,

cs=256; t=ind2rgb(imerode(rgb2ind(i,colorcube(cs)), 
[1,1,1,1,1,1,1]), 
colorcube(cs));

, we get:

Since my cat is called Trasto I’ll use T-shaped structuring elements:

cs=256; t=ind2rgb(imerode(rgb2ind(i,colorcube(cs)), 
[0,0,1,1,1,0,0; 
 0,0,0,1,0,0,0; 
 0,0,0,1,0,0,0; 
 0,0,0,1,0,0,0; 
 0,0,0,1,0,0,0; 
 1,0,0,1,0,0,1; 
 1,1,1,1,1,1,1]), 
 colorcube(cs));

Note: I didn’t realize when I saved all the images to JPEG format using imwrite that MATLAB has the default quality setting for JPEG very low. So you’ll see the “water” effect of JPEG in images. This is specially true for last images, crosses, lines and T should be all homogeneous.

I’ve followed Pere’s path to include RSS feeds for any category in this site, and also included categories for non-catalan languages which I’ve used in my posts till now: English, French and Spanish.

So, for instance, now you can see all posts I’ve written in English using:
http://bloc.jmones.net/categories/altres-llengues/en/.

Or get its corresponding RSS feed to use your favourite aggregator:
http://bloc.jmones.net/categories/altres-llengues/en/feed.

I’ve just begun using Imendio Planner (formerly known as Mr. Project) for project management at work. I’ve never used such kind of software before so I don’t really know how people usually work with it, but I do have some idea of what I need.

The program, though, works somewhat differently as I expected (if you are curious about the specific problem I have with it just scroll to the bottom of this post). I talked about it with Albert (a coworker), David and Pere and they all agreed with me that the program would be much more useful with that feature.

Afterwards I posted a question to the planner mailing list exposing this issue. People at the mailing list were very kind and commented possible solutions and workarounds.

After a few emails from different people, a poster wrote (I reproduce it here for your convenience since this email comes from a public mailing list):

<rant>
It’s funny that what’s perfectly obvious to someone new to project management is ignored by most experts.

I have to agree with Josep that any tool that does project management has to make resource constraints a first-order problem, and not an afterthought. I’ve yet to see any widely used tool that does this; Primavera, MS Project, etc don’t do it, they all require you to go through hoops to do resource leveling and most of the time you end up having to create artificial temporal dependencies such as the suggestion given to Josep. These dependencies are at best a workaround, but in practice they can be detrimental to the project because they obscure the possibility of doing tasks in parallel by the “simple” addition of resources to a task, in practice, as the project progresses you figure out that the link is artificial and often end up doing the task in
parallel anyway, thereby throwing your hands in the air and saying: “screw this project plan”, or even worse, spending another couple of hours redoing the whole thing (and then an hour’s meeting explaining the “new and improved” project plan to the team.

Which is why there exist better methodologies than Critical Path analysis (yeah, I know, I repeat myself) such as Critical Chain management, that take into account resource constraints from the beginning.
</rant>

To be honest, several people replied to him with good arguments. My intention is not to assess which view is right. Probably it is not, but it could be, at least potentially, one of those situations in which “experts are biased” because of too much experience, or too many preconceptions, …

Experts often are right, but be aware because there are several cases in which they could in fact be wrong:

• Experts can be biased because of experience, academic knowledge, and so on…
• Sometimes experts don’t question opinions of other experts because it could turn out that they were wrong.
• Sometimes an expert achieves so much reputation that colleagues don’t even think he/she could be wrong.
• Even worse, experts tend to elect other experts just because they hold the same opinions as themselves.
• Experts could have obscure reasons to be wrong on purpose (possibly, of course).
• Experts may be corrupt.
• (if you can imagine more reasons please comment on it)

So trust experts, but also trust yourself.

Technicalities

The problem I had is that my project had tasks which didn’t have any logical connection between them and which were assigned to the same work resource (a person).

The software schedules these tasks concurrently, which is not wrong for me, but it calculates time to complete both tasks by looking independently which one will end up later. This would mean that the worker would have to work twice as fast, or 16 hours a day (instead of eight).

In my opinion, the program could either schedule them sequentially by calculating which tasks means a harder constraint to the project as a hole (because of possibly having dependent tasks) or just do something less intelligent, like assigning half the resource to each task and double the duration for both. There are more strategies that the program could adopt but these two come up immediately.

Proposed solutions were:

1. Addition of a dependency between the two tasks. I didn’t like this much because this dependency only arises because of the resource problem, but it’s not a real dependency. If I decided to assign one of those tasks to another resource I would need to manually remove that dependency.
2. Assigning half the resource to each task manually. The problem with this is that it’s difficult to implement in a case as simple as having to tasks, A and B, which need an amount of work of 5 and 8 hours. Since I would assign half the resource to each, that would mean working 10 days on both concurrently, and working 6 more days (only half-time) to task B.

I’m possibly overlooking something but this feature looked as something obvious to all people I’ve talked to about it. Please don’t hesitate to comment on this.

To do this I used MATLAB with Image Processing Toolbox functions. There’s also a free software counterpart (GNU Octave) that has a lot of image processing functions in the Octave Forge project, but I thought I would need grayscale dilation and erotion, thus I decided to use the propietary MATLAB (hey! it won’t happen again! I promise). This probably will run well in Octave though, if we consider the subtle differences in imread behaviour (it doesn’t return a MxNx3 matrix, but 3 matrices, one for each color plane instead), and handle the fact that imresize function is missing (perhaps interp2 could work as a replacement for this task).

First of all you can see the original image (resized to a smaller size) here:

I’ll focus on the amplifier and the mixing desk which are on the right so I can include the images without having to resize them:

The first step was to open the original image and convert it to grayscale:

%% Read original image
i=imread('campaneta.jpg');

%% Convert it to grayscale
a=rgb2gray(i);

%% Resize it to a more usable format
b=imresize(a,.5,'bicubic');

%% Adjust contrast
d=imadjust(b);

Then I used four different methods to obtain the edges of the image (Canny, Sobel, Roberts and zero crossing detection):

%% Get edges using 4 different methods
bw1=edge(d,'canny');
bw2=edge(d,'sobel');
bw3=edge(d,'roberts');
bw4=edge(d,'zerocross');

You can see the results of these operations here:

Canny	Sobel
Roberts	Zero crossing

%% We sum all edges and then
%% normalize it and negate it
bwr=1-(double(bw1)+double(bw2)+
        double(bw3)+double(bw4))/4;

%% resizes image to 300 pixel-width, its final size
prefinal=imresize(bwr,300/744,'bicubic');

%% auto-stretches image contrast
final=imadjust(prefinal);

This is how the whole image looks like.

There’s only one thing left: drawing a border to the image, because leaving all those lines open doesn’t look very good. After that imwrite saves the image to disk.

%% 1 pixel wide black border
s=size(final);
final(1,:)=0;
final(s(1),:)=0;
final(:,1)=0;
final(:,s(2))=0;

%% write result to disk
imwrite(final, 'neverland_fairy.png');

The result doesn’t look bad (if you take into account that this is automatable and doesn’t need any hand-editing), don’t you agree?

Perhaps it would be nice to try to stick with only one edge detector method and play with its threshold. If you want to give it a try, please tell me how does that work.

Hey… why don’t you do it the easy way?

Errr… yes… Just do this (I’ve translated the menu labels from Catalan to English so they could be slightly different; but you are smart enough to find them):

• Open the file in the Gimp.
• Filters/Edge detection/Gaussian
• Radius 1: 10; Radius 2: 1, Normalize and Invert.
• Image/Mode/Grayscale
• Image/Scale
• Width: 300px, Cubic interpolation.
• Layers/Colors/Levels
• Set central level to 0.13

Well this is what you’ll get. Looks nicer, doesn’t it? This is just because the threshold of the edge detector is set much lower. Using graphical programs lets you choose the best-looking settings very quickly. But the first way was much more fun!

I have always read that humans are reluctant to changes, at least to their ideas and habits. It like feeling safe because we know how things work. Now changes would be the constant thing that never changes (this sounds as one of Rumsfeld’s poems). We can’t wait for new exciting gadgets that will save us time and help us fill all this time we just saved; we have all kind of objects made in countries we’ll never visit and we are very close to people from all around the globe (well… err… we’ll keep the axis of evil out of this) while I don’t even know the name of my neighbours, and I’ve lived 4 years and a half in the same building which I know could be some kind of pathology, perhaps I’ll book an appointment with an specialist. We produce cheaper and everything becomes less and less useful. We still have bars for the moment… but waiters are getting so unprofessional that coffee tastes better at home. We get bored easily and we reuse things we don’t remember from the 60s or the 70s because they look so new again.

I think it can be argued that we expected a lot of these objects in advance, and they feel so much as an improvement! We had read SciFi books and knew scientists and technicians were working on it.

But what if it were true? Most of the sociological changes technology has produced were unexpected. Will conservatives ever advocate for the “constant change”?

How many times do you listen to the albums you download? How many songs do you have? How many music records did you listen to before you had Internet?

How many people do you regularly keep contact with? Where are they located?

How many times do you travel each year?

Note: please DO tell me all mistakes you can find in this post. I really want to improve my english outside the boring technical domain.