Do yourself a favor and point your browser to this amazing video by Erik Natzke (who is another one of my heroes in this genre). I believe it's called Atmospherik, and this video I think is part of a larger piece (28 minutes). (I can't tell for sure, as I found this link from some stills on Flickr.)

I still can't effectively describe how this piece made me feel. There were times when it felt as if I was watching the creation of a universe. Other times it was like seeing some really wonderful abstract paintings come to life.

Well done, Mr. Natzke.
posted on 11/11/2007 11:32:00 PM

I am giving Disqus a try for a comments solution for this here blog. I was a little loathe to use blogger's comments, as they're a bigger target for spammers. So give me a shout, won't you?
posted on 11/02/2007 02:01:00 AM

This



and this


are the future of source code. Well, I suppose technically they're the present of source code, as HTML could be considered code and these screenshots are from a shipping application, not a tech demo.

However I think more benefit could be derived from this approach if it were applied to turing-complete programming languages like Java, Ruby, and possibly domain-specific languages (DSLs). These screenshots are from an OS X application called Xyle Scope, by a software house called Cultured Code. Highly recommended. Good stuff.

Anyway, I think the thing that makes this presentation so slick is that it shows how you can judiciously use typography and graphic design to substitute for what I consider the dumber elements of programming language syntax (like parentheses, dots, brackets, etc.).

I think I might take a stab at presenting Java source code using this sort of scheme, just to see if it would be more readable (which, in the end, is really what this exercise is all about).

If anyone has any ideas about this, please drop me a line: mark (at symbol) figuresix (dot) com.
posted on 10/22/2007 10:26:00 PM

Pending the resolution of a few technical issues (openGL applet deployment) to work out, I have 5 new (well, new for you) sketches to put online. All of them involve OpenGL with Processing, since I'm very much in love with the hardware-accelerated smooooothness that it enables.

More than just being eye candy, the smoothness afforded by hardware acceleration makes a whole new class of interactions feasible. For example, take the iPhone (or better yet, buy one for me); the touch-screen interaction really only works because the display is able to seem (*feel*) responsive. If the tracking of the touch inputs were slower or the display couldn't quite keep up, it would become an incredibly frustrating UI experience. As it is, however, the interface is responsive enough to make it feel like you're manipulating something that is fairly close to being real.

Contrast this experience with most other touchscreen kiosks/ATMs/ticketing terminals and you'll see (*feel*) what I mean.

Anyway, here are a few screenshots to whet your appetite while I work out getting these things to run correctly as applets on OS X. Failing that, I will probably force myself to learn about creating quicktime output, a la Flight 404. On the other hand, the bar has been raised considerably (thanks to Flight 404, et al) with respect to Processing and offline-rendered content. The sketches were written to be simple enough that they could be executed in real time on a fairly cheap piece of hardware. Moving to offline makes me think I'd have to up the production value if I can hang with the rest of the processing bunch.

So here are a few screenshots for the sake of screenshots.









n.b. - The photos in the last screenshot are not mine.
posted on 9/05/2007 10:52:00 PM

I am really happy that interesting work continues to be done with the Processing language, a really nifty graphics-oriented language that makes it possible to do some very cool things with rather small amounts of code.

My Processing heros of the moment are (and right now I'm too lazy to track down their actual names):

- Flight 404
- Quasimondo
and
- Toxi

Great stuff abounds here. Do go check them out.
posted on 5/02/2007 09:31:00 PM

In the realm of flash/processing/etc visual goofery, the term 'art' is often thrown around, but not often deserved.

However.

This piece by the guy at quasimondo.com is the first piece I've seen that really made me feel something.

Essentially it's something that grabs photos from flickr, adds effects, animates and loops while playing a generated soundtrack.

But it's way more than that, or at least it feels that way. It feels like memory. Or seeing someone else's memory, and the way they think about them, coming back again and again to one image or another. The soundtrack adds another layer, but for some reason, it's not an added dimension of warmth. I liked it better playing against the background of something spacious, minimal, and comtemplative, like the band Explosions In the Sky.

I don't really have a great definition for art, but I think the thing that gives this piece its spark is that all of the photos are a piece of human intent. But what do I know.

Anyway, go check it out. Great stuff.
posted on 4/20/2007 10:14:00 PM

Two really wonderful "Command-Line-For-The-21st-Century" products I've had the pleasure to work with recently are, Quicksilver (for OS X)


and Enso (for Win XP).


I call these post-unix CLIs for a few reasons:

• They are instantly accessible via keyboard shortcuts (no alt-tabbing through the plethora of open applications to get to it)


• They are modeless in that there's no cd-ing around to get to wherever you want to execute a certain command


• They provide fast, pre-indexed searches (i.e., fast searches) of their cataloged material (generally executables, bookmarks, mp3s, documents)


• They go beyond the 80-character monospaced font presentation that has been the rule for command line implementations

Deep vs. Wide Interaction

I'm really glad that folks have pursued this avenue of UI because it provides the really wide interaction available via keystrokes versus the deep interaction of mouse or other pointer/gestural interfaces.

For example, within a few keystrokes you can specify one out of hundreds of thousands of commands, names, etc. However, more nuanced spacial/visual interaction, like sketching, selection of an unnamed image, etc., is better done via a mouse or pen interface.

With the advent of WIMP (window/icon/mouse/pointer) interfaces, it looked like the command line might disappear from most desktops forever. But with these two products it looks like CLI power might continue, without much of the baggage of the traditional command prompt.

You can get things done lightning-quick with both of these, though Quicksilver is by far the more mature of the pair, with a bit more polish and more of a plugin community built up around it. However, Enso looks like they have some interesting expansions planned; also, I'm really interested in how they move forward, flying the usability flag high for all to see. (I can't help it; I like reading books about interaction, and when they drop names like Jef Raskin I get excited to see how some of those ideas turn out in practical application.
posted on 4/18/2007 10:54:00 PM

So here's a nice little step forward for webapp-kind: Live Clipboard, a somewhat small bit of technological innovation, but a firm step forward in actually delivering the promises that were made about computers decades ago (easy sharing of information). I say this not to belittle the effort at all; on the contrary, interoperability between different pieces of software is a huge thing, but something that you would totally take for granted if you weren't aware of the inner workings of software. Image and text copy and paste has been here for a while, but more semantically rich copy and paste is even more exciting (if you actually get worked up about these things like I do).

Someone (not me) said... "Imagine what it will be like, the first time somebody reaches for Right-Click/Copy in a Web app and it does exactly what they expect."
posted on 3/16/2006 10:20:00 PM

Lots of cool things have been happening in the web-app world as of late, and there are some very exciting bits of it that I think are going to contribute to the next bit of a jump in software usefulness. In my opinion, many of these bits have to do with them being inherently networked applications, using a common model and delivery mechanism. The other cool bits arise from the interesting things that happen when lots of people contribute in different ways (the human networking effect).

Software that talks to other software (the technical network effect) The accessibility and remixability of these new apps yields some astounding results... for example, Google Maps matched up with Craigslist real estate ads (oh MAN, if I could have had that when I was looking for houses), Google News, Greasemonkey scripts that tell you if the book you're looking at on Amazon is available at your local library. Though lots of this is now being done with simple, well-defined web APIs, I've also seen some impressive stuff done with just screen-scraping of HTML. Another really great example is some of the stuff being done at Yub Nub, which is in a lot of ways the internet command line that I had been dreaming of a few years back.

Software that learns from its users (the human network effect) - More and more web applications are taking advantage of thousands of brains; Amazon's recommendations and Google's page-ranking come immediately to mind, but there's also del.icio.us, flickr, and any number of other apps that are doing really interesting things just by noticing what people do and like; sort of like taking advantage of the footpaths that get worn in the grass by lots of people walking from one destination to another.

It was only a matter of time before this convergence of things got a name, and the name kinda scares me: "Web 2.0" The number of ways that this term is going to be misused just makes my skin crawl. It's also doomed to become a cliche and known mostly by a superficial feature: the use of lots of DHTML.

However... it does seem that there are lots of folks out there who do "get it". I stumbled on an article at The Social Software Weblog called Approaching a definition of Web 2.0 that that crystallized a lot of the thinking I've been doing about applications for that past couple of years.

And, since I'm a sucker for visualization, here's a nice diagram from the aforementioned article that shows the interaction of some of the features I've mentioned above. Hurrah for diagrams!


posted on 10/01/2005 12:58:00 AM

Note: this post was started months ago (it's currently October), and could be a lot more fleshed-out than it currently is. However, in the interest of actually getting new content on this blog, I'm slapping it up here with all its warts and missing bits.

There are a few areas where web apps are way ahead of their bigger, often faster, native cousin, the Desktop App. In fact, you'll see that a good number of desktop apps are beginning to take some cues from their angle-bracketed cousins.

Decent visual design (or, Goodbye, Sea of Gray Dialog Boxes)
This is likely an artifact of the ratio of graphic design folks to programmer folks in the world of the web (versus the world of desktop apps). More than just looking better, well-designed web apps just make much better visual sense. Go look at something like Odeo or Backpack if you want to see what I mean. There's something about the flexibility of page layout that just seems to work really well. On the other hand, different types of applications require different sorts of interfaces.

I'm actually waiting for someone to come out with a good, solid way to make "hybrid" apps that can take advantage of web page-like flexible layout but still have some of the local/native-code speed benefits of a fat client. The Eclipse platform's Forms API is a step in this direction, but I do think it could be made much simpler.

Familiar Metaphor, Simplicity
The web page is a much simpler mental model for normal folks. People just seem to "get it" much more easily, and they seem less intimidated by web apps. This may be due to forced app simplicity imposed by the limitations of being a web app, but sometimes this is a really good thing.


Common, Scriptable, Hackable Model
Web applications are based upon HTML pages. While this seems like a nasty limitation (and believe me, sometimes it really is), it is also a huge boon for mix-and-match applications.
If you haven't checked out Greasemonkey, go check it out soon or you will miss out on one of the most exciting things to happen to applications in a LONG, LONG time.

With the exception of cut/paste/drag/drop, desktop applications are largely missing out on this interoperability.


Your data is everywhere you are
At some point desktop apps will catch up with this, but for the time being, they're way behind in terms of data accessibility. Of course web apps require you to be connected to the net (mostly), but this requirement gives you the flexibility to access this data from anywhere you are. I think the whole "your data is in the cloud and it doesn't matter what directory it's sitting in" thing will become more and more prevalent. Of course, this also introduces some interesting security issues.

Connected, connected, connected
I'm sure I'm not the first person to think about this, but it seems to me that the usefulness of a program and its associated data are proportional to how available it is to be connected to/accessed from other computers and other programs. For example, check out all the wonderful hacks associated with Google Maps. There lies the future, folks!

Needless to say, web apps aren't appropriate for every purpose. I'm not sure that I would want to do photo editing in a web app that didn't have some serious additional controls beyond text areas, buttons, and dropdowns; similarly, I'd hate to have to run a drawing program or surf the web with only a command-line.
posted on 7/21/2005 10:51:00 PM