Building boost on Mac OS X 10.6 with XCode 3.2

Getting boost to build in ‘fat binaries’ is a pain when you’ve just switched to XCode 3.2. Switching to XCode 3.2 is somewhat obligatory, because that also brings you the SDK for Mac OS X 10.6, aka Snow Leopard. And when you run the Snow Leopard, you want the SDK for it as well. It sounds so simple.

The Apple version of gcc, included in XCode, stops building boost in fat versions, it works for targeted versions (i.e. with only one architecture). But, if you want to build ‘universal’ binaries that work in 64bit and 32bit mode, you’re out of luck.

I got it to build this morning, thanks to some discussions on the boost mailing list. And it == boost 1_40_0, with XCode 3.2 on Snow Leopard.

This is the command-line I used:

bjam --build-dir=../boost_build --layout=versioned toolset=darwin architecture=combined address-model=32_64 link=shared,static install

And here is the patch I created to get it to work. It boils down to: remove all the ppc entries from the tools/build/v2/tools/darwin.jam, because the XCode compiler does not offer support for PPC anymore. And, you have to remove the “-m64” option in the gcc.jam, because the xcode compiler does not like to have -arch x86_64 -arch i386 -m64 all together on the command-line.

But, if you take the road of building your code on XCode 3.2, you specifically eliminate all those users still using a PPC based Mac. That might not be what you intended. In that case you probably need to add the -V 4.0.1. option to gcc/g++ in which case you use the older compiler (from XCode 3.1), which might or might not be what you need for your project.

(Sorry for the stupid looks on the patch, but wordpress mangles stuff with the <code> tag).


diff --recursive -u boost_1_40_0.orig/tools/build/v2/tools/darwin.jam boost_1_40_0/tools/build/v2/tools/darwin.jam
--- boost_1_40_0.orig/tools/build/v2/tools/darwin.jam 2009-04-14 09:59:30.000000000 +0200
+++ boost_1_40_0/tools/build/v2/tools/darwin.jam 2009-09-06 08:01:26.000000000 +0200
@@ -304,9 +304,9 @@
: $(values) ;
}

-arch-addr-flags darwin OPTIONS : combined : 32 : -arch i386 -arch ppc : default ;
-arch-addr-flags darwin OPTIONS : combined : 64 : -arch x86_64 -arch ppc64 ;
-arch-addr-flags darwin OPTIONS : combined : 32_64 : -arch i386 -arch ppc -arch x86_64 -arch ppc64 ;
+arch-addr-flags darwin OPTIONS : combined : 32 : -arch i386 : default ;
+arch-addr-flags darwin OPTIONS : combined : 64 : -arch x86_64 ;
+arch-addr-flags darwin OPTIONS : combined : 32_64 : -arch i386 -arch x86_64 ;

arch-addr-flags darwin OPTIONS : x86 : 32 : -arch i386 : default ;
arch-addr-flags darwin OPTIONS : x86 : 64 : -arch x86_64 ;
diff --recursive -u boost_1_40_0.orig/tools/build/v2/tools/gcc.jam boost_1_40_0/tools/build/v2/tools/gcc.jam
--- boost_1_40_0.orig/tools/build/v2/tools/gcc.jam 2009-07-11 13:04:31.000000000 +0200
+++ boost_1_40_0/tools/build/v2/tools/gcc.jam 2009-09-06 08:11:17.000000000 +0200
@@ -375,7 +375,8 @@
}
else
{
- option = -m64 ;
+ # option = -m64 ;
+ option = ;
}
}
OPTIONS on $(targets) += $(option) ;


Flexible keyboards

I’m a very happy user of the ‘old’ Sun Type 7 keyboard. Actually, I’m hoarding them, since, Oracle is going to kill the Sun hardware business and the Type 7 is one of those keyboards with all the keys in the right place. Control is left to ‘a’ and backspace is not in the top row, but one below, just above the ‘return’. In order words, I’m a sucker for keyboards and I’m really sensitive to their touch and feel and click and whatever there is to them.

Today I saw someone mysteriously put a silicone keyboard (it flappy and flexible, but no brand label to be seen) in my room and I had to try it. Actually, I’m trying to type on it for this blogentry. And, I’m not really a happy customer. Let me count the ways in which this board does not suck:

• It’s very cool to fold away your keyboard when you’re not using it.
• It has an uncounted number of shift keys. Well, there are four.
• It’s featuring (sort of) in Die Hard IV.
• It feels nostalgic.
• You can spill stuff on it.
• It fits in you backpack, or even the side pocket of your cargo pants.

Ok, that was the good stuff. Now for the less convenient stuff.

• It stinks, as in, it has an awful plastic smell about it.
• It stinks, because I’m actually trying to type less, because I’m prone to mistype on this thing a lot.
• It gives me carpal tunnel syndrome with just using it for the past half hour.
• It is very wobbly, even when I put it on a sturdy surface area.
• Did I mention it has four shift keys? And two space keys, but you can still touch them without any reaction? It even has keys on them without any label at all.
• It has windows keys on it, but more keyboards do, so I will not hold it against it.
• It doesn’t have a brand label on it, so it must be crap. Otherwise, someone would put a label on it to say that they’re responsible for it. Probably they’re quite scared of someone suing them into oblivion.
• The control key is broken.

So that’s it. Unless you want to look really cool and like you’re in Die Hard 4, get it. Otherwise, give your wrists and hands and the rest of your body some rest and stay away from it.

Coolness: 7/10 (hey, it’s in Die Hard Four) (but it does not glow in the dark)
Function: 3/10 (with working control: 4/10)
Weight: 8/10 (it’s very light)
Space: 10/10 (it takes up almost no space in your backpack. That’s good).
Total: 5/10. If function is not good, forget it.

Gems documentation

When trying metric_fu, gem told me quite gently, though persistently, that it did not know about metric_fu. Blimey. You’ve got to look around the Intarnetz, but then you can find the stuff you need to get more than one repository.

So, what’s the trick?

gem sources

lists the sources that are already available.

gem sources -a http://gems.github.com

adds that source to the other sources. Jay! That’s what we needed,

RSpec and Forensics

I’m currently reading the beta edition of the RSpec book by David Chelimsky et.al. Because a book like this can only be comprehended when actually using the content, I’ve decided to start documenting a new project I’m doing with it.

So far, it has been about Behavior Driven Design (BDD), which is an acronym I’ve head before, but I didn’t have the time to read more about it.

It feels a bit weird specifying stuff using mostly natural language, but on the other hand it’s naturally very cosy to do so. What’s really neat is that you start using the api you want to specify right up, instead of first formalizing a design for it. That way you known that all the methods in your api really belong there and actually work.

While I was busy to code up some small project I received the new linux journal, which had an article on metric_fu. It contains a lot of code that can measure the quality of your code. That is always good to do, because the more checks you perform on your code, the bigger the chance that you run into a bug waiting to happen. Of course, you also run into false positives faster, and most people stop using checks like these because they run into false positives too often.

But reading the article I was thinking to myself: why don’t we use BDD combined with something like metric_fu on hour one-off tools we create to solve a case? Most forensic practitioners I know are bound to run into the situation where all the available tooling is not adequate to perform a certain job. Things that come to mind are refiling images based on camera, but oh wait, based on resolution first, or extracting all email addresses from an image and compare them to some filter, These things should be rigorously tested before put in use, because a simple code snafu can dump all your stuff in the bin and will cost you valuable time to clean up again. There is in this case an obvious tradeoff between codingtime, solvingtime, clean-the-errors-time and the time you need in court to explain that you did everything in your power to not botch up the code. For that last part you would ideally show testing output that shows that your testcases have a 100% coverage and pass every test you thought was possible.

Ada

For some reason I quite like (some of) the constructs in Ada. Techworld has an interview with the current maintainer of the Ada specification.

Hacking licenseplate scanners

I guess, if you have vanity plates, this should be doable… But, if anything, it will create huge roars of laughter in the parking area of any security firm.

Ruby documentation

I’ve been using Ruby for some small projects for a couple of weeks now. So far, there are worse languages in the world (Perl JUMPS to mind). I’ve used Python for a long time (10+ years, at least). It’s a language to love, but, people are all raving about Ruby (on Rails) therefore I gave it a go.

Verdict so far

• Language OK
• Documentation SUCK

However, I’m not the only one. Fundamentally, Ruby can be used to create applications quite easily. However, if the documentation is hard to find or non-existant that purpose fails. I find myself looking at the implementation of ruby classes far more often than I’d expected, because the documentation is so thin. It surely cooled my appetite.

Filesystems

I like filesystems. They’re not sexy, they do not feel good, but boy, are the fun to write. Ars Technica has a very good, albeit long, article on most filesystems ever seen on this planet.

Threading issues

Roman Shaposhnik has a nice blogentry on how multithreading your application will make everything go buggy all of a sudden. With all the multi-core processors around (Rock as an example) more applications will be going multithreaded.

He quotes an article by Prof Edward A. Lee, which has also this quote:

I conjecture that most multithreaded general-purpose applications are, in fact, so full of concurrency bugs that as multi-core architectures become commonplace, these bugs will begin to show up as systems failures. This scenario is bleak for computer vendors: their next generation of machines will become widely known as the ones on which many programs crash. These same computer vendors are advocating more multi-threaded programming, so that there is concurrency that can exploit the parallelism they would like to sell us. Intel, for example, has embarked on an active campaign to get leading computer science academic programs to put more emphasis on multi-threaded programming. If they are successful, and the next generation of pro- grammers makes more intensive use of multithreading, then the next generation of computers will become nearly unusable.

I’ve seen some insane code in my life, but multithreaded code always tops the list.

But, in a forensics context, nondeterministic behavior is a big problem. The problems being solved are often very appropriate to handle in a multithreaded application. But one famous (or notorious) forensics application that is multithreaded quite often drops the ball. Sometimes with a heavy crash, but also with unexpected results, depending on the order and multiplicity you use for querying for instance. It’s very hard to verify all the results by hand (that’s why you’re using a computer) and you also do not know whether a new query will result in more or less results on the same data-set.

I do not know how to change this, one way is to use IPC and multiple processes all the time, since you don’t have two processes sharing address-space unintentionally. Other options are a change of language that has a better way to handle the non deterministic properties of todays processors.

Maybe I’ll be looking at Erlang any time soon.

Technorati Tags: Forensics, Programming

Subversion to Mercurial conversion

I’ve worked with subversion since the early days, but it seems more and more development projects are migrating to a DVCS, because they feel that kind of development strategy works better for them. Apart from ‘weird’ behaviour (from the SVN point of view) when merging two files, I like mercurial good enough.

This article has a nice step-by-step tutorial on how to convert your svn to a comparable mercurial setup.

Technorati Tags: General, Mercurial, Programming, Subversion