Archive for Project
May 5, 2008 at 1:37 pm · Filed under Project
Crossposted at Not An Employee blog
What: Ann Arbor Coworking “town hall” meeting
Coworking is any long-term arrangement in which independent professionals can work in the same space, whether full- or part-time. You may have seen mention on CNN.com, in the New York Times, or local media.
We’re trying to gauge interest in developing a permanent dedicated coworking space in downtown Ann Arbor. This might include shared office space, meeting and training space, a private cafe, a “makers’ den” for electronic and other fabrication projects. Any or all of those. The space might be run by a private concern, a nonprofit organization, or an ad hoc collaboration. It might be a membership organization, a business of its own, or a cooperative. Or something else.
Let’s explore what it might be, and why you might want to participate.
Where: Ann Arbor District Library Freespace, 3rd floor, Downtown Ann Arbor library building
When: Monday, May 19, 7-8:30pm
The meeting space is reserved from 5pm through 8:30pm, but we will officially begin proceedings at 7pm. If enough interest is generated, we may run two 90-minute rounds of discussion. Please let us know if you’re coming.
Who: Organized by Not An Employee, LLC
Space in the Library conference room is limited to 32 people. If more want to attend and discuss the prospects for coworking, we will try to arrange a second session, and extend discussion after the meeting at one of the other local meeting venues.
Please let us know if you’d like to attend. You may want to use the free service at Upcoming.org to coordinate.
April 29, 2008 at 11:29 pm · Filed under Project, Tidbits of nanohistory
Because history is for sale on eBay, and nobody knows what’s in a “rough old book, good condition for its age”.
Tonight, while thinking diligently about how best to share these all in a new format, scanned this old tome:
Seems pretty dry, eh? History ≣ dry.
Why is this of any interest at all? Because people like Thomas S. Grimké were in attendance, and they thought some weird things that are still holding sway over American education to this day. Here’s Grimké’s preface to his address:
April 28, 2008 at 11:40 pm · Filed under Project
Somewhat zoomable scan of a bookseller’s catalog I have on hand here. If you regularly visit the blog, you may need to force-reload the page in your browser to get the little pieces to line up correctly. I had to have the sitewide CSS to get this to work here.
I’m trying to spec out a browsable, legible interface for scanned books with some complex page structure. You’d want to zoom in to read the images, but not lose the relational block structure; you’d want to be able to read the text somehow. A lot of the things I have in mind are encyclopedic, may have 10000, 20000 entries per volume. Be nice to break those apart individually, like blog entries.
But the big goal here is that the original page structure needs to be visible, but zoomable. I know I could do some stuff with PDFs, or with JPEG2000, or with some neat Flash crap… but you draw your pages with the software you have, not with the software you wish you had.
April 2, 2008 at 11:32 pm · Filed under Project
Cross-posted to the Nudge blog
There are really three basic genetic programming algorithms I like to use out of the box. One’s stupid, one’s (almost) standard, and one’s pretty fancy and effective.
Start with one nugget of assumption: Every search algorithm should be multi-objective. Period. No exceptions. You do a single-objective search on any real-world problem, you’re either lazy or a liar. The end, no exceptions. I don’t care if you’re an Operations Research guru or a lone stock trader looking to make a buck, no problem is single-objective.
So when I say “better” in any context, I am talking about Pareto domination, or if you’re an economist kinda girl, “relative Pareto efficiency”. Say you have two alternatives, A and B, and you’re deciding between them on the basis of two minimization objectives, w1 and w2. A is dominated by B if w1(B)<w1(A), and w2(B)<w2(A). B is dominated by A if w1(A)<w1(B), and w2(A)<w2(B). Neither one dominates the other unless it is strictly better on all comparisons. Otherwise, A and B are nondominated by one another; they can’t be differentiated in a meaningful way without saying which objective is “more important”.
You want to survive a car crash, or do you want to drive really really fast? Which is better? So, get that into your head. There is never one objective. Never.
Let’s make sure we understand why there are always multiple objectives in GP runs. You want accuracy, right? But you also want parsimony. You’re evolving models, solutions to problems, functions, structures. Things can get hairy very quickly in a runaway evolutionary world: programs can get superstitious, they can inherit weird cultish quirks, like learning to use “Cosine(0)” or Sqrt(Sqrt(Sqrt(Sqrt(Sqrt(8.9912)))) instead of “1″, if some forgotten ancestor happened to find that first and passed it on as Big Math Juju. So as God of Your Little Engineering Problem trust me: you honestly want to reach down out of the clouds and say, “Hey, guys, chill. Remember, we use our human-readable voice when we model, OK? Two commandments here: accurate, and succinct.”
So there’s an intrinsic reason right there why you want to minimize model error and model complexity. At least two objectives. Always.
Because there’s always a less efficient way to solve any problem without sacrificing accuracy.
Anyway, those search algorithms.
“Stupid” is random search:
- Create a random program, and evaluate it
- Create a new random program, and evaluate that
- Throw away the one that’s dominated, or the newer one if neither is dominated
- Go to 2
Seem so ridiculous it’s not worth considering? Not really. It’s essentially the worst you could possibly do, knowing nothing about your search problem. So if nothing else, it provides a useful baseline, as well as a nice test of your randomization methods, evaluator timing, and other infrastructure that almost any search algorithm will share with this dumb-as-a-sack-of-hammers approach.
Plus: Easy to explain? Damn straight. Always run random search on your problem, with your representation, full-fledged evaluation, and data collection system in place.
“(Almost) standard”? Steady-state Pareto tournament selection works for me for a number of reasons, at least as a first approach:
- Create a population of, oh I don’t know, 500 random programs
- Select a tournament of maybe, ummm, 10? yeah 10 programs from the population, uniformly at random, and evaluate them
- Identify the nondominated “best” programs among them, and the dominated not-so-best ones, and split them into two groups
- If there are no dominated ones, pick one of the “best” pool at random and demote it out of spite. If there’s only one “best” program, it’s lonely, and inbreeding is bad, so promote one of the lesser ones out of pity.
- Replace all the programs in the not-so-best pool with offspring of the nondominated “best” pool
- Pick two parents, with replacement, from the nondominated set
- Use one-point crossover to make offspring
- Mutate the babies slightly, here and there, to taste
- go to 2
OK, I confess. This is standard in almost no ways whatsoever. It’s a “standard” toolkit for me, sure, but it’s a pretty far cry from Koza’s classic lockstep population-based methods, the kind everybody and their brother has copied wholesale. I like it anyway: it gives rapid feedback on progress, it’s kindof elitist (except for that “spite” step), it saves a lot of search time by limiting expensive multiobjective comparisons to relatively small pools, it works with fitness caching. It’s not perfect, but I already linked to the NFL Wikipedia page, so what are you, so dumb you can’t read? Nothing’s perfect.
Fancy and effective? I really like the ParetoGP method from Mark Kotanchek and Guido Smits (and their colleagues):
- Create an Archive of 500 random programs
- Create a Population of 500 random programs
- Create a container for the Next Generation (an empty list; hold onto that)
- Select a tournament of 20 Archive programs with uniform probability, and evaluate them, and forget about the dominated ones. Just make a list of the nondominated ones from the Archive tournament.
- Select a tournament of 20 Population programs with uniform probability, and evaluate them, and forget about the dominated ones. Just keep the subset of nondominated ones from the Population tournament.
- For each Population tournament winner you got from step 5, pick an Archive tournament winner you kept from step 4, at random. Cross them over to create an offspring, maybe with some mutation if you must.
- Stick the baby into the Next Generation. If you have 500 programs in the Next Generation, replace the Population with it and go to 3. If you’ve run out of tournament winners before filling the Next Generation, just go to 4. If you choose to attack the Orc, turn to page 88.
- You’re going to be wondering when you stop cycling the Next Generations back into the Population, aren’t you? Oh, I dunno. Pick a number. Say “10″. Go on, say it. There: do it ten times. Or more. Or less. Whatever; it’ll work.
- Aha! But then: once you’ve done your ten renewals of the Population (what Kotanchek and such call a “cascade”), you’re not done. Oh, no, boyo. You get your butt up there and you start the whole thing, all over again at step 2. That’s right. Another cascade, from another new, random Population, and another ten generations or so. But—but—before you do, take the final Population, the best best best of that cascade you just finished, and you stick it into the Archive. Add it to the programs that were already there, and take the time to trim the Archive back down to 500 programs. You can do a full-fledged 1000-wise Pareto tournament if you have the time, or you could do some other cunning selection method if you want. Often I tend to do something quick and dirty, like just picking tournaments of 20 and culling all the dominated ones until the Archive size drops back down to 500. So, anyway, you were going back to Step 2 to run another cascade.
- Do that until you’re bored.
Now this is a close approximation of the ParetoGP algorithm described in a number of papers by Mark Kotanchek, Guido Smits and Katya Vladislavleva. It’s a broadly customizable framework, and if it seems like a lot of extra work compared with the “simpler” GP algorithms described above… well, that may be true. I like it very much because it exposes exploitation (via the Archive) and exploration (via the Population) as almost separable processes. You feel like things are getting stuck, let the Population grow a bit and do more random restarting and exploratory search for weird alternatives; you feel like things are getting too wild, you do fewer, shorter cascades and keep a bigger Archive, really nail down the variations on the already-discovered themes you’ve collected there. Play around, fiddle the knobs, see what you get.
And that’s the point, of course. There is no “best” search algorithm. Don’t make me link to that paper again.
You have to pay attention. You have to bring to bear a vast combinatorial armamentarium. You have to keep a seven-drawer toolbox in the virtual garage, with a hundred different wrenches in it, and then look at your problem and listen to your algorithm purring along, and reach into a drawer without looking and find just the right tool, and give that algorithm a little tightening here, a little shimmy there, grind a bit off the edge, take it apart and put it together again slightly better. With grease.
See, it’s not about solving your problem as fast as possible. It’s about watching it improve, and having the sense to see it improving. About having the tools on hand and the experience under your hat so you can intervene in a reasonable and effective way.
So, yes: there are other ways. None are best.
March 17, 2008 at 5:24 pm · Filed under Project
First more-or-less complete shell images of the new house have appeared. First post on project blog for our Nudge genetic programming thing has appeared. And many thanks for all the supportive voices we’ve heard in comments online and met at SXSWi regarding our (still intentionally) vague effort at Not An Employee.
February 29, 2008 at 5:34 pm · Filed under Project
One of the reasons it’s been relatively quiet here in the last few months is that I’ve been working on several projects. Not secret, as such; just the opposite in fact. But one doesn’t want to subject the world to half-formed notions.
The first real project went out the door today:
With Laura Fisher, Barbara Tozier, and Brian Kerr, we’ve made… something. We’ll see what it is, what it becomes.
Like many things these days, many things I’ve got my fingers in, many of the buttons I push, it may sound like a joke. It is; it was. And it’s not.
Who are you? And who do you serve?
Just what is it that you do?
May 22, 2007 at 8:41 pm · Filed under Project
Barbara points out that I’m perhaps over-generalizing in my earlier rant on conformity in academia, and that also perhaps I’ve elided the actual point.
If I were to sum up my concern, it’s the paucity of varieties of work in academic and industrial research. Not a cry about the monotony of personae or approaches, nor any worry about social activism.
But the…well the fact of monopoly. You get right down to it, there is exactly one life-course for a scientist. Or a historian. Or an engineer. You’re either merely an Amateur, or you’re on The Track.
You can tell those in The Track. I see them on the street, in this college town, and I know immediately what they do from the way they dress. Nine times out of ten, I can pick the campus they’re from (artsy, engineery, undregraddy, &c). Barbara thinks this might be different in other parts of the country or world, and might be different in the West especially. I don’t know; that might be a dilution effect, merely caused by mingling with laymen in big cities, or the practical necessity of Not Wearing Black in the Desert that makes professionals in Albuquerque look a bit more like paleontologists.
At any rate, what worries me is that the social and cultural norms that dictate appearance must also dictate worldview, worklife, options. I’m worried about the heretics.
The Academy really is the sort of monopoly that ended badly, back in the days of the Reformation.
And my question is not whether it exists. My question is: What will happen when it starts to break down?
Which it will. And soon.
May 21, 2007 at 11:19 pm · Filed under Project
As with the other project sketches this is something that I plan on taking up myself, but am posting a running account here as practice for real-time project-blogging. Readers are encouraged to follow along themselves if they get interested or bored or inspired or whatever.
This is an exploration. Don’t know if it will work. It’s intended to be an approach for creating algorithmic images, or for artifying pre-existing images. There are innumerable variations, but I’ve decided on a simple one to try first, just to see if the outcome is anything like what I expect.
I’ve been thinking about this one, on and off, for about ten years. A few years ago somebody recommended I look at the Image Analogies project at NYU, which is really cool if you haven’t seen it. That’s related, but what I had in mind for this was something less practical. Through the years I’ve dabbled in Mathematica a bit and done it wrong, and played in R with neural implementations. All unsatisfactory. But I had an insight a few days back that clarifies it and makes it much more attainable.
And I was thinking of using it in the blog redesign, if it does what I suspect it will. cron jobs, of course.
I’ll sketch the project now, and then report the results of a planning session and all the iterations as I actually make my moves. I expect it wouldn’t take more than a few hours if I were hacking it; I don’t intend to hack it. I intend to do it with unit and acceptance tests, if I can convince myself unit testing is feasible in Mathematica or R or wherever I work it through. Maybe I’ll do it in Ruby or Python, for the testing.
I’ll also add diagrams as I work on it. Right now I’m just going to jot it down. Admittedly, as a project involving bitmaps and some geometry, diagrams would help. And so they will. Just not tonight.
In a nutshell: The project will take an image or set of images as exemplars. It will create a database of scaled color pyramids from the exemplar(s). A color pyramid of scale n with origin at pixel (i,j) is composed of a tuple of four “center” colors, and a tuple of eight “edge” colors. The four “center” colors are the average colors of the four n×n squares of pixels starting at (i,j), (i+n,j), (i,j+n), and (i+n,j+n), respectively—NW, NE, SW, and SE in that order. The eight “edge” colors are the equivalent averages, but for squares 2n×2n on a side, surrounding the four center squares, in the order NW, N, NE, E, SE, S, SW, W.
Now if (i,j) is too close to an edge of the image, clearly some of these square regions will overlap or lie outside the proper dimensions of the picture. We’ll assume that there’s a solid background color, defaulting to white, out there. So a pyramid (of any scale) with origin in the upper leftmost pixel of the image will have its NW, N, NE, SW, and W edge squares lying entirely outside the image, and composed entirely of the background color.
So a pyramid of scale 1 contains four one-pixel squares in the center, and eight 2×2 pixel squares on the edges. The center colors are the colors of those four pixels; the edge colors are the averages of the four pixels in each of the eight larger squares.
Like I said: diagrams will help. Just not now.
Anyway, to preprocess an exemplar image, we’ll be generating a database of all possible pyramids (where every center square contains only image data) of scale 1, 2, 4, 8, 16 and 32 (6×6, 12×12, 24×24, 48×48, 96×96 and 192×192 and pixels, respectively). Just keep a list, maintaining repeated samples if there are any.
I’m thinking a scan of text. Something black-and-white, to begin with at least.
Got the data? OK. Now create and train a Kohonen SOM from each scale’s samples based only on the four center colors. Ignore the nine edge colors for the training period; just cluster the pyramid data at each scale on the basis of the four center features.
All trained up? OK. Now for each pyramid in the dataset, assign it an index value based on the cell of the Kohonen network where it ended up being placed. Some unique identifier so that when a pattern is matched to the trained network on the basis of its four center colors, we can obtain the entire set of training patterns that map to that same cell.
Now we have an image [de]generator: I can specify the center colors of an arbitrary pyramid of some scale. We can look it up by finding the cell of the correct Kohonen network that’s the closest Euclidean match. We can then query the database and obtain a list of exemplar pyramids that match that same cell, and pick one of those at random.
Let’s grab a new image. Something unlike the exemplar, or maybe one just like it. Don’t care. Call this the active image.
Pick a random position in the active image, and a scale. Measure the colors of the pyramid in the active image at that scale, refer to the appropriate trained Kohonen network, and have the database spit out a related pyramid from the exemplars. Now change the colors of the pixels in all the edge squares of the pyramid, in the active image, so that they are closer to the colors in the sampled exemplar pyramid. Average them, weight them, whatever.
So for example if we’ve selected pixel (88,100) of the active image, at scale 2, the edge region that will be changed will span all 144 pixels from (84,96) to (95,107). All but the center 16 pixels of that square will become more like some pyramid in the database.
If a pyramid of a chosen scale and position overlaps the boundary, just imagine the surrounding pixels are fixed at the background color.
Iterate by picking a new pixel and scale. Not sure with what probabilities, but probably some kind of weight over the set of scales. Keep going until things get interesting.
The point, of course, is that the pyramids from the exemplar won’t exactly match the traits of the active image, and that it should get kindof munged up, or even surreal, as pyramids are replaced. One might consider applying pyramids from a scanned text page to a landscape; pyramids from a Dutch master’s still life to a snapshot; pyramids from a Persian rug to one’s cat picture.
We’ll see how it works out.
May 17, 2007 at 7:10 am · Filed under Project
So lately I’m writing a fundraising proposal; a manifesto; a series of blog posts; a press release. All at once. One thing.
Spending a lot of time writing, reworking, simplifying—because the funding audience for this proposal is very broad (you may well be in it), but more important because my underlying vision is maybe like five steps removed from anything anybody’s done before. I’ve pitched the thing to about a dozen trusted listeners, and while there’s been loads of enthusiasm and only limited mutual confusion in the end, on average every conversation contains about five missed insights, of the form:
I: See, the whole point of this is X.
They: OK. I think I get it. Sure. But it sounds like you’re just describing a Y.
I: Ummm, no. Y is fine, and great, but this is X. Y’s have a, b, and c. We specifically avoid a and b, and give c away for free. See?
They: Ohhhh! OK! Cool!
[repeat 4 times, replacing X, Y, a, b, c]
So that’s a challenge. You may be able convince somebody to give you a patent or fund your business or fund your grant proposal on the virtue of one X/Y disconnect—that’s your improvement, your competitive edge in entrepreneurial ventures, your key insight in the life of the mind. If you’re looking for a cultural transformation that entails some deeply-held social and cultural norms (aka “want to change the world”) and there are five or more of these little startling jumps… you haven’t got the right metaphor yet.
Don’t worry, I won’t be vague anymore beyond the end of the month, and maybe the end of the week. I’m down to two X/Y pairs now, and I spent a long philosophical time last night stamping that out.
In the life-cycle of a big project, whether it’s a book or a business, a grant or a program, there comes a transition between its existence as cagey vaporware and its crystallization into an autonomous named entity. A kind of project individuation.
My friend Ron is writing a book, and he’s also at this embryonic stage where he’s loathe to show it around. Not so much because it fails to match his vision, but I suspect because the story isn’t clear, yet. He knows his story, as I do mine; what’s wanted is the transformation into something communicative, with relevance to the right subset of listeners.
A pitch’s relevance depends not merely on the words on the page. You don’t inspire the reader to understand the relevance of a thing merely by describing it in a manifesto, or an essay, or even a paean. The challenge of conveying relevance includes connoting all the correct subtexts — the suite of cultural ideas you want to bring to the fore and the avoidance of the implications you want to downplay. Format, presentation, logo, fonts, phrasing, length of sentences, rhetorical style, professionalism in the written or spoken word, graphical style: to every listener or reader these define you as a member of some stereotyped group. Not just the first impression, but every impression conveys meaning.
Sometimes even those confusing disconnects, those X/Y mismatches, can be used effectively in conveying meaning.
One’s goal is not to drop the idea on the table in front of the audience. One’s goal is, or should be, to create in the target’s mind a state of deep understanding. The best stories leave no room for “Why would anybody do that?” or “Why would you do it that way?”, and often don’t even waste time saying it outright. They can make the necessary schema plain with simplicity and grace.
Pitches are not memes. There are no memes. Pitches are engineering projects; the listeners’ minds are the raw material, and the expansion of the author’s vision their goal.
May 15, 2007 at 9:13 pm · Filed under Project
This is a software project; a simple web app. Ruby on Rails should do just fine.
Still waiting to do a real planning game session on it, but here are some general notes.
The main focus will be presenting scanned images of old booksellers’, auction and publishers’ catalogs. Visitors will be able to do the normal stuff you might expect from a basic web2.0 framework: page through the booklets, search for text, comment on pages, tag things.
Somewhere along the line OCRed or other text conversion will want to happen, but at the moment there seems to be enough value for the participants in simply being able to search the catalogs based on back-office OCR markup. In other words, no need to present the text itself; the OCR can generate searchable text blocks in preprocessing.
There are long-term social aspects, and a number of potentially useful follow-ons, but as of now the core project objectives will be (in no particular order):
- Simplicity for uploading and administering catalog scans: things should just basically spoot out of ABBYY FineReader into the database interface, somehow.
- Searchability. There should be useful words of some sort that people can search over, and expect to see pages from catalogs they’re interested in. All that stuff about false positives and false negatives will play out in the testing phase, no doubt.
- Commenting. Folks should be able to say stuff. Not so much the bots, but folks definitely.
- Usability. Not too stupid an interface. Simple. Not cluttered; not inaccessible; not frilly; not full of uselessness or Google ads or such. Just pages, and some little dabs of interface.
- Flexible domain model. It should be trivial and obvious to amend or improve the text versions of the page scans, to add missing pages whenever they’re found and present partial works before then, to manage multiple editions or versions or issues of periodicals or volumes of sets.
More in a bit.
May 15, 2007 at 9:29 am · Filed under Project
In a conversation with Laura Fisher the other day at Cafe Primo, she brought up a notion she’s exploring about a layout for dynamic content: blogs, sites. Something not at all, or not as much, like a printed page or an unrolling scroll.
We discussed treemaps, and the fact that Brian Kerr had already suggested those. I got to thinking about some ideas we explored back in the Data Pageant days for realtime visualization of chatter and buzz about stocks. I wonder if they might be implemented as a relatively simple—and interpretable (and maybe even useful)—blog interface as well.
There are a few problems with treemaps as an interface infrastructure. On the one hand, we use subdivision to indicate hierarchy in treemap layouts, but at the same time we rely on size of cells to communicate something about relative abundance or importance of these hierarchically-organized classes. The mapping of linearly decomposable scales is fine if you’re talking about how something’s subdivided (the stock market, an economy, a list of species), but it doesn’t exactly rock when you need—as with blogging—to highlight something that’s just been added to a collection, against a background of lots of other pre-existing entries. The new entry’s block will over time tend to be a smaller and smaller piece of the big visual pie, and as a result you dilute away your newest stuff at the expense of older things. Then there’s the question of what linearly decomposable thing you’re measuring: words blogged? visitors? page views?
Eh.
So say you have some things. Blog entries, articles, bookmarks, that sort of thing. Let’s stick with blog entries.
These have a few important attributes that you can measure, and care about. In a blogging context, think maybe “post date” and “page rank” and “most recent comment time” and “trackbacks” and “length” and “tag set”. Stuff like that. Note, some might be quantitative variables, some might be categorical; who cares?
Let’s use for example “age” and “tags set” and “page rank” and “most recent comment time”. Off the cuff, say we want to lay out all our blog posts, or maybe the last 100 or so, in a kind of lattice in a rectangular region. Newer posts are closer to the top of the rectangle; posts that are more closely related in tag space are closer to each other horizontally; posts that have larger page rank are larger; comment time is used to highlight posts that have more recent comment activity, and this fades to background over some window of time.
For the sake of simple math, let’s lay the posts out as if they were points in this rectangle.
The age variable is pretty straightforward: we put the newest posts near the top, and the oldest one at the bottom of the range. We could string them out evenly, or proportional to their actual post dates; hold that in mind as an experimental design variable for now.
The horizontal axis is some kind of “similarity”, and it involves the tag clouds (or lacking those, semantically interesting terms) in the posts. To save space and time, let’s elide what happens here by summarizing it as “we cluster them”: we can use a hierarchical clustering algorithm, or a self-organized map, or whatever the heck we want. In the former case, we end up with a tree of some sort, and we’re left with the decision of how to place the various leaves; we could have the bushiest branches in the middle, and the spindly ones at the edges, or order them in decreasing size so the most similar things are all at one side, and the weird miscellaneous things at the other. An SOM provides an explicit spatial arrangement of entries once it’s converged, and we could just map that to the x axis as we see fit. Again, we’re left with a design choice as to whether we space things evenly or proportionally. For example, if we have a hierarchical cluster tree of 100 blog entries, we could trim it a little below the leaves so we get 7 clusters, and give those equal space along the x-axis.
Fiddle around. To be honest I wonder if the scaling thing matters much. Order does, though.
So we have some points scattered in this rectangle. And we’ve imposed an order in both dimensions. Let’s preserve that order by linking these points together in a Delaunay triangulation. Connect the dots; close neighbors are alike, we’ll argue, so tie ‘em up.
And whenever you have a Delaunay triangulation, you have a Voronoi tesselation. And we mentioned “size” being linked to “page rank”, so move the dots around by adjusting the Delaunay link lengths until the areas of the tesserae are as close as possible to the page-rank measure we want to capture. If instead you want all the posts to have equal area, then do that instead: make all the links the same length, as much as possible.
And then paint-by-numbers with “comment time” pigments when you’re done.
Do all this layout business in server-side processing, whenever you post a new article; those variables won’t change. Do the coloring on the fly if you really think your posts’ page-rank will be changing that quickly.
Admittedly, the weird-ass shapes of Voronoi tesserae pose a design challenge for the rollover artist out there, but an interesting and instructive one. Can you make an interesting rollover effect in pure PNG-driven graphics, or do you need to use Flash? Can the points be used as the centers of squares of the right size and shape, or rather can you position the points and then “grow” squares from them until they touch one another, and get an accurate size that way?
Dunno. We were doing stocks, and it was a long time ago. I’d be curious to hear, though.
Older entries »
Subscribe to posts feed