What do you want from your special FX?

Since Sun announced the JavaFX meta-project awhile back (2007?), there’s been a lot of commentary, mostly negative, on the effort; but I think a great deal of this misses the point, which is that FX is not primarily aimed at the RIA market, but at the much larger market of devices.

Look, raise your hands if you use an RIA app on a daily basis. Heck, on a weekly basis. I don’t. Nobody I know does. I’ve downloaded some, browsed through the demos, and hey–I use a lot of software, I test drive a lot. And I haven’t seen any compelling RIA apps that I need to keep installed and turn to to solve my problems–any problems, in fact.

That’s not to say that there isn’t an RIA revolution around the corner. But I think JavaFX is aiming for something else–a market I’m pretty sure Adobe and Microsoft are also aiming at–which is devices that can support high-quality video, UI stacks, and audio, and which are connected to a network at least part of the time. A turning point for me was when I was at the airport–I think in England–a few months ago, and I was waiting in line to check in. Looking around, I saw a TV-sized device showing inbound and outbound flights. The monitor, like the airport, was a recent vintage, and the display eschewed the traditional, colored-test UIs which I’d grown to know in many airports for a modern, sleek, highly readable and informative display. The colors were better, as were the fonts and layouts; there were icons representing the carriers, and these flipped around to show other icons indicating on-time, or delayed. The animations between screens showing inbound and outbound flights were not distracting, but rather a small cue that said, “We’re about to show you something new.” There were also, IIRC, advertisements that showed up occasionally. I could have done without those.

Anyway, it was at that moment, looking at this new-fangled airport info screen that I realized: that’s the point of this excercise. That’s where Sun, with JavaFX, wants to be. All of these devices, almost regardless of size, which people use every day to gather information, entertain themselves, communicate, plan, that was the target for this platform. And that market is HUGE. That’s not just mobile phones and smart phones, that’s music players and TVs and set-top boxes and info terminals for tourists and monitors at airports and handheld GPS devices and who knows what else. It’s any screen attached to any computer which is powerful enough to drive a modern GUI interface and smart enough to pull stuff from the internet when it needs to.

That market is not new, but what is new is that the cost of a decent hardware platform–decent graphics cards, a chunk of memory, a good amount of disk space, a high-quality screen–has fallen dramatically and continues to do so. If you can enter that market with a set of tools allowing you to write–more or less– code that runs on your desktop as well as that other device, I think that’s a big deal. Because you’ve not just reduced (or eliminated) the effort of porting the software, you’ve granted the developer a gift: they no longer have to learn a specialized toolkit to write to one of these devices, and they no longer have to learn different stacks to work across different types of devices, different models of those devices, from different vendors.

A number of bloggers (and blog-commenters) are focusing on JavaFX Script, and I do think it deserves attention. Actually, I think JavaFX Script will end up doing well in its space. But I think we have to look at the larger picture, and the larger picture is dramatically improving hardware across all devices, and Sun believes it can offer a solution that’s comprehensive and which is an incremental improvement to something that already works in the field. The motto is, we can do more now. That, it seems to me, is the market that Sun is aiming at, and it’s much bigger, and much more important, than the hold-your-breath RIA space.

Posted in Uncategorized | Tagged , | Comments Off

Bite through the skin to get to the pulp

I just came across PulpCore, a open-source 2D rendering and animation framework for the Java plug-in. I found the demos really impressive, in part because the experience of launching them was so straightforward and non-intrusive. It made me think–wait for it–that I was launching something in Flash. But these are Java applets; it’s just that they’ve actually taken the time to subvert the normal launch process so that you’re not reminded that, first, this is written in Java, and second, this is going to take awhile. Go check out the demos, see if you don’t agree. Among others, there’s a fun, silly little game called Milpa, a cool compositing demo, and a nice demo with layered text, among many others.

Discovering PulpCore allowed me to re-discover two cool Java libraries, Phys2D and JBox2D. Both are ports of a “2d rigid body physics engine, written in C++ by Erin Catto” called Box2D. From what I could pick up on various forums and blogs, Phys2D is based on an older version of JBox2D; the API is apparently somewhat easier to use than JBox2D, but the latter has been working on improving performance over time, so that at this point, JBox2D is faster, but Phys2D somewhat easier to use. Whatever: they both demo well. I like that you can hit the space bar to cause boxes and beach balls to go rocketing into whatever pile of bricks are shifting around on-screen. Rigid-body physics doesn’t have to be boring.

Back to PulpCore. I think PulpCore has that first-day-of-spring feel to it. I don’t mean that it’s new, or that you can’t see the same types of graphics effect using a dozen different languages these days, but rather the author’s own enthusiasm for the thing comes through in the demos. The demos just seem cool to me. Nice choice of colors. Clean layout. Each demo has a clear focus. Sharp edges. Good user experience.

I get this same kind of feeling quite often with Processing demos. It’s somehow refreshing to me that people are writing these little apps, making this dynamic, evocative artwork, just for the sheer joy of it. They aren’t telling you they’ve found the next big thing, they’re showing you what something that makes them happy, that excites them, draws them in. Maybe they spent hours, days, weeks getting that demo to run well and look nice. All of that energy, focus, drive, and joy in creating this work comes across to the person viewing the end product, at least, that’s my experience of it. Check out the videos posted by flight404 on vimeo.com to see more of what I’m talking about.

I used to get this same feeling about the demos posted about a language then called F3. The language is now becoming a product–on the eve of it’s first full release–but in the meantime, the life has been sucked out of it; marketing is in full swing and we’re being told, again and again, how this will be (one of the) next big thing(s). But I miss that old feeling, that spark of life that I got from the first demos the developer of F3 used to post once a month or so. I don’t want to be told that I’m going to have the next big thing, I want to experience something–I mean, I don’t even want to experience something special, I’m not looking for that, but if you do your job right, that’s what happens–I pick up on your enthusiasm, the fun you had creating this thing. It’s the life that is on full display when someone discovers joy, excitement, something cool–and pours that into their artwork and it reflects back outwards towards you, the visitor. I hope that the technical work that’s taking place around F3–a full compiler, a new runtime, graphics libraries–will be thrown into the shoebox and they all end up as newer, better tools in the hands of people seeking joy. Me, I don’t need another stinking RIA app. I just wanna have a little fun.

Posted in Uncategorized | Tagged , , | Comments Off

Visual Guice

I’ve been meaning/intending to try out Google Guice for awhile now; just saw they threw together a simple graph visualization for dependencies declared in Guice. Looks nice. I haven’t found a Spring visualization library yet that I like, and I don’t use one. I end up having to keep track of it in my head or by navigating through the config files. For some modules I’m working on, it’s kind of a hassle.

I don’t think visualization solves all problems, but back when I used to do more database design as part of project development, having a well laid-out ERD was a huge help in communication. If the database is well designed, part of which (in my mind) implies consistency, having an ERD at hand is like having a good street map when you’re toodling around town. ERDs save a lot of time finding your way around the database, planning and writing queries, and work as a focal point in discussions–I often found there was no problem in getting non-technical folk to pick up the model format and be able to make their points using the diagram. ERDs are actually pretty easy to keep in sync with the database, at least as far as entities, attributes, constraints and such are concerned. The biggest chunk of work was actually in laying the elements of the diagram out, always trying to keep the relationship lines from crossing each other. It was often worth a pat on the back if you found a layout that was neither too large (across many pages) nor too cramped, and which was easy to follow.

Which all reminds me of a great little tool written by Alex Moffat a few years ago for drawing UML sequence diagrams. The tool was called Sequence. I don’t think he’s been maintaining it, but other people have picked it up and incorporated it here and there; there’s a version that generates sequence diagrams from JavaDoc tags, for example. The best thing about Sequence was that Alex wrote a small DSL with which you could describe a sequence of operations very concisely. There is a parser for the DSL, though it exists purely to create the diagrams. I think Sequence is a great example of little tools that make your life a lot easier. Here’s one example of the syntax (taken from the help docs).

Comments.newComment {
  CommentFactory.newComment -> "the new comment" {
    Comment.<> {
      IDGen.nextID -> newId;
      Comments.getSize -> size;
  Comments.addToCache(the new comment);

which leads to this

Sample UML sequence diagram

Posted in Uncategorized | Comments Off

Fruit flies in the JVM

Fresh winds are whipping through the JVM development community, and they aren’t–apart from JavaFX–coming from Sun. The hype around multiple (“more than 200!”) languages running on the JVM has led an acceptance that running something other than Java, and something other than a simple scripting language, on the JVM, is not only a distinct possibility but also a competitive advantage allowing developers to expand their toolkits and skillsets horizontally rather than orthogonally. What I mean is that new languages, or new implementations of existing languages, on the JVM allow developers with an investment in JVM stacks to try new things out without leaving that stack behind.

It’s odd, but now I’m getting the feeling there are new languages popping up for the JVM on a monthly basis; this is mistaken, since in reality, getting a language to a stable enough state to be published seems to a take many months or even several years of hard development work. Still, we are seeing much more than just JVM-based implementations of Python and Ruby, and we’re seeing it happen more quickly than I think anyone would have expected. And they are announced without much fanfare and without much corporate backing or marketing muscle behind them; that’s a change, and a welcome one.

I think there are several core developments to the landscape that are enabling this:

  • It’s much easier to test against multiple OSs these days, what with dual/triple boot machines, live CDs, and virtualization; that means your language can be relevant on the 3-4 major OS platforms from day 1.
  • The infrastructure to host code, source control, and to document what you’re doing is now very, very cheap. With a little elbow grease you can promote your new product with a spit and polish that a few years ago would have only been possible if you had money in the bank. This is a big plus for developers who want to see the samples, APIs, and run the 5-minute build-a-blog test.
  • There’s more acceptance of new languages, and, I think, the arrival of production-ready implementations like JRuby and Groovy on the JVM offers hope that we have real alternatives in solving real problems, and that we no longer need to commit to one language and one stack in building out our applications.
  • The widespread use of RSS/Atom-based promotion, blogs, and online video draws much more attention, at low or no cost, to the work you’re promoting, and it happens much more quickly than before.
  • The consultants who used to make a killing on promoting Java are seeing their rates fall and need new markets to conquer. OK, that’s being mean, but these people are offering free promotion in very public forums–not just blogs but conference presentations and workshops.

What’s missing, I think, but not far off, is making IDE support for new languages a core component of a new language’s early code drop. The more people write language support plugins for the major JVM IDEs (Eclipse, NetBeans, IDEA), the more the IDE developers try to improve this support and build out their support libraries, and the more end-users see that these IDEs are no longer aimed merely at Java. I think that the IDE situation needs to improve some more; given the pace at which these plugins are being developed, it seems, from the outside, to remain a pretty time-consuming task to get full-featured language support in an IDE. Part of this depends on the complexity of the target language–for example, Scala has a reputation among those developing plugins for it to be pretty hairy, and in the time elapsed since Scala first started drawing more interest, we are still stuck with one complete plugin for Eclipse, and two plugins, for NetBeans and IDEA, that are not even in an alpha release yet. I do wonder if the task can’t be made easier, though. How, I’m not sure (I’ve never tried writing one), but if we can simplify the task and shorten the development cycle, we’ll enter into a really fertile period for language development, where releasing a language plugin, possibly for 3 IDEs at once, wil be considered commonplace rather than unusual.

Some “new” languages that just popped up on my radar are Mantra and JSqueak; there was also Talc and Fan a few months ago. Here’s a list of languages that I’m starting to keep an eye on–it’s a pretty limited list, given what’s actually out there. The links point to the home page for the project.

  • Scala: “Scala is a general purpose programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. It is also fully interoperable with Java.” Scala needs no introduction, since it gained a lot of attention, especially in the last six months.
  • Fan: no one-liner for this one (maybe that’s a good thing). One of its strengths is portability across the JVM and CLR. The authors introduced the Fan language to the JVM Languages mailing list a few months back, and recently got some airtime from Cedric Beust and Stephen Colbourne.
  • Talc: “The language Talc is an interpreted scripting language for quick and easy programming. It is simple, straightforward, and aimed at aficionados of the C family, despite its Pascal-inspired declarations. Particularly notable features are static typing, mostly C-like syntax, and the all-important curly braces”. Check out the author’s (Elliott Hughes) blog; he recently posted an interesting comparison of Java bytecode generation libraries. I find Talc interesting in part because it’s aiming to be a language with a small “l”, aiming primarily at small scripting tasks.
  • Mantra: “Mantra (Hindi for “magical incantation”) is a new dynamically-typed programming language that is syntactically similar to Java but with the flexibility and ease of programming of Ruby or Python. Mantra is not an interpreted language. Source code is translated to Java and so Mantra programs integrate trivially with plain Java code.” Mantra is the brainchild of Terence Paar, the author of the increasingly popular Antlr parser generator.
  • CAL: “A lazily evaluated, strictly-typed language…with many similarities to Haskell”; see also their introduction on the JVM Languages mailing list
  • JSqueak: “JSqueak is a Squeak interpreter written in Java.” Squeak is a Smalltalk dialect. Very cool–the demo available from the homepage runs a Squeak development environment in your browser as an applet.
  • Clojure: “Clojure is a dialect of Lisp, and shares with Lisp the code-as-data philosophy and a powerful macro system. Clojure is predominantly a functional programming language, and features a rich set of immutable, persistent data structures. When mutable state is needed, Clojure offers a software transactional memory system and reactive Agent system that ensure clean, correct, multithreaded designs.”. There are some great screencasts introducing Clojure available as well.

A good place to hang out and hear from those writing languages for the JVM is the JVM Languages Google Group. If you haven’t been following it, check out the archives; many of the most active JVM languages developers have showed up there, and there are a number of threads describing the languages in some detail.

I would be remiss if I didn’t mention Sun’s role in promoting all this, and the success they’ve had doing so. Their hiring of two JRuby core developers, and their investment in supporting Ruby and JRuby in NetBeans, as well as GlassFish, have all seemed to pay off handsomely; JRuby seems to be a real contender to standard Ruby for rubynauts. We haven’t seen as much from the Jython developers (two of whom Sun also hired), at least in public announcements; but there’s reason for hope, as they seem to have Django running (to some degree), are closing in on Python 2.5 compatibility, and will have support for Python/Jython in NetBeans by the time NetBeans 6.5 is out later this year. Anyway, seems like a good strategic move by Sun.

I should probably mention JavaFX as well, but I think I’ll wait until the SDK comes out next month and we see how well it plays in the developer community. I’ve been following the compiler mailing list since it was established, as well as that of the new scenegraph API on which the language relies, but it’s really too early to say how it will play in Peoria. The early enthusiasts are, well, enthusiastic, but outside of some pretty simple demos on the web we don’t really have anything to see at this point, much less anything useful. But they have some smart people working on it, there are some cool ideas in the language, Chris Oliver has written some awesome demos, and in general, I’m hopeful.

I’m looking forward to more surprises.

Posted in Uncategorized | Tagged , , , , , | Comments Off

Maxine-ize your investment

I thought it was worth mentioning that another stealth research project at Sun has been open-sourced (GPL v2.0), in this case, a new virtual machine written in Java called Maxine. There are presentation slides available from JavaOne 2008. Maxine came out of nowhere as far as I’m concerned; I’m glad that Sun is still investing in this kind of research, and that they’re making it available as free software.

The Maxine project owners note a set of limitations, but I think the idea itself is interesting regardless of current limitations, although they note it’s not a new idea to write a JVM in Java itself. What may be new is that they are taking advantage of Java 5 features including generics, annotations, etc. which they believe gives them a leg up.

What I’m wondering is if this will, or could, ever be a useful replacement for HotSpot. I’d be surprised, but OTOH my sense in following the HotSpot mailing lists, as well as blog postings about it, is that HotSpot is a pretty damn complex piece of software. Certainly the advantages of writing in a higher-level language than C++ seem to make it worth the effort–or at least, an area worthy of investigation.

If you’re interested in these sorts of things, it’s worth keeping an eye on the Da Vinci Machine project, which aims to explore enhancements to the JVM to make it a better/more comfortable target for languages other than Java. I also recommend Cliff Click’s blog; Cliff used to work at Sun on the HotSpot server compiler. He is following interesting research on JVM implementation techniques and provides a useful map and commentary on what he finds.

Posted in Uncategorized | Comments Off

Tools in use

I decided to stop using a Java-based IRC client, jIRC for one written specifically for OS X (I’ve been using OS X at home and Linux for work)–the Mac utility, Colloquoy, is just excellent in all ways. And what I realized is that for some tools like this, the issue isn’t Java versus another language, or SWT vs Swing, but rather that Java has to offer a compelling platform to target so that good, experienced application developers target it for their apps. There are tons of junk applications written in C or C++ that are just as ugly, slow and annoying to use as the worst Java GUI app you’ve ever used. It’s just that overall enough of the right people are attracted to the non-Java platforms that we end up with a good selection of good apps to use.

I still use jEdit regularly, although not full-time anymore; it used to be my editor of choice. If you’re a programmer, I think jEdit proves the cross-platform goals of Java really pay off. I also use Cyberduck, an FTP client for the Mac, which is also written in Java. Really great tool. The best thing is, they don’t mention Java once on their home page. I’m pretty sure they only have a UI for the Mac, which is fine by me in this case. What I like is that they are using Java to get the job done, and it helps them get the job done.

Point being: I try to choose great tools. Some of them are written in Java. End of story.

Posted in Uncategorized | Comments Off

Why bother? Sun and Client Java

I just saw this blog entry from Jan Erik Paulsen, the guy that runs Teppefall Labs. Question: why is Sun Microsystems bothering to invest in client (desktop) Java and RIA?

Sun is in danger of losing what position they have in the desktop/client market already, vis-a-vis Swing. While Swing has, by some accounts, a solid foothold in business applications (mostly internal apps), it’s not growing in popularity for general use across the major operating systems, or, as far as I can tell, for use in desktop applications. Also, with Adobe offering a client-side, auto-updating, network connected development stack with Adobe AIR, and Microsoft trying to enter the market with Silverlight, development using a “traditional” desktop application GUI framework seems less appealing. This is true even with Sun’s attempt to simplify desktop app development with the Swing App Framework and the Swing Binding Framework, even with support for both in NetBeans 6. That bundle of technologies and ideas called RIA may or may not be important as a market in the long run, but it’s certainly capturing people’s imagination.

However, a larger point is that Sun is in danger of losing its pretty sizable investment in client-side technologies already in place. I have no idea how much money and engineering resources were involved, but the entire stack we’re talking about–AWT, Swing, Java2D, Java3D/JOGL, NetBeans, etc.–is large, must have been expensive to develop, and covers a lot of ground. If Sun cedes the desktop/RIA market to Adobe (and possibly Microsoft and even Mono), all of that goes to waste, since neither Adobe nor Microsoft are building on top of that software stack. We should note as well that no one outside of Sun is currently extending or enhancing those technologies themselves–there are libraries that build on top of them, but Sun appears to be shouldering the entire burden for the whole stack.

To put a positive spin on it–Sun already has a lead in having developed certain time-consuming and difficult parts of the problem, and have it working on multiple OS platforms. Not taking advantage of that–not building on top of the large effort already completed–is a waste of an existing business investment. You could even say what Sun is doing with Java Update N is an incremental effort. They don’t need to start from scratch, and that gives Sun, at least business-wise, a pretty good leg up on the competition.

That said, there are reasons, good reasons, to be skeptical. Sun currently has no good story for (in no particular order) media (sound and video codec support), modern HTML + CSS or end-developer/designer tools. All of these are supposedly being addressed, but we really have to adopt a wait-and-see attitude, since Sun is not known for its accomplishments in any of these areas.

Worse, the hype and marketing push that’s been simmering around the “Consumer JRE” embodied in Update N masks some problems there, too

  • The new plugin, while welcome, is targeted for only two browsers, IE7 and Firefox 3. The latter hasn’t been released, and backporting to FF2 appears to be off the table for now. Opera isn’t supported, and neither is Apple’s Safari. Older and newer versions of IE aren’t being discussed, though one would hope for upwards compatibility with IE8.
  • The Quick Starter feature is not only Windows-only, it appears to be primarily targeted at Windows XP. It’s disabled by default on Windows Vista, which means it will likely never be used–I can’t imagine any regular user bothering to search for the checkbox to enable it. QS doesn’t improve startup time on OS X or on Linux.
  • Hardware acceleration pipelines for graphics are only addressing Direct3D 9. There is already an OpenGL pipeline, but it’s not enabled by default due to instability on a subset of graphics cards. Thus we aren’t seeing this in *nix deployments or on the Mac. Again, a Windows-only improvement.
  • There is simply nothing in this related to OS X, period. Apple seems to be in full control of Java on OS X, and who knows what they will do with it in the future, if anything. Open source efforts like SoyLatte could, in the long run, have some impact, but I’m not holding my breath; it seems at best a solution for developers using OS X who need the latest and greatest. As a side note, I do have to say that the Swing (or rather, the graphics) stack on OS X appears to be the best implementation I’ve seen so far–if you have OS X available, just try downloading IntelliJ IDEA for an evaluation to get an idea of how good a Swing-based application can be.

Mind you, I don’t think this is all bad. Sun is building on the stack they’ve already invested in, and they are looking to make the biggest splash on the most widely-deployed desktop operating system out there, which is Windows, and the most widely deployed browser, namely IE7. The story on the Mac remains a complete mystery–Apple continues to refuse to release any kind of roadmap–and outside of some large-scale deployments we hear about in the press, desktop Linux is just not that widely used at this point (compared to existing and likely Windows installations, its market is miniscule).

So I think we should see Sun’s efforts on desktop/client/RIA Java to be their effort to make lemonade from the lemons the market, and fate, have handed them. The upside is that their technology portfolio in this area actually contains work that many people, even competitors, respect. And as an incremental investment–building on what they’ve already done–it seems like a good play business-wise. For people already using the Java platform, I think it’s arguably an interesting move to watch.

Posted in Uncategorized | Tagged , , , | Comments Off

Scala plugins for NetBeans, IntelliJ; status and notes

I just noticed on the netbeans-dev mailing list that Caoyuan Deng’s plugin support for Scala in NetBeans has been granted one of the “innovator grants”. This is good news! You can already download (very) early versions of the plugin, and there is a mailing list to provide feedback. A proposal describing the intentions for the plugin is also available. The grant challenge ends in August.

Also, I’ve been checking up on the public code repository for the IntelliJ Scala plugin and there is continued work there as well–although last I heard, the team isn’t promising anything just yet (e.g. it’s a matter of resources). It appears to target the next release, IntelliJ IDEA 8, instead of the current one.

Posted in scala | Tagged | Comments Off

Scala Presentations and Interviews

Here’s a collection of some presentations & interviews on the Scala programming language I’ve come across in the last few months.

The great Parleys.com just posted Martin Odersky’s presentation on Scala from JavaPolis 2007 (last December in Belgium). They had previously posted an interview with Martin (from the same conference) which is interesting, but I find the long presentation much more helpful in placing Scala in the context of programming language development, feature set, etc.

Software Engineering Radio, which produces podcasts (often interview-based), also had an interview with Martin from late 2007.

There’s an older presentation, again by Martin, as part of Google Tech Talk’s series, from November 2006. This one is hampered by the problems that most of the Google Tech Talks all seem to suffer from: poor video quality, almost illegible presentation text (e.g. slides, bullet points), sometimes poor sound quality. It’s a shame, since the folks at Google, apart from good cafeteria food, also seem fortunate in the many top technical people who visit them to give presentations.

Lex Spoon, who works on the Scala team at LAMP/EPFL and is one of the co-authors of the in-progress Programming in Scala book–which I highly recommend–gave a great talk on Scala which is posted at InfoQ.

Bill Venners, programmer, author and creator of the Artima web community, appears in a podcast on JavaWorld where he also covers Scala. Bill is also co-author of the upcoming Programming in Scala book, and is the author of the ScalaTest unit-testing framework for Scala.

Posted in scala | Tagged , , , | Comments Off

The Media Wall

Just saw this, a video/interview with Jeff Han, a researcher? student? at New York University. The company he co-founded for this is Perceptive Pixel, which has another video showing more of the same. He’s working with a large “media wall” (3ft x 8ft) on which you can manipulate images and other user interface elements with hands (both hands at once–multitouch). This seems even cooler than Microsoft’s surface, since I can imagine, if the cost ever comes down, that we could have these “walls” hanging around on our, err, walls, and just walk up and interact with them, rather than having to sit down with the thing. The amount of space available also seems cool–you can just push elements over to the side, walk from one area to another, etc.

I wonder what it would/will take to make this available to regular consumers, and also what sort of operating system and software support you need. If the market remains too small, we won’t see investment from software and hardware developers, putting the burden on the manufacturer–which not only limits the pace of innovation, but also restricts the amount of experimentation possible when the market is larger and the barrier to entry is lower, or the incentive to enter the market is greater.

What might be cool is to develop this as a “kit” technology which allows me to work against a normal wall, or maybe a whiteboard, so that I don’t need a dedicated TV/monitor. That might encourage more people to try it out and potentially expand the market somewhat.

Posted in Uncategorized | Tagged , , | Comments Off