Monthly Archives: February 2006

Another Amazing Xgl Demo

I hope the folks at freedesktop.org don’t mind all the traffic that davidr is causing, but anyone interested in the future of the Linux desktop have got to see this.

I have to admit that a lot of what he shows is eye candy, but to me the idea is to make the things on the desktop seem more real. This could ease the paradigm shift that happens between the real world and your computer screen, thus hopefully making people more productive. I’d have to try it out for real to be more sure and I can’t wait! I just hope I don’t need a Cray and a quad SLI to get the same effects shown in the demo :).

Demo video here.

So what is the CDT angle on all this? Well, one of the earliest uses we saw for the CDT was as a core development environment for Linux C/C++ apps. If something like Xgl can cause the demand for Linux to grow, we should see more Linux developers using the CDT, probably including former Windows developers who will be expecting a Visual Studio equivalent.

A Cool Eclipse CDT for Embedded Tutorial

I often hear the remark that the CDT isn’t good for embedded development. I always find that odd since the majority of the contributors and commercial consumers of the CDT are embedded tools vendors and the CDT actually sprouted out from one such tool. Mind you there are a few things that the commercial vendors add to make things like board bring up and target management easier but these aren’t huge additions.

But having been in the tools business for over a decade now, I find it much easier to sell such ideas if there is a grassroots movement that is driven by real users’ needs. That’s when I was thrilled when Wayne Beaton passed on a proposed Eclipse article based on a turorial on that very subject. The tutorial is written by James Lynch who has given me permission to pass it on to you. You can see the tutorial here. The objective of it is to show that you can do embedded development on an inexpensive environment for people who want to play and learn about the embedded world. Mission accomplied I’d say!

The tutorial walks the reader through how to set up their Eclipse environment and other tools including a special embedded version of the CDT that our friend Øyvind at Zylin Consulting has put together. He then shows how to code up an small image that strobes an LED on the board and how to build the image, download it using JTAG and debug it over a serial port. It’s a very cool illustration of our point that “Eclipse is not just for Java”.

Now, I’ll need to take a look at the changes that Øyvind has made in his version of the CDT and see why we couldn’t make them available in the base CDT. That would make it even easier for everyone who wants to try it out.

Xgl – Desktop Linux’s Savior?

I’ve followed the Linux on the Desktop thing for quite a while. At one point I had one of the distributions installed on my laptop and swore that there was nothing that I needed out of Windows that Linux didn’t provide for me. And for the most part that was true, except for my corporate e-mail client, which I ended up running in a vmware session.

I trotted along with that for a while, but after a couple of months, I went back to Windows in frustration. Despite the promise of Desktop Linux, it just felt sluggish and blurry when compared to my Windows boxen. When working with reams of code in Eclipse, the desktop experience is critical to my productivity. And unfortunately, I’m just more productive in Windows that I was in Linux, which is too bad since I really prefer Linux for software development. I just seems to give me more control over my execution environment.

And then one day a Mac G5 landed in my office. There wasn’t much installed on it so I didn’t have much use for it, but the desktop environment sure looked cool. After a little investigation I found out that at the base of it all was OpenGL. The promise of using OpenGL, or 3D acceleration in general, for desktop environments had really peaked my interest. With the pending arrival of Microsoft Vista, I think we’ll soon realize how clunky the ole’ 2D desktops really are.

So if Mac OS X can do a 3D desktop on a *nix base, why can’t Linux. That’s when a few google searches brought me to the Xgl project going on in and around X.org. Xgl is an implementation of an X server on OpenGL, assuming I understand the documentation correctly. The progress on Xgl has been slow and I kind of lost track of it’s progress until an article appeared on ZDNet the other day. I’m still not sure it’s moving at a pace where we’ll see it common place anytime soon, but with the backing of Novell, who hired the developer of Xgl, my hope has returned, at least a little bit.

I love Linux for software development and, if I had the right desktop experience and I had access to all the apps I needed to be super productive in my job, I’d switch again in an instant. Here’s hoping that the Linux community sees the potential of Xgl and works on finishing it and bringing it into my favorite Linux distribution sometime soon.

Update: Here’s the news release from Novell. Includes some cool movies showing off a demo of Xgl’s advanced capabilities.

SystemC – two worlds collide

I used to sit across the cubicle wall from an ASIC designer back in the mid 90’s. He was pretty friendly and was very interested in the future of software engineering, especially software modeling. I guess that makes sense since, as an ASIC designer, modeling hardware was second nature and he figured it should be the same for software.

That got me interested in what they were using to model hardware. He was using Verilog, one of the big two hardware description languages, VHDL being the other. I was starting to use ObjecTime, a graphical software modeling tool that I ended up helping build, and he found it very odd that we were moving into graphical modeling where the hardware guys were abandoning it for textual modeling.

Looking back now, I’m thinking he may have been on to something. I still think visual modeling has a long way to go before it becomes mainstream with every day developers, and even longer for modeling behavior. Maybe we’re suckers for punishment and prefer to deal with reams of text, or maybe the tools aren’t up to snuff yet for visual modeling (and I’m still holding out hope that GMF will get us much closer).

That’s when I ran across SystemC yesterday, I had a famous Ward Cunningham “a-ha moment”. Here’s a system description language that software guys would love. It uses the power of C++’s type system and a small run-time to model the concurrency and timing of real-world systems. What a great mix of the two worlds with hardware and software guys working on the same code. I am just starting to scratch the surface of the potential of SystemC, but it’s one of those technologies that I end up losing sleep over wondering about the possibilities. I’ll write more on it once I do a bit more research and I’d love to hear peoples’ opinions on it.

However, the important thing I am taking from SystemC has nothing to do with systems modeling. At the back of my mind is a new programming paradigm that was sparked when I first looked at UML action semantics. Hardware is inherently a huge collection of concurrent processes, which BTW is also a key feature that SystemC emulates. This concurrency is the reason why many algorithms are much faster to implement in hardware. Why can’t software be that way? And with the new revolution of multi-core processing, will our current von Neumann paradigm scale to hundreds of concurrent threads? Maybe there’s something we can take away from SystemC that we can use to build massively concurrent programs in C++. I sense another “a-ha moment” coming, or at least another few more late nights…