Tin Can Camera

Why Type

2008-08-07T20:45:00.003+01:00

For work, I'm demoing a GUI editor, which means undo would be nice, which is easiest to implement if you enforce purely functional data structures. So I'm doing a bit of reading as to how to implement suitable structures in Java 1.6, as that's the project's target language, and using Eric Lippert's examples as part of my reference material. There was also yet another thread on

Cedric's challenge, C port and analytic attempt

2008-06-30T23:45:00.005+01:00

I was a bit disappointed that the C port of the previous code wasn't quite as fast as another approach which cached more state instead of generating the i'th value. The second attempt, using the bcd lists was comparable to John Wilson's Java version (1.3 seconds rather that 1.5 reported by the Java), and an attempt using bitsets a bit slower. Timings on Eee pc 900, Ubuntu hardy heron. The code is

A coding challenge

2008-06-28T16:44:00.004+01:00

An implementation of the coding challenge of Cedric's. Somewhat coloured by the fact I normally use python as a prototyping language prior to production coding in C++. The combinations technique (using a bcd string instead of list) gets faster than the filtering technique for max somewhere between 1,000,0000 and 10,000,0000. As python is bytecode, it may be slower to bit-twiddle than use a

Eee's are good, Eee's are good

2008-06-12T21:17:00.003+01:00

I got an Asus Eee PC the other week, and spent the weekend and the last few evenings putting Ubuntu 8.04 on it (compiz, Ubuntu studio themes, several desktop tweaks, scite text editor, installing wifi and other drivers). It's small and cute. The screen is surprisingly legible, even for tiny text at arms length, and it's smoother than my big laptop running compiz. As I don't have a USB DVD drive,

On the map

2008-06-03T23:23:00.002+01:00

Received a little gps 'mouse' receiver in the post today, and (having installed gpsd and python-gps) have got it running as a local service with my first google maps mashup. The server is here, it just shows a google map centred on the current location. I now need to wait until I get a mobile broadband dongle and the new tiny laptop I've ordered (Asus eee 900) and then can have gps on the road (

Python and EA

2008-05-28T22:36:00.005+01:00

For my current contract, I'm part of a team producing scripts which define interfaces to equipment in a satellite communications system for monitoring and control. Various interfaces, serial, low-level TCP and SNMP. The application is fairly old - originated on Unix in early 1990s, ported to MFC late 1990s - and there are many links between the various configuration files. It's a high

Lambda The Ultimate and Matrix Distractions

2008-05-20T22:49:00.003+01:00

I had been reading up a bit on trace-based JIT. I'm not sure that there's any real difference between trace based and method based JIT if each branch is converted to CPS style call with type feedback. Which means removing the optimisation of having jumps and branches from the bytecode, and replacing them with dynamic calls. But then I got distracted by a discussion of Strassen matrix

Test of syntax highlight

2008-04-30T21:51:00.006+01:00

Test of the syntaxhighlighter: # generic sequence trait trait seq def empty : boolean def head : T def tail : seq def to_string => '[' ++ join(self, ', ') ++ ']' def concat (other:seq) => other.empty ? self : shift(other, reverse) def reverse => shift([], self)

Some things I'm thinking about

2008-04-25T09:55:00.002+01:00

I've been playing more with my mostly functional modelling and simulation language (kin), here are some ideas which I want to try and profile to see if they offer gains: Carrying type and data as a tuple: Some implementation of Scheme and JavaScript use a single void* size datum for each object, and for integers set the lowest bit and encode the value in the rest, and for other objects the

Bjarne Stroustrup on the Evolution of Languages

2008-04-20T22:29:00.003+01:00

A few comments on this - The illustrations in the interview don't appear related other than that they are of an IDE ("I might have a different opinion if a good IDE was universally available", queue Visual Studio, which implies that VS isn't a good IDE) and that the UML is illustrating multiple inheritance, but mechanism for dispatch in the paper is not based on multiple inheritance (at least

Andy Goldsworthy - Rivers and Tides

2008-04-13T11:14:00.004+01:00

We got the DVD as a wedding gift, and watched it last night. I like Andy Goldsworthy, both for his aesthetic and the humility that lets a work exist within an environment which makes it transient, or fluid. Watching him create a work, sometimes it would fall. Often it was compromised to fit with the time scale imposed by the environment by tide or light. At each fall, a discovery. More of

Boot Wierdness

2008-04-08T09:44:00.003+01:00

Note to self: I added bootparamsd to my bubba (so I can increase RAM disk size), and now if it's plugged into the ADSL I can't get the internet. Also, continuing errors on booting the Amilo A1650g - added noapic to the boot params and turned off fast boot in the bios. Still don't know why there's a IRQ conflict.

More kin musings

2008-03-29T18:13:00.004Z

Back from finishing a contract in Malvern, and have had a few ideas on kin. If general allocation is monomorphic arrays in column order, then single object representation is just a stride of 1 and a length of 1, and padded as required. Assumption is that the code will operate on arrays, so compiler should default to vector ops where possible. Need some basic constructs before starting,

Update

2008-03-29T12:13:00.002Z

I haven't posted since November, as I've been a bit busy. I got married on the 29th December. I left my job writing an interpreter for real-time simulation in South Wales so I could come to Glasgow and had employment at Crocodile Clips in Edinburgh, writing electronics and physics simulation software for schools. Unfortunately, Crocodile lost a large order so failed to honour that contract, so

Plays well with others?

2008-01-28T10:34:00.001Z

> I know large systems can be built statically...I've also done it dynamically in more than one dynamic language. That hasn't quite been my experience - every large system I've worked on has ended up getting layered into a static core with dynamic or DSL scripting. Greenspun's tenth rule. On the other hand, even medium applications I've been involved in which were implemented only in a dynamic

One more wide-finder

2007-11-01T09:01:00.000Z

Since previous efforts didn't print the results summary, they weren't really complete, so here are two more variants using a vector (tbrayA.cpp) and a priority queue (tbrayB.cpp) to get the top 10 entries. There's a pthread parallel version of the B variant (tbrayB_parallel.cpp). The main thread reads chunks, scans back to a line break, and hands off the chunk to a pool of worker objects,

Garbage

2007-10-26T19:45:00.000+01:00

I've been thinking a bit about garbage collection and stack allocation, and both Robert O'Callahan and phaeron at virtualdub seem to have been. Chicken scheme seems to have something interesting - a single stack which is collected on exhaustion (rather than C# or Java VMs which have a traditional program stack and a stack based allocator), so I'm thinking about implementing a

I hate everybody

2007-10-18T22:39:00.000+01:00

Well, every programming language I've ever used anyway. Not a lot to report, I've faded off of doing the wide-finder thing as the MPI ruby code was about as good as I could expect in elegance, and I'm more interested in other stuff at the moment. It did get me annoyed with C++ again, in that its primary mechanisms for specialisation - template metaprogramming and single dispatch polymorphism -

A few more thoughts on concurrency and high-level languages

2007-10-05T23:32:00.000+01:00

I little while ago, I started playing with a pattern-matching and relational language for meta-programming called 'kin' (it's got relations, and does pattern, so kin/kinship). Being a machine elf rather than a language lawyer, I never could come up with a decent user syntax for it; I've toyed with making it a lisp (either L1 like scheme or L2 like common lisp; I wrote something that used lisp

POITROAI

2007-10-05T20:52:00.000+01:00

For this particular problem, the principles are more important that the exact results, but I'm happier with tbray7.cpp which gives the same results as the regex in the original ruby code:fortinbras:$ time bin/tbray7 datasets/hundred-o10k.ap matches: 95400 real 0m0.439s user 0m0.284s sys 0m0.144sThe file was in cache for that one so ignore the real time; the important thing is that the

Of course, it helps if you tell gcc to generate a 64 bit executable

2007-10-04T22:40:00.000+01:00

... when you're using 64 bit operations: tercel-2:$ time bin32/tbray4 datasets/hundred-o10k.ap user 0m5.644s tercel-2:$ time bin32/tbray6 datasets/hundred-o10k.ap user 0m4.048s tercel-2:$ time bin/tbray4 datasets/hundred-o10k.ap user 0m5.725s tercel-2:$ time bin/tbray6 datasets/hundred-o10k.ap user 0m3.839sI'd assumed it would default as it does on linux, but no. Which also

Some fingers in the air.

2007-10-02T23:19:00.000+01:00

I got Steve Vinoski's 2007/09/29 erlang code, installed hipe and the bfile module, and it ran on the laptop: fortinbras:$ cat ../datasets/thousand-o10k.ap > /dev/null fortinbras:$ time erl -smp -noshell -run tbray5 main 512 ../datasets/hundred-o10k.ap 110100 matches found user 1m23.649s real 1m33.683s sys 0m1.620sI'm not sure looking at either mine or Steve's code where the 1101th

It's a glitch in the Matrix..

2007-10-02T19:31:00.000+01:00

Real wire-frame car

Data-wide wide-finder

2007-09-30T14:50:00.000+01:00

Running a test with just breaking into lines without the matching, compared to the non-MPI version with matching runs on the 100x file in 380ms user time rather than 720ms. So there is work in both parts of the string processing. Parallelising the scan for newlines to work on 8 chars at a time gives a reduction to around 220ms. Restoring the matching, and parallelising the scan for the first

Wide finder, parallelism and languages

2007-09-29T21:56:00.000+01:00

Tim Bray, who knows about web search and was part of the XML specification process, is experimenting with exploiting parallelism in his wide finder project. I'm interested in parallelism (running similar processes on multiple hardware) and concurrency (having multiple collaborating threads of control in a system), as many interesting problems are intrinsically concurrent, and as hardware isn't