[ Home | Articles | Account | People | Projects | FAQ ] two more crushing blows to the mouse industry this weekend: first off, the beautiful X window manager / general UI tool ion, which has such cool things as minibuffers, file completion, full keyboard operation, and a purely frame-based tile system. actually seems more useful than larswm, which is surprising. it's like a little fragment of the parts you use most from emacs, shaved off and put in a window manager.
secondly: I wrote a new emacs mode called quads, which is a quadtree navigation assistant. it solves (or seems to solve) the problem of relocating the cursor to an arbitrary position in a window. you eyeball the position you want to go, hit the magic key, and it lights up 4 wedge-shaped regions overlaid on the text in the current window. above, below, to the left, and to the right. you cursor in the direction of the region containing the spot you want to go, it recenters the wedges in the middle of that wedge. if you hit space, ctrl-g or bottom out of the quadtree it drops you back into normal navigation. this way you can move to any spot in a typical editor buffer in 5 or 6 keystrokes, which is roughly as fast as mousing.
also increasingly satisfied with konqueror as primary browser. it's like a small, fast, working version of nautilus+mozilla.
frances makes good food. frances makes vegetarian thanksgiving that makes turkey-eaters cry. cry, turkey-eaters, wah wah wah.
On the fractions front, my professor gave me a thesis which introduced me to the wonderfully bent world of p-adic fields, each of which is essentially the standard completion of the rationals with a different metric on it: two rationals are "close" if their canonical difference is divisible by large powers of the prime p in question.
What's interesting about p-adic arithmetic is in how their digital (radix expansion) representations differ. Having exchanged the property of "magnitude" for the property of "divisibility", division makes numbers "further apart" and multiplication makes them "closer together", but if you fix a digit length, and hence a subset of Q (defining the maximum closeness and farness) you get a remarkable set in which arithmetic amongst the remaining terms is "exact" with respect to the standard norm on Q.
Intuitively, this makes sense: if you were to have fixed the number of digits you use to represent the "normal" rationals, you would be able to represent only a certain subset of rationals by their size. Say if you fix 3 digits worth, you could only represent numbers between 999.0 and 0.999; nonetheless you could exactly represent every number in that range, and the results of its arithmetic, so long as they stay in that range. In the p-adics, you're exchanging the meaning of digits, and by truncating to those 3 digits you get the ability to represent all rationals regardless of magnitude which happen to have a canonical form (reduced to coprime * power-of-prime) in which they are divisible by a 0..3 digit power of the base prime.
The profound effect this has, if I follow the thesis correctly, is that the propagation error of operations on finite p-adic representations (or one such, which she calls "hensel codes") can be systematically compensated for after each operation. So you can make a fixed-length representation and completely quantify the error of any operation on that representation by the error introduced when reading numbers in and approximating them.
So now I think maybe there's hope for computer arithmetic after all. I have to go make some software which uses this system, and try it out.
Also, I have to give huge props to wei dei's crypto++ library. I've had occasion to need crypto code recently, and this library is the shit. Anyone who's still making crypto libraries when something this cleanly designed, modular, reusable and simple is available is a fool. normally, when you want to make parts of a crypto library work together in a way they weren't designed to by the author, they don't fit. In crypto++, they do. Every part has been designed to cleanly fit into every other part, so you can fabricate new crypto systems, complete with i/o facilities, in a few minutes of thinking and coding.
Finally, I made a saddening empirical discovery about makefiles: your time is actually best spent (I measured) by not only having 1 makefile for the whole project, but also listing explicitly each target, and all its dependencies, and the rule to remake it, in that 1 makefile. It takes a few moments of fiddling with find(1) to produce file lists, but it is actually less time than you spend getting your pattern rules, dependency generators and recursive invocations right. Furthermore, once you have such a makefile, its behaviour is completely predictable. Bugs in makefiles simply do not occur if you use them this way. Everything that needs remaking always gets remade in exactly the right order, you never need to make clean, you never have obscure bugs from old .o files, you never need to mess with automake, and best of all when your tree is up to date, running make returns immediately rather than after 100 recursive invocations. peter miller is right. dan bernstein is right. it is a better use of your time to use make the way it was intended.
aaronl: let's say you are a normal unix user. you use the contents of /usr/bin as your verbs, files and file descriptors as your nouns, and a shell language as your set of connectives. you follow the "unix philosophy": make big things out of little things. lots of us are happy with this language.
now one day you decide (some people do not decide, but lets say you do) that you're a little sick of invoking programs with "flags", especially big programs, and you really want to have already-running programs interact with one another in the same way the typical shell pipeline does. hm. that's a little harder. you'll probably write a special purpose FIFO-based wire protocol for your particular case and leave it at that. but then as it's clear, you'll wind up making n! wire protocols for n programs to interoperate. suckage.
so, you decide to make your program's essential services into a library, so that rather than having program A talk to program B, one of them will just "swallow up" the other's functionality, and be able to call "itself" directly through C linking. Or python module loading. Or perl module loading. Or C++ linking. Or lisp module linking. hm. suckage. these things can't link with one another.
so, you decide to make SWIG, which can generare module loaders for anything in anything else. there, goddamn it, now I can load my modules in peace! a perl script can load up a bunch of C .so's and execute them. unless the module implements persistent objects with identity. or objects on other hosts. or objects with existing data. hm. suckage. you're limited to the scope and lifetime of a single process. beyond that you're back down to pipes and sockets.
so, you invent CORBA, in which anything can talk to anything else, regardless of implementation language, host, lifetime, etc. you can refer to dead objects and re-create them. you can call methods statically (compiler checked, like a library), you can call them dynamically (string tokenized, like a shell). everything's perfect! except you can't tell how to start objects, or query their capabilities, or name them, or disconnect them when they're done, or discuss basic protocol issues like who is going to embed whom. hm. suckage. looks good on paper, but lacks some infrastructure to hold it together.
so, you invent a set of component interfaces everyone must agree to support in CORBA. bonobo, say. hurrah! everything's solved! yip yip yip!
I too "have a problem" with components, and it is this: all the time is being spent on making mechanisms for finding and activating new nouns and verbs. once they exist, they tend to just get plopped into a "component bucket" application, wired together (manually) to make the application do what it's supposed to, and forgotten about. the task of finding new linguistic connectives is generally ignored. consider some domain specific languages developed in higher order languages like haskell.. they have really powerful connectives, well crafted to seemlessly "make bigger things out of smaller things" with a single statement. like the "|" connective accomplishes a reasonably rich set of "dup2, dup2, close, close, fork, exec" statements in a single character, higher order connectives can blend one "behaviour" into another, one "music" into another, one "animation" into another. now consider the connectives holding component-architecture programs (mozilla, nautilus, evolution) together: subobject activation and embedding, for loops, bulk data transfer, reference-to-data transfer, and hand crafted method calls.
the trouble with making a clean and useable connective is that it requires strict adherence to interfaces, and interfaces with good enough design to be connected together. in the current landscape of CORBA componentware, people tend to "just keep adding methods" to single objects, often critical ones, where they should be developing connectives and subobjects obeying regular, well designed, readily combinable interfaces. patterns of composition are way more powerful than just "my thing can see your thing". this is what sets fresco's interfaces apart from other uses of CORBA: its primitives, connectives and decorators are chosen to construct self-laying out, event-handling, MVC behavioural composites out of sub-objects in a natural way. designing those interfaces was clearly a hell of a lot of work, and they still don't do everything you'd want them to. but they're a far cry better than what other people are using CORBA for.
I'm afraid in 5 more years, programming will truly have regressed to for loops in ECMAscript. and that will be very sad.
back in toronto. cleaned apartment, moved everything around, paid loads of bills, back in my normal life with frances. everything feels mostly right again.
current fascination is with the perverse beauty of "generative programming"; in particular, with the horrors of expression templates and their use in compile time optimization of scientific computation. This is sick, dark magic business and I love it.
thus far, authors have explored this technique in making unrolled vector libraries and simulating functional programming. I'm interested in seeing if the same technique can be effectively used to do an arbitrary precision rationals package in C++ without any performance hit. I think it can, but I'm still surveying the literature. it's even crossed my mind that such a library could select appropriate cases in which to use long word & vector integer coprocessors, so common on today's CPUs :)
this is especially interesting because, now that I'm fiddling with quantum chemistry programs, I'm really coming to loathe floating point math.
the other possibly useful thing which could be done at a static metaprogramming level is to reorder expressions to minimize truncation and roundoff error if you happen to be using FP. so much interesting stuff to explore. sigh
going out to a party now...
raph suggests, as many have before, that:
Nonetheless, it is important for authors to get paid for their work
And, while I can understand that authors certainly want to be paid (don't we all) I do not concur that it is important. Indeed, I broadly disagree with the film, music, book, and magazine industries in their constant affirmation of the supposed right of the "creative person" to get paid for anything they happen to create. A vast, incalculable majority of the material these industries foist on us is utter crap. We consume it because
There's a word for this in trade policy: protectionism
so now wagon has a homepage and an RPM and all that sorta poop; perhaps this will help sway people form proprietary job distribution systems. who knows?
frances is on a train arriving this evening. joy!
had dinner and drinks with ankh the other night, which was nice. I haven't seen him in a while. I tried to convince him to work on berlin to no avail. stefan related over pool the fact that gnome is now some sort of OMG-backed foundation.. I guess congratulations are in order. perhaps someday we'll find a way to glue it to berlin and make an unholy advanced-imaging monster. till then I'm gonna, uh, hit the profiler some more and see about that mutexing thing.
I wonder sometimes, looking at all these turbo awesome RDBMS-based version control systems proprietary vendors sell, whether one of us ought to sit down with postgresql, a little embedded SQL and a big cup of coffee and try our hand at it. total speculation here, but I think maybe the assumption that we need to use tar, diff and patch as the basis for version control is perhaps hindering us.
since I have nothing else useful to share aside from the details of me scrubbing my apartment floor, I will instead provide amusing links: wli graced comp.lang.functional with a lovely link to a type inference paper and thomas lindgren followed up with an even more delightful link to spj's Implementing Functional Languages -- A Tutorial paper. mmm. to round matters off, jbash sent me a link to why computers need ethics following our lengthy chat on the topic 2 weeks ago, and shaver pointed us to a stunningly odd site featuring britney spears and the marvels of semiconductor physics.
larry ellison has a bunch of jet fighters. bill gates has a quad xeon running windows 2000 built into his toilet. scott mcnealy has a yacht the size of an air craft carrier.
why doesn't the free software community have computers in our toilets? are we just losers?
I just don't buy the argument that because something is technically more powerful/elegant/designful, that we ought to give ourselves over to the way in which it is made. adobe can afford to pay people for slick fonts for exactly the same reason time warner can afford to pay for a million-dollar-a-day studio for their darling artists. and not entirely unlike the way the pentagon can afford to spend $100 on each bolt they stick on their jeeps.
I'll take my shitty liberated stuff any day.
raph points out that free software has been unable to produce any good fonts. I would debate this point rather heavily. something we needed for berlin was a font which took to task the unicode character set and attempted to cover all of it with a single, simple typeface. just as a fallback, in case the user needed to see some text for a language which hadn't many professional font designers. unifont is the only such font, proprietary or free, which has done so. it did so at the expense of the much hyped glyph <-> character distinction. it did so at the expense of smooth, silky vectors. it did so at the expense of existing font formats. yet at the same time, it did what nobody else on the market had the guts to do, yet what billions of non-english speakers could really make use of.
this to me is the essence of free software. it's not wine-and-cheese yacht-faring upper crust software. it's not the stuff which spoils you with compliments and charm, wows you with the immense cost of their outfit, only to turn their back on you if you happen to be poor. free software doesn't have time for compliments and charm.
I am genuinely proud of the fact that my computer comes with more compilers, more documentation, more databases, more libraries, more editors, more tools, more network clients and servers, and more source code than I will ever see in a million years of watching adobe's product line. I am proud that this software has taught me to be a programmer, and came under a license encouraging me to train others to be programmers. I am proud that I can go online at any time of day or night and see a legion of people on mailing lists and IRC teaching newbies to be respectable programmers with good technical problem solving skills, liberating people from the intellectual enslavement of the "software market". I am proud that we spend our free time working on things we see a real need for, or things we simply find too beautiful to not work on. if we ever stopped, we would be done for.
(5 days till frances gets here. 5 days..)
our soda vending machine is a shining example of the principle of maximal astonishment: no matter which button you press, it gives you something you didn't ask for. we spent a couple hours tracking a heisenbug in qmail-pop3d, in which it forgets about mail moments after it stats it. mail's there, it knew about it one moment, then what, cosmic ray? same binary, different box, problem vanishes. I'm worried there might be an obfuscation field enveloping our entire wing of the building.
now everything's quiet and post-milestoney. times like this (they several times a day) I really miss frances. soon she'll be here, soon. we agreed this weekend to move out of the city asap and get a home going. small bit of land, temporary living quarters, cement mixer, and a big pile of mud. I can't fucking wait. she is the best thing ever.
M17 is very good, and all the mozilla'ers here must be heartily congratulated. forget morons who don't understand how much work such a thing is.
a good week + end: feature complete on my project at work, saw frances for 3 whole days, including hiking a dozen k of the bruce trail, finally finishing the inconceivably long final fantasy 6 (with a 21 minute super-NES-straining epilogue) and completing to my own satisfaction "wagon", my new job distribution framework (complete with autoconf/automake, disparaging articles here notwithstanding). I even got my taco bell and bubble tea fixes, and paid rent. now all I need is tuition
otherwise having a nice quiet period in a busy summer. saw my adorable, utterly bewildered niece explaining to me several things which all came out as the word bwaaaaaaaaaaaaa!. I think it had to do with my not being her mom. I gave the parents some sun electric to quiet the baby when she's all freaked out, and apparantly this is indeed working well, such that they've asked for a whole whack of similar music (I'm thinking like patashnik, 7614, the shutov assembly dreamfish 1 and 2, etc). new parents of advogato take note: what works for tweaking ravers on acid works remarkably well for screaming infants (and exhausted parents)
FOAF updates: Trust rankings are now exported, making the data available to other users and websites. An external FOAF URI has been added, allowing users to link to an additional FOAF file.
Keep up with the latest Advogato features by reading the Advogato status blog.
If you're a C programmer with some spare time, take a look at the mod_virgule project page and help us with one of the tasks on the ToDo list!