Android SDK goes beta

Well, if you follow the embedded industry even from a distance, the news that the Android SDK has gone beta is old news by now. I've been so busy p2-izing our upcoming Wind River products that I haven't had time to write here. Time to get my priorities straight :).

Any whoo, there's a lot of competition all of a sudden for mind share in the mobile Linux game. Android has been pretty quiet lately but they've clearly been busy beavers and a real Android-based device seems imminent, so it's time to take them seriously.

The only thing I'm really waiting for from them, however, is open sourcing of their Dalvik VM technology (can't call it Java since it's not Java, but it's Java...). For Java to truly take off in the embedded space, we need a good VM that works in resource constrained environments and runs well on relatively slow processors. Oh, yeah, and it has to be freely available for the kids to play with it. It's there in the Android SDK, but it would be cool to have the source to see how hard it would be to port to other mobile Linux platforms.

Because there are other players in this game and they actually seem to be ahead at this point. OpenMoko has already shipped a new version of their Neo FreeRunner phone. LiMo has a healthy stable of partners with a number of them already shipping devices as well.

So is there room for all of them? No. There is not. As Donald Smith conjectured recently, mobile is becoming more about the software stack than the hardware. Luckily we have more hardware than stacks at the moment, but not by much. We need to see some consolidation here soon so that application developers can start building those killer apps without having to port them to umpteen different environments.

BTW, Equinox running on Dalvik would be very cool. I'm guessing it's not easy. But is this in the works by anyone?

Eye Candy on the Linux Desktop

My crusade for a better Linux desktop continues. After reading a recent rant from someone at the Inq and recent predictions on what Linux will look like in 4 years time, I thought I'd give another shot at improving my Linux desktop. I've been using it heavily from the command line for manufacturing media for upcoming Wind River product using our Eclipse p2 based installer/generator and for mucking around with ClearCase. I can do all that from putty on my Windows machine. But it would be easier if I could just do it and everything else I need to do right on the Linux desktop.

What I was really after was the 3D effects offered by the Compiz Fusion compositing window manager for my GNOME desktop. After a recent bad experience installing a security upgrade for Fedora 9 which totally killed my machine (no boot up for you), I'm back on Ubuntu 8.04. But, alas, I had to install the proprietary drivers for my ATI video card before I could turn on the effects, which is another can of worms I'll leave for now. But once I did, I was up and flying with some wobbly windows and spinning cubes and windows flying all over the place.

I haven't used Mac OS X or Vista seriously, but I can't imagine any eye candy they would have that Compiz doesn't have. So in that sense, I get the feeling that Linux is making huge strides forward. I still haven't figured out how to get fonts as crisp as I get on Windows but I imagine it could be done. It does indeed appear we're not that far away from a champion desktop for Linux (sorry, watching too much Olympics and I'm finding too many parallels between Linux desktop and the ability for Canadian athletes to win medals, 4th place is great, but...).

But I really liked what the guy said in the article about Linux in 2012. He predicts we will get there, but that it's going to take "for pay" distributions of Linux to take us there. Free software isn't going to do it. And there's good reason. Windows and Mac look so good because of the proprietary software that makes it happen. If we want that on Linux, we're going to have to pay for it, just like we do for Windows and Mac OS X.

We're going to have to pay for the licences to the software that legally plays MP3s and shows DVDs and cleans up my fonts and for someone to make it all work on our laptops without having to edit anything in /etc. That's just the economic reality of it. And I for one have no problem with that. Because I believe you get what you pay for. Free software is great for commodity software like kernels and windowing systems and IDEs written in Java ;) where there's lots of people to help build them. But it takes rare skill to make a great desktop environment. And the guys with those skills hold the cards and probably want to profit from their fortune. To get a great desktop on top of that great OS, it's worth it.

How many threads? No way!

Well, I thought I was being sneaky when I googled for the Intel Larrabee paper that is being presented tomorrow at SIGGRAPH and thought you had to be an ACM member to get a copy but then found it on the Intel site. Everyone else seems to have found it too. To save you the hastle, here it is. I found the link today on Wikipedia so apparently it's no longer secret.

Anyway, I'm more curious about it than anything. And I guess the biggest question I had was how many cores the thing is supposed to have. This will help me measure how pressing the need is to figure out how to program many threaded applications without Joe programmer's head exploding.

Well there's no actual product announcement in the paper, which I guess is the right thing since it's a conference paper aimed at getting graphics programmers interested in their architecture. But the performance charts give a hint. They show the number of cores needed to make some of the popular recent games hit 60 frames per second where you generally need between 24 and 32 cores. They then show some charts showing scalability up to 64 cores. Given that, I think it's safe to say we'll see 24-32 core Larrabees in the not too distant future and grow from there.

But wait, there's more. Each core has 4 threads of execution to help ensure that the cores are kept busy while waiting for cache and memory and I/O and stuff. That gives you up 256 concurrent threads in the 64-core monster and 128 in the regular 32-core machine. That's a lot of threads. And, yes, it'll be hard to write applications that can get the maximum performance from these.

One other thing I found interesting is that their performance tests were done with the cores running at 1 GHz. That's pretty slow by modern standards. And it explains why they are focusing on graphics co-processor applications where programmers are already trying to figure out how to make things more parallel. If you don't, you're single threaded application running at 1 GHz will be pretty slow (trust me, I have a 667 MHz Pentium III at home, brutal). So until multi-threaded programming becomes more mainstream, don't expect to see one of these things running your Office suite or Eclipse - even though it could.

Carmack the Magnificent

(BTW, the title of this blog entry is a spin on one of my favorite TV personalities from many years ago, Johnny Carson)

I just finished reading an interview Tom's Games did with John Carmack, the mastermind behind id Software. I love hearing from him. He's very respected in the gaming industry, is a really smart guy, is totally a geek, but has a good eye on the industry. You learn a lot about where gaming is going technology-wise and business-wise by listening to him.

A couple of things he mentioned interested me. He did bring up multi-core computing and how gaming programmers are still trying to figure out how to take advantage of all those extra concurrent threads. As with everything, it's going to really change the way programmers think. In what I'm sure was a Freudian slip by the writer, he used the word "paralyze" instead of "parallelize". I think that's exactly what's happening. Programmers are paralyzed as they try to figure out what to do. It goes against everything they've been trained.

On the good news front, though, I've been playing a little with the dataflow programming paradigm and I'm liking the way it makes me think. Essentially you have huge number of processes that have data streams between them. You're program becomes a network of co-operating virtual machines. Makes sense to me but it needs to be tried out on a real application. And I think gaming is that perfect application.

As a side note, John also talks about the iPhone and how it can be a great gaming platform. His wife says it's a terrible phone, which I'm sure it is, but using these things as phones is becoming secondary to the other applications that can run on them. I'm pretty sure that's where the future of mobile devices is headed. Forget the phone, they're just great little network appliances.

How's build working for you?

It's been a crazy couple of months for me. The list of things I need to do has been badly encroaching on my time for Eclipse community work. But it's all been good and we're working on some really cool stuff with p2 internally here at Wind River which should turn into community work as well anyway.

But it's getting time to start my work on e4 and the Eclipse resource model. We've talked a lot in the past about the need for flexibility there and to support other resource models that don't necessarily map to the underlying file system. Even in the last few days we've received inquiries on the cdt-dev list about supporting Visual Studio-style projects in this manner (from a guy with an e-mail address of nvidia.com - quite interesting). So this is what we've meant by flexible resources and what we plan on addressing.

The question I'm starting to ask myself is whether we should be looking at the build side of the resource model as well. If you come from the Makefile centric view of the world, the Eclipse build system is very bizarre indeed. I'm not sure of the history of how it got to be that way, but it was our first real interaction with the Eclipse Platform team, to somehow get Eclipse to build CDT projects correctly. There's still a lot of magic there that probably could be simplified if we made the build model more flexible as well.

Also we have a hell of a time co-ordinating loading the CDT build model data from our magic .cproject file at the right time and in a scalable and non-deadlockable way. Sometimes I just wish that the .project file and the code that manages it was more flexible as well so I can have our build data loaded at the same time the rest of the project information is loaded. (Yes you can do a little of that now but not easily with the complex data we have for our build configurations, tool chains, option settings, etc).

Anyway, I don't know how many people are building IncrementalProjectBuilders out there (and, yes, the weirdness does start there). But I was wondering if other plug-in developers are also facing issues like this.

Going with the data-flow

I've just been reading articles in Wikipedia on dataflow programming. This programming paradigm captures what I think is the greatest need we face to built the multi-threaded applications of the future. It also explains where a lot of the concepts in UML Actions and Activities come from.

From what I understand most of the dataflow languages are visual languages. The SynthMaker tool that came with my Fruity Loops is like that. The page also lists the hardware description languages, Verilog and VHDL, in this category. I think they've left out SystemC since it fits into that mould as well.

But even if dataflow programming is the big new paradigm, I firmly believe that any new paradigm will only be mainstream if it's familiar to developers. There's been some great programming languages over the years that you would swear are much better than C (Ada comes to mind, Pascal was really good too), but if you look at the most popular languages in use today, C-like languages, and C++, Java, and C# in particular, win by a land slide.

So it comes back to what I was mentioning earlier. SystemC is a great example of a C++ library and run-time that implement a different programming paradigm but let you reuse all the skills you've learned with other C++ applications. And, it's an example of a language that supports dataflow programming which we need for massively multiprocessing applications. It's definitely a source of inspiration.

Who's leading anyway?

The LinuxHater linked off to Christopher Blizzard's (from OLPC fame and now at Mozilla) blog on the current state of affairs with the GNOME project. He gives some very eye opening insight into what's happening there and the potential future directions for GNOME, GTK, and friends. It's not pretty, literally.

GNOME is getting big in the mobile space, or at least the number of contributors from that space is starting to dominate the GNOME project. And as we all know in the open source world, the contributors are the leaders and get to make the decisions. What this likely means and what blizzard is afraid of is that the GNOME desktop is not going to get the attention it needs to compete with the modern interfaces it competes with. The commercial interest just isn't there to make it happen like it is with GNOME mobile.

He explicitly spells out Qt and Apple as leaders in making good user experiences and developer friendly APIs. My favorite quote of his: "If in a platform-driven market and a platform-driven world you’re not the #1 or #2 player it’s going to be very difficult to make a dent in the market. (This is especially true if Nokia decides to fix the Qt licensing.)" I agree on both fronts. I can't see how GNOME is going to grow without serious innovation. And I hope that Nokia fixes the Qt licensing (wink, wink, nudge, nudge).

Being CDTDoug and focused on embedded and mobile at Wind River and on the success of CDT for Windows development with Wascana, why do I care so much about the Linux desktop? Well I think it's the missing piece in the open source success story. We have Linux as an overwhelming favorite in the server market and it's growing in great strides in the embedded space. But without success on the desktop, my Mom isn't going to care. Which means Microsoft and Apple and closed source technologies as still seen as the right path to innovation by the general public. And until "I am a Mac" dukes it out with "I am a Linux PC", there will always be doubts on whether open source can compete with the big boys.

LinuxHater, a touch of tough love

From now on, I defer all my opinions on the quality of the Linux desktop and the open source projects that work on it to this guy, the LinuxHater. I started reading this blog after I ran across this article on the 'Z' via the 'dot' written by a guy from Google. It really hits home what both of them have to say.

The hater shares some really honest opinions using some very colorful language (warning - if you're sensitive to that kind of thing) on everything from how hard it is for his grandmother to get into Linux, to how all the forking and duplication that's going on FOSS community is doing some serious harm to our ability to build up the Linux desktop to compete with Mac and Windows. It's a really funny read. And I have to agree with the Google guy. Given how much the hater knows about what he's writing about, he's really a Linux lover who desperately wants Linux to succeed but is loosing his cool in frustration.

And it's hard to argue with what the guy says. Open source is about freedom, freedom of the developer to build whatever he wants, however he wants it. And if he doesn't like working on a project, he can start his own, and even fork the code. What he can't do, however, is fork the developers. And that's what's killing the Linux desktop. Too much duplication is watering everything down. Everyone's so focused on building the best framework, they're forgetting about the average end user who doesn't care, or have the capacity to care, and just wants something that's easy to use and works.

With Eclipse, we're making conscious efforts to avoid this problem. At almost every project creation review someone asks whether the project is duplicating some other project and, if so, we work hard to get everyone to work together to resolve it. I think it helps that Eclipse is very much commercially driven. We understand the economics of open source development. We have very limited resources to invest, and it's so critical to work as a team with other companies, even if we compete in the marketplace. If we can get over that, why can't Linux desktop projects, who don't even have a financial vested interest in succeeding, do the same?

But there's a lot of politics in open source, especially with projects close to the Free Software Foundation. I'm not sure how we get out of it. Hopefully, those involved can see through the sarcasm and listen to the message. Linux rocks as an operating system, it really needs a desktop to match, and the community needs to unite to provide the sufficient resources to build it.

Important safety tip

So when you go to redefine the key sequence in Eclipse to do 'Build All' make sure you're hitting the Ctrl key and not the Shift key. It explained why I couldn't define the CXXFLAGS macro in my Makefile. Instead of Ctrl-X Ctrl-M for build all, I had accidentally defined it as Shift-X Shift-M. Weird (that it let me), Cool (that I could do it), but took me a little while to figure out that's what it was and not something wrong with my keyboard when Shift-X didn't do anything :)

BTW, thanks out to the guys who are contributing to the Emacs key bindings. I'm loving it! All I need to add is this Build key sequence, which Emacs doesn't define either anyway.

Now where's that include file?

Yeah, C++ refactoring is our biggest achievement for CDT 5.0. But here's one I found probably more useful in my day to day use of the CDT (which is getting more and more lately which is awesome).

I have a burning need to learn GTK development. I have a little dialog based app that needs to run on Windows, Linux, and Solaris. I have the Windows version done using MinGW's support for win32 programming (now there is an experience for you). Now I need to implement the same thing in GTK for Linux and Solaris.

So I'm going through the GTK 2.0 tutorial on the GTK web site and the first thing it get's me to type in is:

#include <gtk/gtk.h>

The first thing the CDT does is throw up a warning marker on the line complaining that the CDT indexer couldn't find that include file. Being suspicious, I did a build and sure enough the header file wasn't found. With all the great work the indexer team is doing I really should trust what it's telling me.

So I fired up the Ubuntu package manager and found out that the GTK devel package is indeed installed. What's up?

Then I remembered one of the new CDT features I stumbled across in my 5.0 testing that we really should tell people about more. I went back to the #include statement and after <gtk, I pressed Alt-/ (I use the emacs key bindings, Ctrl-Space for the rest of you). And sure enough, content assist offered me all the include files and dirs that being with 'gtk', including the one I needed, gtk-2.0.

It's just a little thing, but one of the great examples of the information that the CDT can gather for you to help improve your productivity. And it's time to tell people about it...

A tribute to ObjecTime

As I mentioned recently, I've been thinking of how you could program UML-like actions using C++ in a manner similar to SystemC. As I worked through the workflows of how actions could receive data and signals on input pins and send stuff on output pins, and how they all hook up together, I started to get a deja-vu feeling.

It brought back a lot of good memories from my years at ObjecTime. You know, we had a lot of this stuff back in the 90's. Mind you, it was almost totally focused on state machines that communicated with eachother using messages, but it had a lot of the multi-threading, action oriented development that we need for multi-core systems.

It was a fun time back then. We were a company of 150 or so working on something we were all very passionate about. It was one hell of a team. And we had some big customers but not many of them. When Rational bought us we saw it as a good thing that would lead our work to greater exposure and a bigger sales force. It didn't pan out that way, but the team lived on and a lot of them are still working on modeling tools for Rational which is now a division of IBM.

But one area where I think we failed was in adoptability. We had some passionate early adopters as customers but there are only so many of those. You certainly don't want to build a business with only that. And it was hard to get the code centric guy to trust the modeling and code generation tools. Let's face it, when it comes to crunch time, you'd rather be in with the code with age old and trusted tools and the modeling tools easily fall by the wayside.

Anyway, that's why I work on the CDT now. Code rules, at least for now. But as we try to introduce complex programming paradigms to facilitate multi-threaded development, I got to wonder if there isn't another ObjecTime out there. We where years ahead of the industry and we knew it. I had feared that the time would never come, but maybe that's not true after all.

The word with Mark Shuttleworth

I ran across (with the help of slashdot :) this interview with Mr. Ubuntu, Mark Shuttleworth, and found it very interesting. It's a good insight into how a commercial entity is successfully, or hopefully successful, working with the open source community to make things better. I've complained a lot here about the Linux desktop experience and Mark feels the pain and is trying to do something about it.

A couple of interesting points he brings up. One is on the Gnome/GTK versus KDE/Qt battle that's been going on for years, and for years too long IMHO. And he mentions the point that I think is really underlying the issue and that's licensing. GTK is popular because it's LGPL which allows for software using it to pick their own license. Qt is technically and aesthetically better, but sorry, unless it's commercially friendly in a free form, it's going to lose the battle. And apparently it is losing from what is stated in the article.

And as long as the battle continues and the Linux community spend their limited resources on two desktops, the Linux desktop user community is going to pay the price. Mark discusses why he sees Mac OS X as the biggest winner lately in the desktop wars. It's because of Apple's dedication to providing an innovative user experience. That's going to be hard to achieve with Linux without the community rallying behind fixing it, or a major vendor stepping up and investing in it. It sounds like that's what Mark is going to do with Canonical, but they aren't really a major vendor with big pocket books, at least not at this point.

Anyway, an insightful read. A lot of the discussion should be familiar with the Eclipse contributor community. Working and influencing open source is a difficult task and requires some specialized talents. And apparently that bodes well for those that figure it out.

A lesson on SystemC

Here's a quick look at an example of SystemC code, you're traditional NAND gate:

SC_MODULE(my_nand) {
  sc_in<bool> a, b;
  sc_out<bool> f;

  void run() {
    f = !(a && b);
  }

  SC_CTOR(my_nand) {
    SC_METHOD(run);
    sensitive << a << b;
  }
};

It looks like some of hardware description languages I've seen such as Verilog. It lets you model inputs and outputs and a process here named run that takes the inputs a and b and does a nand to produce the output f. And it's all continuous. The module will change the output value as the input values change.

The crazy thing is that this is C++ code. SystemC is a collection of header files that define the templated classes, such as sc_in, and some macros, such as SC_MODULE, as well as a runtime library that models the continuous nature of electronic signals and calls the process methods, such as run in our example, to execute the behaviors at the right time. Very cool use of C++ IMHO.

Now UML Action Semantics isn't that much different than the behavior and structure modeled here. You have actions that have input pins and output pins and a behavior that runs when all the input pins are ready. All actions run in parallel. It's a discrete event system as opposed to continuous, as software tends to be as opposed to hardware. But I wonder whether we can use C++ in a similar way to program action semantics.

With a runtime that uses the underlying OS threading system supporting multi-core systems to run the actions in parallel as much as possible and the familiarity of C++ and existing C++ tools, like the CDT :), but used to program a paradigm very different than traditional sequential C, it has me intrigued...

All eyes on Larrabee

There's been a bit of talk on the web-o-sphere about a report out of the German tech magazine Hiese.de that claimed that the Larrabee multi-core processor that Intel was working on will contain 32 original (well, second generation, but still 20 years old) Pentium cores. In the end, it appears to be just speculation and Intel was quick to squash the rumors. But the logic behind the speculation seems plausible.

The old Pentiums where 3 million transistors and with the new GPUs coming out with over a billion, you pack a lot of cores onto one of those. And I like the concept. Something old is new again. Simplify and multiply. There are a lot of transistors in modern CPUs just to handle out of order execution and try to do as many things at once at the instruction level. But that's pretty complicated but made it simple for the programmer. We've gotten pretty good at doing the simple things, why not just take a step back and use what we know. But, of course, you still need to software to take advantage of it.

Reading the discussions really opened my eyes a bit more. This 32-core thing really is possible and will happen within the next year or so. Are we ready to build software applications that can do 32 things at once in an organized fashion. Thinking about it a bit over my holidays here, there is some existing technology we can use and it'll be pretty familiar. I'll blog more about it in a couple of days or so, but think C++, generics, SystemC, UML action semantics. Mix them all in a pot and I think we can come up with some "soup for the multicore programmer's soul"...

Are you ready for 1000 cores?

Massively parallel computing is something I've been interested in for a while and have blogged about a few times in the past. This blog entry by an Intel Researcher made me think about it again. He continues to proclaim that the future isn't that far away and we had better start designing our software so that it can run on machines with thousands of cores. He worries that we're aren't ready yet and we need to start getting ready. And he's right.

Being a tools guy, I think this is the next big paradigm that the tooling industry needs to address. Object-oriented programming and design was a godsend when machines started scaling up in the size of memory and storage and our programs began filling that with data. We built a lot of tools to help with that. Programming languages and compilers are obvious examples. But so is the JDT and CDT, with their code analysis to show type hierarchies and help you easily find classes. Not to mention all the object modeling tools for drawing pictures of your classes.

Coming up with the languages and compilers and other tools necessary to deal with thousands of concurrently running threads is our next great challenge. This is why I keep one eye on the Parallel Tools Project at Eclipse. They're already in this world dealing with the thousands of processors that run the super computers they work with. This effort is a research project in itself (quite literally if you notice who participates in this project :).

But as the Intel researcher warns, this stuff is going to hit the mainstream soon. We're starting to see that with OpenMP parallel language extensions supported in almost all recent compiler releases, including gcc. And I'm convinced it's an area where modeling can help since you really need to think of your program in multiple dimensions, which is something modeling is good at.

I think it's a matter of time before we're at the head of a new paradigm. I remember the fun we had when object-oriented programming hit the mainstream. I think this one will be just as fun.

Bye Bill. You will be missed

Reading the news I see that today was Bill Gates last day at Microsoft. Apparently, they held a tearful farewell in Redmond for him. And it really does mark a significant moment in the history of our industry and a time to reflect.

If I had a dime for every time I read someone say that Bill Gates crashed their machine or was someone personally affecting their life in some negative way, I'd be as rich as he is (well, maybe not). But as much as you may hate Microsoft and the methods they've used to drive their vision, you have to take a good look at what Bill Gates and company have done and how they've succeeded.

The biggest thing I learned from watching Microsoft is how important it is that you keep focus on software as a business. You may have the coolest widget or the cleanest framework or the fastest algorithm, but unless you have a business story and good business people around you to help sell it, it won't matter as much as it could.

And Bill Gates knew that. Surround yourself with good business people and you give yourself a chance. I've seen it too many times, great technology that has floundered because the team focused too much on the technology and forget to bring the marketing guys into the team, if they had marketing guys to begin with. And it's frustrating to see.

So on this day, even though I'm trying to build a C/C++ Development environment with the CDT that can beat Microsoft Visual Studio at it's own game, I pay tribute to Bill for all he's accomplished and all he's taught this industry. He doesn't hate you, he's just following his business plan.

CDT 5.0 for Ganymede, Come get Some

CDT 5.0 is out the door and available at your friendly Ganymede update site. I'm sure the Eclipse servers will be busy the next few days. The Eclipse community is vast and they love trying out the shiny new features that we've worked hard on all year to make.

I'm especially proud this year with CDT 5.0. With my new job at Wind River working on a p2 based installer, I've finally have a real reason to use it to write the JNI code that I need for some of the computation intensive parts of it. BTW, I now have proof that the Java version of an algorithm is much, much more compute intensive than a C version, check out the LZMA SDK from 7-Zip.

I'm really enjoying the experience. When I first imported the LZMA SDK into my C project, the first thing I needed to find out was where the main() function was. Let's try the Open Element dialog (Shift-Ctrl-T), typed in main, and there it was! A couple of Open Declarations (F3) later, and I was able to find the implementation of the decode function I needed to use. Awesome and I didn't even notice the Indexer running to find all this stuff. And everything else looked clean and worked well.

So yeah, the JDT guys are probably laughing since they've had all that stuff working well for a few years now. JDT has always been our bar (along with VisualStudio which I think we reached a while ago). But watch out. We may just make the CDT so good that people will wonder what the hype about Java was all about :)

:-O Nokia buys Symbian to EPL it

Wow. In case you missed it, Nokia bought up the rest of Symbian (it was already a major investor there) and have united with a number of Symbian stakeholders to form the Symbian Foundation to which Nokia will be contributing the Symbian OS. And from there, they will be working to provide an open source, EPL licensed, version of it.

Wow. We have CDT committers from both Nokia and Symbian and they are a great bunch. I still haven't figured out whether this is a good thing or not, but it certainly stirs up the pot as far as open source mobile platforms go. I think it also helps secure the future of the Symbian OS as a technology. It's hard to compete against the hype of Google Android and at the very least this will give Symbian some attention.

It'll also be interesting to see what kind of community evolves for it. They've certainly seeded it with companies that have a vested interest in Symbian's success. That'll give them a good start. As we all know in Eclipse-land, it's a lot of work to grow a community. But maybe growth isn't the prime objective here. We'll have to wait and see what the pundits say, but going open seems to be the most popular strategy these days to help ensure sure your platform matters. Mind you that may be the Google-envy speaking ;)

Back on Linux

I don't know why I get the urge to blog about my Linux journey. I'm sure it's not very interesting. But after a few days of working hard trying to set up ClearCase the way I want it so I can generate p2 repositories from our Wind River product release views, I've gotten back to why I was a *nix guy back in the day before Windows became a much better desktop.

I guess when you find a use for cpio, you are clearly destined to be a Linux junky. I've also fallen in love with NFS automounting (shh, don't tell my wife, she'll find that weird). When I can go 'cd /net/yow-dschaefe-linux' and get to my Linux box from anywhere on the WAN, that's pretty cool, not to mention handy. Doing a 'cpio > /net/yow-dschaefe-linux' from a ClearCase view on a Linux machine in California to my box in Ottawa and have fairly decent performance, that's the greatness of Linux file systems in a nutshell.

And using KVM to set up a virtual machine to run the version of ClearCase I need and from there to NFS mount a directory from my real hard drive and then to do a ClearCase view export back to my real machine so I can run the generator at full speed, it just rocks. It's not for the meek and it has taken me more time that I wanted to figure it all out, but Google is your friend and now that it's set up, I'm ready to go.

So, yes, I still think Windows is the better desktop, but for file and compute servers, Linux is clearly the champ. But of course, you all know that already :)

OSGi for native development?

I hinted at this topic in my last entry and when giving my crazy thought of the day last week. It's another Friday, but judging from the comments to those blogs and my gut, I'm convinced now that an OSGi implementation for native development isn't really that crazy.

Everyone has heard of the Microsoft Component Object Model (COM). Even if you don't chances are you've used it. It's now getting long in the tooth but it was a critical technology that led to the success of the Windows platform starting with Windows 95. It was a great way to build up frameworks with plug-ins and to write components that used the services of other components, e.g. a Visual Basic script that ran inside Excel.

But of course, COM is very specific to the Windows platform mainly because of it's reliance on the Windows registry which provided the directory to find the COM classes and objects you need. It also had some weird tricks with threading models and some wacky things called thunks to help to help performance when we were running Windows 95 on our old i486 machines.

But it's been done and there's lots of things we can learn from that, and from the limitations of some of the others, like CORBA. Using C++ as the core technology is one thing we would need to avoid. Different compilers have different ABIs, like how virtual function tables are laid out. As much as we try to evolve, at the end of the day, C is still the best language for interoperability and almost every language provides a way to call C functions.

There was some discussion in the OSGi community around something called Universal OSGi lead by Peter Kriens who is also involved in Eclipse. If anyone knows the status of that I'd be happy to take a look. It shouldn't be too difficult to start with the OSGi APIs that make sense and start implementing a framework to support it.