Well, maybe it could be easier than that. “Python For Informatics: Exploring Information” is (the starting point of a growing) text book aiming at enabling people to use the Python programming language (known best for being concise, very readable, easy to get started with and, overally, being modestly friendly to starters while, at the same time, allowing one to do all eventually to be done with a programming language these days) for exploring data, learning to solve tasks “programmatically” by writing Python scripts, making use of the many smaller and bigger features this language offers. The book, written by Charles Severance, published under a Creative-Commons license and building upon the foundations of the likewise readable “Think Python: How to think like a computer scientist” offers a straightforward, concise introduction to doing basic things with Python as well as understanding a bunch of basic concepts of computer programming in general and also provides a little more material (audio recordings, slides, …) to make things more accessible to you.

Well… though I still mainly use Java for my everyday productive work, I then and now have been sort of “in admiration” of Python because of its elegance and accessibility and because of, at times, just seeming “a good language to get a job done”. Right now, also looking at the Opportunistic Developer Week held by Ubuntu GNU/Linux community at the moment, and also making heavy use of Python (and the quickly development framework), I see an interesting tendency (or, well, let’s better call it an “option”…) for the future of computing: Make end users more “productive” again. Make creating smaller (and maybe, as well, bigger?) programs as easy/difficult as using a spreadsheet and a word processor, and allow people for quickly sharing and, in a community, growing small, custom projects into larger ones eventually addressing the needs of more than just one user. This really could push forth a whole new culture of contribution and collaboration to open source or software libre which by now, all too often, just seems limited to downloading and installing stuff. And, eventually, it ultimately could end in the set of tools available being broader than ever. Not all too bad, isn’t it? :)

Anyway: One of many fields in which NetBeans these days still does excel compared to Eclipse is building graphical user interfaces using the GUI builder that comes pre-installed with every NetBeans package and even from this point of view is way ahead of the Visual Editor available to Eclipse users, in case of which even installing and getting the bits to work seems an adventure of its own. And here, we’re not even talking about RAP (based upon RWT) which is the “web alternative” and, though pretty complete (and getting better with each release), always lagging a bit behind the “desktop RCP” (based upon SWT) in terms of technology, widgets, … . However, Eclipse then again is a bit ahead from our current projects point of view: The “single sourcing” approach the RAP people are trying to push forth – the idea of having one codebase and run this both “on desktop” and “in a web browser” without too much ado – is really a good approach, well, if you need to cater for both web users who still want a good feature set and to internal users to which using a browser based interface eventually is not an option. Yes, there are quite some drawbacks about the way the Eclipse runtime environment does work and scale when deployed to an application server (in example talking about one dedicated “UIThread” per user session which definitely is not the way people think of doing server-sided Java applications… :) ), but overally, it’s more than so far you can do with Netbeans unfortunately, where you’re left with either doing a desktop (Swing based) application or a web application using some framework for this purpose (JSF, Wicket, …). Works, but one of the ideas you want to address when considering single-sourcing (having programming models as well as user interfaces as close to each other as somewhat possible for web and desktop) falls short here. There have been numerous projects trying to make Swing a web application platform too, but most of them seem discontinued, and none of them integrate well with the tooling one is used to (and enthusiastic about :) ) in NetBeans.

And, talking about e4, the next major version of Eclipse IDE/platform, the current status quo might become even more apparent: e4 comes with XWT, a technology to allow for declarative UI description using XML file definitions rather than writing code, allowing for, well, “declaration” rather than coding of user interfaces, which has a bunch of more or less obvious advantages. Not that this idea is generally all new (just consider XUL used by the Mozilla applications), but along with the “usual tooling” to be found in an IDE like Eclipse, this might turn out to be a rather impressive feature. First demonstrations, like this screencast showing the visual editor for XWT, leave one end up with expectations rather high. So let’s wait and see…

… both what Eclipse people will keep on doing related to XWT until e4 is to be released, and what Oracle is likely to do to Java technologies like Swing or maybe JavaFX. Maybe the latter one might be an interesting alternative if integrated with web and desktop environments and the appropriate tooling. I am curious to see things proceed, talking about both technologies…

Some say the only way of telling whether you understood some aspect of theory is whether or not you’re capable of easily explaining it to someone else. If that’s true, Toby Segaran, the author of this book, for sure has a pretty clear idea what he’s talking / writing about: Throughout the chapters, he manages to explain algorithms and concepts in an astoundingly short, concise and yet coherent way, laying out essential things in a few lines of text, a small set of images and sample code, providing you with all you need to get you going. So if you’re out to learn a thing or two about “programming collective intelligence”, about clustering, seeking, ranking, machine learning and a whole load of other interesting things, this book is generally an excellent starting point. Same applies if you like to do learning following a straightforwards “hands-on”, providing you with working examples and fundamental information to build upon whenever you feel the need to go more into detail here and there.

But there’s more. Asides being a good introduction to a specialized field of algorithms and approaches, as a “side effect” you also dive into doing a lot of things using the Python programming language, including fetching and parsing RSS feeds, automatically processing HTML files, generating visual output using Python Imaging, … . Along the way, you learn how to do file i/o, you get quite some exercise in using list comprehension and in working with matrix representations, and, which in my opinion seems one of the best effects to have: You get confronted with writing re-usable algorithms and data structures, either by writing exchangeable functions doing “the same in a different way” on a given data set, or by transforming input data of whichever kind into a given data structures to re-use functions defined to work with these data structures before.

All these things, as said, same as the actual explanations on the books core subject, come as concise, very “hands-on” explanations, ready and there to get your feet wet quickly, to try out, to build upon, to include whatever you learnt into your own applications. It’s a book making one curious to play with the example code, to figure out how to solve different problems with the approaches learnt here, it’s a book which, while reading, made me more than once immediately think of at least a handful of things to be done with the examples in there. There’s always more detail information if more knowledge is needed on the aspects and topics outlined there, but as a brief, usable introduction, it can’t be done better in my opinion.

• System integration using open standards, web services and SOAP? Oh please, we don’t even support generation of valid XML (based upon some schema or DTD) right now.
• Quick scripting integration of backend services using JSON and REST? Not out of the box, you have to do that manually, and you can’t do it bidirectionally as our current HTTP client implementation doesn’t support anything else but GET.
• Usable, AJAX enriched web client? No. Our web client architecture relies upon a whole block of code containing hundreds of lines of inline HTML/CSS/JavaScript, and we don’t intend to change that.
• CORBA integration as a technology at least somewhat open? Oh no. We do have rudimentary CORBA support, but just for our very own internal purposes, unsupported, untested and unmaintained outside our own use cases.
• Asynchronous communication, ESB or business orchestration even? Well no, by now you should have learned that our system doesn’t need an outside world to exist.
• Mashups, Web 2.0, portal integration, widgets, all these technologies which aren’t really useful in itself but maybe a good thing to provide end users with some eye candy? No. Not now, not tomorrow, probably never.

Being in kind of a rant mode, I could continue this list forever, but it is of no real help. What’s the bottom line? Well, despite my personal (political) attitudes, I have become a little more pragmatic the last couple of years as far as it concerns the use of “open source” software or even “software libre” in a business context, as I have figured out that, though I think it’s generally an important matter from a long term point of view, there are more important short term aspects to deal with: Open standards. Open connectivity. The ability to integrate applications, to make them seamlessly go together without too much ado. Ask your vendors to support open, industry-adopted interfaces and agreed-upon communication standards, and don’t accept “data” or “logic silos” to lock up part of your business data / functionality. Show your vendors that this matters to you, and support those who make a change here, no matter whether open source or not. It’ll make things more difficult during project startup, especially as it will be more expensive and provide value you can’t immediately “see”, but as soon as you will need it, you know why you did it initially… or, maybe worse: You know why you should have cared, initially.

• Generally, of course, I am happy to see tools that matter to me (Glassfish, NetBeans, OpenOffice, VirtualBox) seem to have quite a good perspective being under the hood of Oracle. Surely, time will tell and we will overally have to see how much of this commitment still will hold true one year from now, but at least it’s good not to see these projects / communities axed immediately. So far, the only thing that really seems to go away is kenai.com, at least as a public service.
• Reading this page, I have good hopes that the current ecosystem of user groups related to Java and OpenSolaris will continue to exist and be supported in its current form. Again, I guess, it’s wait-and-see how these things will be like, in near future, but at least it’s a pretty good start.

So, finally (and I guess this is my last post on Sun and Oracle): I like the overall product and platform strategy Oracle seems to adhere to (even though, as pointed out before, somehow I wished Sun came up with the same idea earlier). Maybe, by now, it’s up to the communities (NetBeans, Glassfish, …) to embrace the new situation and keep their projects up and alive the same way they would do being “under the Sun hood”. Let’s see where to get, this way. :)

At the moment, however, I don’t want to re-evaluate the various aspects of the Sun/Oracle merger again as this has been done extensively all over the ‘net before. I just, given the day, want to add two personal thoughts to that…

Changing times

At first, and maybe foremost, of course, it feels kind of sad seeing Sun as an independent company (brand?) cease to exist. I merrily admit I have been a fan of Sun technologies ever since I first got in touch with some Sun-4 workstations in my early days at the university. Looking back, a couple of things started for me this way: I first got in touch with “the internet”, I learnt to enjoy the benefits of Unix operating systems (yes, I mean it), I learnt a lot of interesting and valuable things of which some by now still help me earning my day-to-day life. Some years later, this extended as I jumped head-first into Java and Java EE, which somehow keeps me driving to date both professionally and personally (saying that I earn my money using this kind of technology as well as that it feeds my personal interest for frameworks, software development, architecture and so forth). To me, from some point of view, Sun always were kind of akin to a “student company”, a company running very closely tied to research and development, to university life (maybe no surprise considering where the name “Sun” originated, as well as where Suns founders initially came from). On the other side, I always percieved Oracle as a “business”, an enterprise company, so maybe Sun being bought by Oracle feels kind of the “student approach” finally being embraced by the business. This can be good for both, of course, but of course there’s a moment of quiet melancholy about that. ;)

Options missed

Another thing, however, maybe is less personal (yet still not a neutral point of view) but more technical: The very first thing to happen when Oracle announced the Sun acquisition was the statement that this transaction would enable Oracle to provide “application-to-disk” solutions, including the full range of technology (servers/storage on the “bare metal” front, the Solaris operating system on top of this, the Oracle database on top of this as well as the Oracle Application Server logic, …). Though this is thoroughly sane, I wonder why on earth Sun didn’t come up with something like this, themselves? I mean, after all, they had at hand all technology needed to really build an all-inclusive platform. Just imagine something like this:

• Sun servers and storage systems to be the “hardware foundation” of the backend, Sun workstations, on the opposite, forming the frontend / client hardware. And there always might be thin clients (Sun Ray?) for more lightweight clients, of course.
• All hosts run the Solaris operating system, of course.
• In the backend, there is mySQL (maybe clustered, as an enterprise setup) as well as a fully-blown Glassfish Enterprise Application Server stack (including OpenESB, OpenDS, …) as the application deployment and runtime platform. A headles OpenOffice / StarOffice installment serves as the toolkit for server-sided document and report generation and transformation.
• ZFS is used to serve large capacities of disk storage to the clients as well as recieving backups of client data using ZFS snapshots as all hosts run this kind of storage technology.
• For web users, the application server runs a portlet container exposing web client components to access the backend services. JavaFX clients might serve those who want more “rich client” feeling in this environment.
• The clients run a Java virtual machine and a NetBeans platform environment tailored especially towards taking application modules being “clients” connecting to the backend servers. OpenOffice, on the clients, is integrated as well as seamlessly working inside the NetBeans RCP applications and used for building templates deployed to the server-sided headless OpenOffice for automated / batch document generation.
• For development purposes, there are specialized workstations coming with a pre-built “small” copy of the large environment (mySQL, Glassfish, …) as well as a fully-blown NetBeans IDE specialized (and maybe extended?) to building client applications both on top of NetBeans RCP (for internal / desktop clients) and on top of portlet technology (for web clients). Connection to the backend might be done either using SOAP/REST or something like CORBA/RMI/EJB-Remoting, it wouldn’t really matter – developers could do “rapid distributed application development” in a well-integrated, homogenous environment. The included OpenOffice link would allow for also integrating the full range of office functionality and automation. There also could be a VirtualBox environment for various testing purposes, as well as (of course) powerful and transparent mechanisms of deploying application components in different versions to the whole network.

Oh well… Seems an interesting vision… in reality, and this is what sometimes makes me sad about this, it seemed that Sun, over quite a bunch of years, just “extended” their portfolio of technology without actually embracing, without really embedding the various products and projects, without making a “working whole” out of it. Plus, it seems Sun marketing for one projects sometimes used to shot the foot of marketing done for other projects, especially related to the Solaris operating system: Java applications looked pretty “good” on most platforms rather quickly (especially of course Windows, followed by GNU/Linux with the advent of the GTK Look And Feel). The platform Java / Swing applications used to look clumsy and ugly for the longest period of time, unfortunately, happens to be Solaris (which, same as Java, is a Sun technology). Same goes for JavaFX: While Sun / OpenSolaris evangelists do a rather good job at promoting OpenSolaris as the developer operating system of choice (which I hardly doubt it is, at the very least given dtrace), others promote JavaFX as “the” kind of the shiny, all new technology for building rich client applications for the web. Following this route, you don’t really have to ask which operating system was not supported out of the box with the initial JavaFX release. It’s things like that which surely make me hope that Oracle can do better here… and still preserve life, growth, development in all the communities and ecosystems that used to grow around many of the Sun technologies, that make most of them extremely valuable and useful. So… good luck to all, both the Sun employees (who seem to be in for some fundamental change right now) and to the Oracle people (who are facing the challenge of building a working “whole” out of the two companies and technology stacks).