This afternoon I published a guest blog post on the Cloud Foundry website, promoting to use of Feedhenry's new integration with public Cloud Foundry. I re-produce a slightly edited version here. I'll follow up with more details of how to update the server-side of the app that has been created with the instructions below, using git commits.
Mobile application developers can now build and deploy applications on Cloud Foundry using the FeedHenry developer platform.
In the following blog we will demonstrate how to use the FeedHenry Command Line tool to clone a sample/template app, (from GitHub), stage the server-side code to CloudFoundry.com (Node.js and Redis), and build a HTML5 & JS app for an Android device. See http://mobilecf.feedhenry.com for detailed instructions. Also check out the FeedHenry App Studio to preview the app that you create here.
The FeedHenry CLI tool, fhc, uses node.js on your local machine. To setup node.js use the node installer located at http://nodejs.org/#download
Use the Node Package Manager (npm) to install or update the FeedHenry CLI tool (fhc).
$ sudo npm install –g fh-fhc
(the optional prefix “sudo” gives permission to install system-wide in a Unix style environment).
To test fhc is installed correctly and see the version you have installed, use:
$ fhc -v
fhc has some built-in documentation; use fhc help for general help, or fhc help [command] for help on a specific command.
To get started with the CLI tool you need to login to the FeedHenry platform using your CloudFoundry.com credentials. This will automatically create a FeedHenry account at mobilecf.feedhenry.com.
$ fhc target https://mobilecf.feedhenry.com
$ fhc login <your CloudFoundry.com email> <your CloudFoundry.com password>
In the next 3 simple steps, we will illustrate how to create a HTML5/JS app with an instant backend in cloudfoundry.com
To edit/modify the template app, login to github, and fork the app to your personal account.
Get the read-only git identifier for your cloned app.
Now create an app in the FeedHenry platform linked to your fork of the template app in github.
$ fhc apps create App-Anatomy git://github.com/<YOUR-ID>/App-Anatomy.git
If using a secured repository, please check out the documentation docs.feedhenry.com for generating and uploading public/private keys.
Staging to Cloud Foundry requires the use of the unique app identifier <APP-ID> that can be acquired by listing the active FeedHenry apps.
$ fhc apps
The staging can be done to the debug environment or the live environment. The former hosts the server-side for “debug” apps, and the latter for “release” apps. Separating these allows developers to exercise functionality separately in testing before deploying to production.
$ fhc stage <APP-ID> --devel
$ fhc stage <APP-ID> --live
To ensure that the app has indeed staged correctly use the Cloud Foundry CLI tool (vmc).
$ vmc target api.cloudfoundry.com
$ vmc login
$ vmc apps
$ vmc logs <my Cloud Foundry app-id>
We have just staged the cloud code from our forked app. Each app contains three directories: client, cloud, and shared. The client directory is for the client-side HTML5/JS app, the cloud directory is for the server-side Node.js code (this is what has been staged). The shared directory is in both. Check out the documentation for more information on using the shared directory.
To generate an Android debug build of the app:
$ fhc build app=<APP-ID> config=debug destination=android version=2.2 download=true
The appropriate files are gathered, bundled and dispatched to the FeedHenry build farm. The resulting binary file, for Android, an .apk file, is returned and can then be downloaded to your desktop. You can preview the app using the FeedHenry studio at mobilecf.feedhenry.com.
Load the app onto the phone by using email or Dropbox.
That’s it – you have built and staged an app in 3 easy steps.
Note: Editing the code in the git repository can make changes to the server-side and the client-side functionality. Those changes can be uploaded to FeedHenry via a git pull request. The updated server-side code can be re-staged, and the updated client-side code can be used to build a new version of the app. To find out more about this template app, App-Anatomy, see FH App-Anatomy in the References.
To get started go to http://mobilecf.feedhenry.com
Join the FeedHenry and the Cloud Foundry guys for a Cloud Foundry mobile meetup, March 25th, San Francisco.
Signup for Cloud Foundry today, and start building your own mobile app!
Facinating discussion of how important C++ still is. Wierd that I witnessed it all, from teaching myself OO and C++ on a 286 with Zortech C++ in the mid-to-late 1980s. I still have an original ECOOP conference poster (1988, Oslo, Norway).
This article argues that at best lip service, and at worst derision, is being paid to web apps and HTML5 apps, despite an underying beleif that HTML5 is the way of the future. The debate is summarised in terms of the major platforms: Apple (fully native for iPhone and iPad), Google (half in half for Android), Facebook (fully HTML for Facebook).
FeedHenry's offering is effecively a halfway house between the two, as the FH client API wraps the local device functionality, and allows the resulting app to delivered via app stores as a real app, despite using web technologies rather than native development languages to build.
This simple online example is a great illustration of the power of HTML5:
Every now and then I am reminded of why I latched onto Jon Udell as a Byte author in the 1990s. Then it was his very engaged style of linking abstract thought to the pragmatics of using Perl for lightweight web development. Now I suppose it is the same: Talking with Joan Peckham about computational thinking - Jon Udell
When Phil Windley pointed me to Jeannette Wing’s manifesto on computational thinking, she had me at hello. The intellectual tools of computer science, she argues — including the ability to work at multiple levels of abstraction, to automate repetitive processes, and to make and use state machines — are really “a universally applicable attitude and skill set that everyone, not just computer scientists, would be eager to learn and use.”
I am still more of a blog guy than a WiKi guy at heart, but the ease of this (for those who understand Wikis) is interesting.
Scenario: lecturer uses one TiddlyWiki on her/his laptop to edit the slides for a lecture. When ready, they are published to a place where the student can access. Then these could be allowed to be edited by the class and resubmitted to the class - perhaps with each student having one section to expand or give a critique on via a number of new slides (WiKi entries).
Scenario: anyone who is comfortable with it use TiddlyWiki as a personal note taking tool, that captures information in hypertext as linked web pages but authored as a Wiki and saveable as a single file - easy to archive or distribute.
Thanks to Stephan Raimer, TPC member of eChallenges, for alerting me to these possibilities.
By the way, the story of the TiddlyWiki author is very interesting. BT acquired his open source company in May 2007, established osmosoft, and has been using this as what seems to be a kind of open source skunk works team.... one to watch.
Perhaps the best cited article on the advantages of scripting is John K. Ousterhout's "Scripting: Higher Level Programming for the 21st Century", published in IEEE Computer in March 1998. John, the author of the popular scripting language Tcl (pronounced "tickle"), pretty much lays out the case for scripting languages. The major developments since then have been the creation of new scripting languages with special usefulness for certain domains, and a maturity in the tools that help developers use scripting languages, and test and debug their scripts/programs.
A recent Forrester report "The Forrester Wave: Dynamic Programming Languages, Q3 2007" underlines the case for dynamic languages, focusing on Python, PHP and Perl.
The popular acronym for open source development platform LAMP comprises four elements:
The O'Reilly ONLamp.com site has a great range of materials on the various elements of this platform, and O'Reilly publish the leading books on each topic (e.g. Larry Wall, Tom Christiansen, and Jon Orwant's book Programming Perl (3rd Edition July 2000), known as the Camel Book because of its cover).
There's been an interesting discussion on the internal TSSG technical discussion list in recent days spurred by this provocative post from Michael Mace, an ex Palm employee: Mobile Opportunity: Mobile applications, RIP. His basic thesis is that it is so painful trying to develop for so many hardware platforms (that currently make up the mobile handset market) that developers will inevitably be drawn towards mobile web applications instead, even though this certainly has its own problems. He claims the business model for mobile developers of native applications is so flawed that the web-based approach will inevitably win out. It is an attractive thesis and one that definitely appeals to me.
To see some of the other on-line contributions to this debate:
Unlike many of my colleagues I have such to a UIQ3 phone, the Sony Ericsson P1i (others seem to have Nokia N95 or iPhones), and even with its limited web browsing capabilities (Opera 2.3.08) it is a really useful tool. The native applications I use are: voice calls and SMS, camera, PIM (contacts, notes, calendar - though I sync with Google Calendar), and a very useful SSH client. In an emergency I use email (but it's very slow to sync with my IMAP server that has hundreds of folders), being able to send email is definitely useful. I use the mini-qwerty-keyboard and the touch-sensitive screen with a stylus for hand writing recognition about equally. Ironically I really like the built-in FM radio and use this more frequently than the MP3 player - which I do use for podcasts and music using a 4Gig card for external storage. If the bowser were more robust I would definitely use it even more.
Here's the official announcement on the release of Perl 5.10 Perl 5.10 now available - The Perl Foundation. This is the first major upgrade to Perl 5 in 5 years. The release was timed to coincide with Perl's 20th birthday - Happy 20th Birthday Perl (18th Dec 2007).
In this interesting post Rich Manalang describes the process of doing a short (6 week) JRuby project in Oracle blow by blow Oracle AppsLab's Mix, JRuby on Rails, Small Teams, Agile, and it's Effects on the World. This really captures the decision points and problems when working in an organisation used to larger more formal projects, amazing that they pulled it off and did some performance tuning in time!
I've blogged before on the emerging abstraction layers for programming, or "Rich Internet Applications", blurring the line between the browser and the desktop.
It seems the area is hotting up. the latest news is that Adobe has re-branded its Apollo framework as "Air"-- Adobe Integrated Runtime. See this InformationWeek article for a review Adobe Renames Apollo, Pushes Rich Internet Apps -- Adobe Integrated Runtime -- InformationWeek
The battle to dominate interactive, graphical Internet application platforms just got kicked up a notch. Adobe Monday announced it has re-branded its Apollo multimedia technology that lets Internet applications run outside a browser as the Adobe Integrated Runtime, or Air, and released it into beta with new features along with the first beta of Flex 3.0, Adobe's development framework for Flash and now Air.
Another TSSG spin-in company, Headway Software, is in the news the weekend with this Sunday Business Post article yesterday: Sunday Business Post | Irish Business News.
Headway's products allow developers to analyse their own code base make improvements in the quality of the code base by optimising various metrics. You can download a trial of the their entry level Structure 101 product on the Headway Software site.
The TSSG wish Chris Chedgey and his colleagues all the best in the re-launch of the Headway Software brand, we're confident it can make some real impact in the software quality world. They have had a couple of recent successes:
Tim O'Reilly blogs that John Backus Dies at 82. One of the pioneers of software, involved in creating the programming language Fortran, and the Backus-Naur Form (BNF) for specifying programming languages and other things.
In the Computer Business Review Online article Open Source Weblog: Where does open source code come from? the recently published EU report on innovation and competitiveness of the EU ICT sector is presented.
Interestingly, Sun tops the list of companies involved in open source software (tanks to Tim Bray of Sun for this link).
This is fascinating reading. I'll post back with more observations...
Jon Udell's latest post Sharing knowledge on the web ｫ Jon Udell descibes how informative he finds the web for his own work. He suggests that as so many people involved use the web regularly, and as so many of the processes involved can be represented textually in web postings, there is a very useful reflexive charater created. We use the web to learn how to use the web. He also suggests that in other domains, such as fire fighting, video representations may be more appropriate than textual ones, and that in time web will grow to encompass these too. Interesting stuff from Udell as usual!
Tim O'Reilly in this article O'Reilly Radar > Early History of the Web Pipes Concept credits Jon Udell (and Andrew Schulman) with versions of the original concept of describing the use of a web URL as an interface, and the ease with which you can then build services that interlink these individual components, as analogous to the Unix concept of piping the output of one program/script into another.
certainly I picked up on the idea from the various columns written by Jon Udell in BYTE and on other on-line publications the 1990s. It is topical now because Yahoo! have launched a service that highlights the metaphor: Yahoo! Pipes (an RSS remixer). I also learned about RSS from Jon Udell in the late 1990s and implemented RSS content aggregation on a service we launched in the South east of Ireland called ConnectKey (a portal site for local businesses that was bit ahead of its time).
the post on Ars Technica .NET and Java to get better dynamic language support neatly summarises the activities in creating virtual machines (VM) for dynamic languages. They fall into three categories:
This got me thinking: O'Reilly Radar > Threads Considered Harmful
It does make sense to try and avoid explicitly managing threads, just as it does to avoid explicitly managing memory. It's just a matter of when the technology tools can catch up with what that ought to be able to do....
Paul Watson cites Linux, Apache and Mozilla as the three main open source projects Life is grand ｻ The Three, on a thread started with O'Reilly's Nat Torkington who asked what the three most important open source projects were.
This reminds me of the old argument about whether Linux should be called GNU/Linux, as Linux is actually just the kernel, and what makes it a great platform is all of the other software that can use the kernel (like the GCC compiler, and even the "ls" command to list files, and the "bash" shell to type built-in commands). So if I could modify Linux to GNU/Linux I'd agree. One might also think of sendmail which helped provide the other major Internet service that drove the adoption of the Internet outside academia - email.
It is interesting that Fortress is effectively an update of Fortran, focusing on parallel processing capabilities. There's a big buzz around Grid Computing in general, and the open source availability of this tool could help provide more programs that can make use of Grid infrastructures - I have always found that the main bottleneck for grid/parallel computing has been parallelising the algorithms for problems.
Sun Microsystems took a new open-source step this week, enlisting the outside world's help in an attempt to create a brand-new programming language called Fortress.
On Tuesday, the company quietly released as open-source software a prototype Fortress "interpreter," a programming tool to execute Fortress programs line by line. "We're trying to engage academics and other third parties," Eric Allen, a Sun Labs computer scientist and Fortress project leader, said about the open-source move.
Fortress is designed to be a modern replacement for Fortran, a programming language born 50 years ago at IBM but still very popular for high-performance computing tasks such as forecasting the weather.
Even though Fortress grew out of a Defense Department-funded supercomputing project, it tackles a mainstream computing challenge, too: more easily extracting work from all those new processing engines appearing in multicore processors.
Here's a challenge - solve 99 problems in Perl 6 - the solutions in Lisp and Prolog can be used as a guide.... 99 Problems in Perl 6 - O'Reilly ONLamp Blog
Affordable "flat-rate data" and "handset incompatibility" are the two major issues for the mobile platform according to this post - I agree - but would qualify the inclusion of international roaming to the first issue - a big issue here in the EU. The rest of the post addresses these two issues in more detail.
A Rails/Django Comparison by Alan Green and Ben Askins RailsVsDjango
Well, the open Java Community Process had already opened up Java considerably, but now Sun have made the right decision in releasing many J2SE and J2ME components under the GPL licence. This article by Allison Randal of O'Reilly summarises it well: O'Reilly Radar > Java released as Open Source
The obvious follow-on question is when will Solaris be released under GPL, and in fact this was asked at the launch event and the answer was a definite maybe:
The main launch event was led by Jonathan Schwartz and Rich Green, with pre-recorded video segments from Richard Stallman, Eben Moglen, Tim O'Reilly, and others. At the very end, Schwartz asked Green if OpenSolaris would also be released under the GPL. He gave the best answer possible: that the community feedback from choosing the GPL for Java has been positive, so they are indeed considering the possibility of future GPL releases. It's worthy of note that the license chosen is specifically version 2 of the GPL without the often-added text "any later version", which means that Sun has reserved the right not to upgrade to version 3 of the license. Simon Phipps commented that Sun is happy with the GPLv3 process. Chances are that Sun will upgrade when the time comes, but it's a choice that strengthens their seat in the discussion over the future shape of the GPL.
I stumbled across this interesting article on software innovation today: The Most Important Software Innovations. It is an attempt to define a list of the most influential open software innovations (ignoring hardware innovations). It uses a relatively arbitrary cut-off point at TCP/IP in terms of networking (ruling lower networking protocols such as Ethernet out of scope). However, I would have to agree with the overall thrust of the argument that there are relatively few real innovations in software, and that many so-called innovative software ideas are simply a recoding of an existing idea. Of course all of us who work in software surf on the wave created by the hardware developments that make our underlying platforms cheaper and more powerful at a remarkable rate, so though this list doesn't include hardware innovation, it certainly requires it!
An interesting angle on the social implications for IT of the rise of flexible light-weight approcahes, and flexible remote storage and hosting Gartner: Prepare for consumer-led IT | CNET News.com
The suggestion is the pendulum is swinging back towards the end-user away from central IT infrasucture management.
Headway Software (a TSSG spin-in company) has just launched the latest version of their Structure 101 product that allows users to analyse the complexity of their Java source code, and to help manage that complexity. The idea is very simple: despite the heavy use of UML modelling to help with the design of software, most actual deployed software does not have a model, or has drifted from the original model. The Structure 101 product analyses the actual codebase to produce graphical visualisations, and tabulated information, that effectively exposes the existing structure of the code. It employs some simple metrics, so that developers can simply focus on improving the metric, and some more detailed analysis where developers to address potential rogue dependencies.
Full press release is available from the company website: News Headway Software, Structure 101, Version 2. Potential users can download and experiment with a version of the product directly from the website.
Chris Chedgey, CEO of Headway, also has his own blog where, amongst other things, he shows how the product can be used to analyse various open source software projects.
In this posting Easy Street (Middleware Matters) Steve Vinoski of Iona highlights the difference between enterprise-class software (ECS) and software that runs in the enterprise (STRTE) - combining the two to get the title of the post "Easy Street" = (ECS + STRTE). He positions various technologies within this framework - interesting....
Tim Bray neatly summarises a provocative posting by Spolsky that has prompted some angry rebuttals.... ongoing ｷ Spolsky Starts a Language War
In this posting Steve Vinoski links to the PDF of his review of "Enterprise Integration with Ruby" by Maik Schmidt, published in the July/August issue of IEEE Internet Computing: Middleware Matters: Enterprise Integration with Ruby. The informative review recommends the book, and recommends taking a pragmatic approach towards both REST and SOAP styles of enterprise architectures, with any tool, including Ruby.
This article addresses criticisms of CORBA levelled by Michi Henning in a recent ACM Queue article: The OrbZone ｻ Response to "The Rise and Fall of CORBA by Michi Henning"
Steve Vinoski extolls the new AMQP standardisation effort for Message Oriented Middleware in Middleware Matters: Finally, a messaging standard. We wish them success with thiese efforts!
Having been involved in middleware standards for many years, I've often wondered why real message-oriented middleware (MOM) standards didn't seem to exist. There are proprietary message queuing products, but they don't talk to each other. There's JMS, but of course that's just an API standard, and actual JMS implementations don't necessarily talk to each other, either.
Today, a number of companies, including IONA, Cisco, JPMorgan Chase, and Red Hat, announced the formation of the Advanced Message Queuing Protocol (AMQP) Working Group. There are currently several interoperable implementations of AMQP 0.8 in production, and this group is initially working to produce an AMQP 1.0 specification. I think John O'Hara, VP and Distinguished Engineer at JPMorgan, sums it up perfectly: "AMQP solves the 'missing middleware standard' problem."
These days, standards are all too often designed by committee, or are solutions (usually poor ones) in search of a problem. Judging from a recent panel that I was part of, people are fed up with this. I've previously written about problems with standards, and my old friend Michi Henning just published an article that details such as problems as well. The beauty of this AMQP effort is that the working group is formed around an already-working system. In other words, we're taking something already proven to work well in practice and standardizing it. That's exactly how standards should be created.
Look here for more information about AMQP and to download the 0.8 specification.
Bill on Is The Desktop UI Metaphor Dead?
Martin Fowler on Evaluating Ruby. This gives a unique perspective on the very current debate around web deveopment frameworks, a contribution from someone with a very strong reputation in heavyweight enterprise architectures. If he sees value in the lightweight dynamic alternatives (as he expresses here), then maybe there is a real shift happening here. I like the down to earth pragmatic tone he adopts.... a refreshing change from some more shrill voices.
SURELY WE CAN DO BETTER!
The impedance of incompatible type systems imposes a constant runtime overhead in addition to the syntactic burden. We need to move beyond the three solitudes and go beyond the gratuitous complexity that exists today. There is no reason we can't develop languages that are as productive and easy to use as 4GLs and which have underlying execution semantics based on integrated type system where tuples, objects and infosets are all first class. Microsoft .NET has already demonstrated that it is possible to have an OO language that can contain tuples and records as native types.
There are some early exemplars that show lots of promise. Xduce  provides an interesting semantics for Infosets and related research. Xtatic investigates XML as a native type in an OO language like C#. The recent research paper on the unification of tables, objects and documents  provides an interesting example of how an existing OO language such as C# or Java can be semantically and syntactically enhanced to address the problem.
We need to step back and consider the accidental complexity that arises when all of the various technical components are presented to a business developer. In isolation each of these technologies has clear merits but even a simple business application is far too complex when we compose the parts. We need to apply our considerable efforts to developing languages/tools as simple and useful for business users as 4GLs have been and continue to be. We need a computationally complete end user programming language, which will allows a mere mortal to create and deploy applications across a federated collection of semi-structured information.
Many at the PDC and JAOO were in shock as Erik Meijer http://research.microsoft.com/~emeijer/) and the VB team showed off VB 9 features that combine clever type inference and structural sub-typing to simply and elegantly manipulate squares (relational tuples), circles (objects) and triangles (XML info sets) as simple polymorphic collections.
The JAOO conference in Aarhus, Denmark has become one of the most enjoyable and informative developer conferences in the land of OO. Originally a Java conference, it has expanded to cover a wide variety of topics from MS.NET and Java technology to best practices in software engineering. This year's conference followed on the heels of the Microsoft PDC earlier in the month. Both conferences featured tracks and sessions on scripting, dynamic languages and domain specific languages. There was also a Dynamic Languages Symposium (http://decomp.ulb.ac.be:8082/events/dls05/program/) and Ruby conference at OOPSLA. These efforts are all aimed at lowering the barrier to developing applications. Hurrah!
Bill de hﾓra on The Library of Imaginary Machines (where he discusses the folucus on platforms:
"Maybe language development isn't sexy anymore. For a lot of developers now, I think programming languages just aren't all than interesting in terms of a target abstraction, or for playing around with. My generation (graduating in the late nineties) might be last that actually were interested in programming languages as an end in themselves, and even then platforms like J2EE, CORBA, and the Web were much more interesting to many."
An excellent history of middleware and server-side scripting
The Language Divide by Steve Vinoski (Iona Technologies).
I have recently given a series of lectures on our taught MSc Communications Software course on "The Rebel Platforms", a term used by Richard Monson-Haefel, an analyst with the Burton Group, in that group's regular conference (c.f. the IT Conversations Podcast. In this he includes both LAMP and its derivatives, and alternatives to monolithic J2EE in Java such as structs, Spring and Hibernate. This he identifies at least 4 major platforms: Java/J2EE, .NET, Java/rebels, and LAMP/derivatives.
Interesting to see some active debate on what the impact of dynamic languages on the Java Virtual Machine (JVM) as a platform is ongoing LAMP and Java (ongoing, Tim Bray's blog)) that references Sun Analyst Conference: Good News/Bad News (tecosystems - Stephen O'Grady's blog). This includes those who use specific version of those dynamic languages that target the JVM: "Jython and JRuby and Caucho (as in, PHP on the JVM) and so on".
So the first thing we have to do is to stop mixing up the Java Language and the Java Platform, and make it clear to the world that other languages - in particular dynamic languages - work fine on the platform, and that there's nothing wrong with using them. Then we have to do some engineering work to help this happen. The good news is, we're getting started on that; see Gilad Bracha's article and slides on the JVM-level progress. But that's way down in the engine room; I think we need to help out all the way up and down the stack; the profilers and debuggers and IDEs and, well everything. But still (call me a marketing droid if you want to) I think the message is the important thing: It's time to grow and share the Java platform; everybody wins.
The impact of JVM as a virtual machine for dynamic languages is balanced by the potential impact of an emerging new virtual machine designed for dynamic languages, Parrot, a spin-off of Perl 6 activity, that felt the next version of Perl needed its own VM, though the idea is now to optimise Parrot for dynamic languages in general.
Bill's weblog is a constant steam of excellent coment. His recent review of the year of his own blog highlighted this exellent commentary on Structure And Interpretation of Computer Programs
For every programmer that adores this book, there's probably five who don't and ten who've never come across it, and if they did, would think it irrelevant to their working lives. I can sympathize with those fifteen programmers having been one of them. All the code in the book is in Scheme. That's a barrier right there because it means most people will have to learn a non-algol language to understand the book. But given the range and depth this book succeeds in covering, it's definitely the case that Scheme is a good choice. Given the first edtion was published in 1985 (I think), it's hard to imagine it being done in any other language. Smalltalk was another powerful language available at the time, but then again, Objects don't appear for 200 pages (in section three).
Sean McGrath has posted an informative article musing on traffic management in India: ITworld.com - Naked programming on naked street. The argument is that, although it sounds crazy, the best way to get things done is to have a free for all and just see what happens! Works for me, sometimes.
Brian Delahunty, who works with us here in the TSSG, is posting a series of articles on using Mono (the cross-platform version of .NET). Here's a link to a posting on his weblog: Introduction to Mono - A series of articles about Mono development. And here's the Introduction to Mono article.
ObjectWeb has announcd that the open-source application server JOnAS is now J2EE 1.4 certified, following 9 months of testing work. JOnAS was the first open source project to be awarded a scholarship under Sun's non-profit, open source friendly license terms. JOnAS joins JBoss as the only two certified open source appserver alternatives to commercial servers.
JOnAS is a platform integrating original code with best of breed components from ObjectWeb and other open-source communities: Carol, HOWL, Ishmael, Jeremie, Jonathan, Joram, JORM, JOTM, Medor, Monolog, Perseus and Speedo from ObjectWeb; Axis, EWS, Jakarta Commons, Struts, Tomcat, Velocity, WSDL4J, XMLBeans from Apache; HsqlDB, JacORB, JGroups, Mx4J, P6Spy, XDoclet and XJavaDoc from the open-source community at large.
ObjectWeb is an international consortium of academia, corporate and individual members hosted and represented by INRIA, the French National Institute for Research in Computer Science and Control. ObjectWeb licenses the J2EE CTS under Sun's license terms friendly to non-profit and open source projects. JOnAS was the first open-source project to be awarded such a scholarship by the Technology Compatibility Kit (TCK) Review Board (Apache Software Foundation, Doug Lea, professor of Computer Science, State University of New York at Oswego, and Sun Microsystems) in September 2003.
INRIA and Sun then worked several months to put in place the proper legal framework that would allow the ObjectWeb community of members to certify JOnAS' compliance. The certification process itself started in April 2004.
I have been involved in some EU project proposals with ObjectWeb and I have been very impressed by their professional open source ethos. Getting this certification is a recognition of a lot of work by a hard working team. Well done!
Useful guide to testing perl imports: perl.com: Perl Code Kata: Testing Imports
Jon Udell describes The present and future value of Python. This looks at the trend towards reevaluating the worth of dynamic scripting languages, especially those that link to virtual machines.
Sean McGrath has written the first installment of a planned 5 part tutorial on Jython Webapplication programming: Jython Webapp Tutorial
I am very interested by those who argue that the WS-I* standards are too complex, and that we should refocus on simple XML server-side processing and simple clients. This lays out this stall nicely.
In this thoughtful article Practical RDF ｻ Web 2.0 just like Web 1.0 before we got clever Shelly Powers critiques how the light-weight distributed computing bandwagon is setting itself up to make the same mistake it did years ago. There's a lot of talk around this theme, especially at the Web 2.0 Conference (San Francisco, CA, 5th-7th Oct 2004), which is just finished. However I see in the writings of Jon Udell, John Battelle and others that there is a more positive spin can be put on the reemergence of light-weight architectures to challenge the heavy applications server industry. Remember, there's a new platform out there: the mobile connected device (smart PDA, smart phone, smart iPod, or whatever) just waiting for inventive new applications and services that can be programmed using light-weight techniques. Start hacking.....
Good to see people are trying out Parrot and posting about it: Sam Ruby: make Parrot
John Battelle's Searchblog: Put On Yer Search Hat explains how Don Park has some search ideas: that it would be useful if you could tell the search engine what your priority for the search was (e.g. you're a developer, or you're a home PC user) and that you might have more than one profile and switch between them.
In these projects the primary focus was on discovering re-usable on-line e-Learning content modules , and various types of XML metadata were used to describe these modules (IEEE LOM and others), and to describe the users, and to describe the devices. The architecture, however, is applicable to pretty much any form on-line content. The public results of the Guardians project can be downloaded from Guardians Public Downloads
The problem with the type of approach suggested by Guardians is the large overhead in the creation of the metadata in the first place. Whilst I am also a big fan of Cory Doctorow's polemic metacrap document warning of the simplistic assumptions about metadata, I also beleive that more sophisticated auto-generated profiles and resource decriptors will help refine the very rough search strategies used by search engines currently. Roll on the semantic web....
To go with my recent post on Perl testing, here's the BBC's Perl Programming Style Guide: Appendix A. Perl Coding Standards It is a lighweight guide (doesn't impose variable naming schemes and such like) but useful nevertheless. Interestingly doesn't mention taint checking for CGI code that I would have thought would be a must. Nevertheless a good starting point (and it is a draft version v0.14). Thanks to the Dublin Perl Mongers' list for alerting me to this one.
This is a useful article on implementing testing in Perl perl.com: Building Testing Libraries [May. 07, 2004]
The TSSG are currently designing a taught MSc in Communications Software (that will share modules with other taught MScs in Software Engineering offered in WIT) and we are exploring at ways of formalising the design knowledge required for such a course. Eamonn de Leastar (a colleague) alerted me to this excellent book: Patterns of Enterprise Application Architecture (Martin Fowler). Building a module around this could help make it generic enough to of value to a range of taught MSc offerings. A related book is Enterprise Integration Patterns (Hohpe & Woolf), the link it to a portal site where similar issues are discussed. I was impressed by the simple clarity of Hohpe's discussion around the areas of message-oriented middleware and loose coupling Asynchronous Messaging Architectures in Practice. This is related to the interesting work on the REST (REpresentational State Transfer) of Roy Fielding's PhD dissertation, a retrospective architectural justification for we-based architectures.
All this Design Patterns work is based on the famous Gang of Four Design Patterns (Gamma, Helm, Johnson and Vlissides, 1994) book. Another work colleague, Karl Sandison, is a big fan had has been using this as part of the undergraduate programme for many years. This distinction is that Fowler and Hohpe explictly focuses on Enterprsie Patterns.
Patterns of Enterprise Applications Architecture (Fowler, 2002).
Enterprise Integration Patterns (Hohpe & Woolf, 2003).
Spotted this useful tip on automating JBoss JMS queue setup: Jboss: Making deployment less of a PITA.