Dave Johnson on open web technologies, social software and Java
This is the third in my series of Web Integration Patterns. Check out the intro at this URL http://rollerweblogger.org/roller/entry/web_integration_patterns
Enable easier integration and better search across integrated web applications and sites by using standard mechanisms (e.g. Microformats, RDFa) to embed property values in HTML pages.[Read More]
This is the second in my series of Web Integration Patterns. Check out the intro at this URL http://rollerweblogger.org/roller/entry/web_integration_patterns
Make separate web sites and applications appear to be one by using common user interface elements for navigation.[Read More]
This is the first in my series of Web Integration Patterns. Check out the intro at this URL http://rollerweblogger.org/roller/entry/web_integration_patterns
Use links as a way to integrate web sites & applications via navigation and relationships between resources.[Read More]
In my previous post, I promised to write a blog series on Web Integration Patterns. This post explains the concept and a bit about how I plan to write about it.
Ive been meaning to write on this topic for a some time and to explain how Ive gone from being an advocate of RSS/Atom feeds, Atom Publishing Protocol and things bloggy to being a proponent of Linked Data (video), Semantic Web, RDF and other things that I previously considered to be nuisances. I've also got a new topic and blog series to announce, so here goes.[Read More]
In my quest to get Roller running on the latest in Java EE servers, the last server I tacked was the WebSphere Application Server. Unlike Glassfish and JBoss, WebSphere's Java EE 6 offering is not available in final form yet. Java EE 6 support is coming in WebSphere 8. So, for this exercise I used the WebSphere 8 beta, which was made available in July 2010. In this blog I'll describe how I approached the problem what I learned along the way.[Read More]
In my quest to make Roller work on Java EE 6, the next server that I tackled was JBoss 6. In this blog I'll describe how I approached the problem what I learned along the way.
Roller uses JPA for database storage and specifically the Apache OpenJPA implementation. I knew that JBoss uses the Hibernate JPA implementation and I suspected that there would be JPA portability problems, so I decided to run Roller's JUnit tests against Hibernate JPA. There were many test failures and fortunately, the failures were easy to fix.[Read More]
In my quest to make Roller work on Java EE 6, the first server that I decided to tackle was Glassfish 3. In this blog I'll describe how I approached the problem and what I learned along the way.
Roller uses JPA for persistence and specifically the Apache OpenJPA implementation. I knew that GlassFish uses the EclipseLink JPA implementation and I suspected that there would be JPA portability problems, so I decided to run Roller's JUnit tests against EclipseLink JPA. I wanted to find and fix those problems before even touching GlassFish. The tests ran and there were many JPA related failures and errors, most due to differences in the way that EclipseLink handles bi-directional relationships and the use of unmanaged objects.[Read More]
It's hard to believe, but I've been dorking around with Roller, the blog software that powers this site, for almost 10 years now. I started in summer 2001. In the past couple of years, I've had a lot less time to work on Roller. I devoted some of that time to mentoring student developers, which was fun and rewarding. I also spent time making Roller more consumable for developers by making it easier to build, run and deploy to modern Java app servers, which was not really fun but was definitely educational, bloggable even.[Read More]
Latest links from my Twitter, Google Reader and Flickr accounts.
Dave Johnson in Links 05:20PM Jan 04, 2011
On the last day of 2010, I made available the third release candidate for Apache Roller 5.0. The main difference between this new candidate and the previous one is that the new RC3 runs on Java EE 6 servers: Glassfish 3, JBoss 6 and Websphere 8 (currently in beta). Making this happen took a lot more work than I expected and I'll blog about that over the next couple of weeks as it is an interesting case study in Java EE 6 portability.
Here's the announcement:
Apache Roller 5.0 Release Candidate RC3 is now available for testing. Note that this is NOT a release of the Apache Software Foundation or anybody else; this release candidate is for testing purposes only and not recommended for production. What's new in Roller 5.0: https://cwiki.apache.org/confluence/display/ROLLER/What's+new+in+Roller+5.0 Change list (issues resolved since 4.0) http://bit.ly/gAhDWR Issues resolved since last release candidate (RC3) http://bit.ly/dZ27Nx Signed binary and source files. Also, documentation in PDF form http://people.apache.org/~snoopdave/apache-roller-5.0/ The biggest change in RC3 is the new support for Java EE 6 application servers: Glassfish 3, JBoss 6 and Websphere 8 (beta). I've been able to verify that Roller runs on all of those servers, and I updated the installation guide to explain in detail how you install on Glassfish, JBoss and WebSphere. If you would like to help out then please test RC3, discuss the problems you encounter here and file specific bugs with steps to reproduce in the Roller JIRA bug tracking system. Thanks, DaveThat announcement is available here: http://markmail.org/message/my5wbld2xqvhqpyg
This is the closest thing to a blog post that I've written lately, a post to the OpenSocial specification group on aligning OpenSocial with RDF and Linked Data:
Link: RDF and OpenSocial
This is a topic of interest to me, so I'll try to elaborate.
First, I want to point out that RDF is not a representation, it's a way to model data and it's multiple ways to represent that data (in XML, JSON, etc.). I think the real question is: how do we enable OpenSocial to hook into the RDF-based web of "Linked Data" that is rapidly growing up around scientific data, government open data and the academic world. I'm not going to go into the benefits of Linked Data in this post, but I will disclose that I work for a company that uses RDF as a common data model to enable loosely coupled integration across our web application products (see also Jazz Integration Architecture  and OSLC ). We'd like to be able to integrate with OpenSocial services in the same ways.
I'll explain the basics of RDF. RDF is way to model web data and ways to represent that data in XML, JSON, Turtle, etc. The RDF data model is simple, we have resources identified by URIs and property values associated with those resources. Resources can have types, each type is identified by a URI. Property types have URIs too. Once you have defined your data model in terms of RDF types and properties, you can represent resources and their properties using RDF representations. There's RDF/XML for XML, there's RDFa for embedding properties in HTML. There's are JSON representations too, but not a standard for JSON yet.
So, to bring OpenSocial in-line with the world of Linked Data, we would define each class of OpenSocial objects as an RDF type, with a URI. We would define each OpenSocial property as an RDF property, with a URI. In some cases, we'll want to use existing properties, like the Dublin Core title, name, etc., and in some cases we'll want to define entirely new types and properties.
As a starting point, I think we would do the following:
* In OpenSocial v2, we would define all OpenSocial objects and properties as RDF types in the OpenSocial Specs. This means simply assigning a URI to every class and every property we define, using standard properties where appropriate and defining new ones as needed. Object and property names would rename the same and we'd have what is essentially an RDF mapping built into the spec. Existing OpenSocial representation formats would stay the same, but we'd add some new RDF representations.
* We'd introduce an optional new OpenSocial spec that services MAY implement: the OpenSocial RDF Specification. The specification would simply require that a service provide RDF representations of it's resources via content-negotiation. The service could offer RDF/XML or HTML with RDFa, JSON/RDF or all of the above.
That's a starting point and I think we could come up with some other ideas if we thought more about use cases. Anybody else interested in aligning the worlds of OpenSocial and Linked Data?
A couple of weeks ago, I made a second release candidate available for Apache Roller 5.0. Here's the announcement (also available at http://s.apache.org/apacheroller50rc2):
Apache Roller 5.0 Release Candidate RC2 is now available for testing. Note that this is NOT a release of the Apache Software Foundation or anybody else; this release candidate is for testing purposes only and not recommended for production. What's new in Roller 5.0: https://cwiki.apache.org/confluence/display/ROLLER/What's+new+in+Roller+5.0 Roller 5.0 JIRA change list: https://issues.apache.org/jira/sec ... sion=12313828 Signed binary and source files http://people.apache.org/~snoopdave/apache-roller-5.0/ Issues resolved since RC1: http://bit.ly/9eWjJk If you would like to help out then please test RC2, discuss the problems you encounter here and file specific bugs with steps to reproduce in the Roller JIRA bug tracking system.
I'm running RC2 on this site and it seems to be holding up just fine so far.
This looks to be useful and I'm always happy to hear of more bike lanes and greenway paths planned for Raleigh. The main thing I need for my biking safety is a bike-path along Sandy Forks Road, or at least a sidewalk, but apparently that's not in the Raleigh Bike Plan's Top 25 (whatever that means).
Courtesy of Mr. Steve Waters member of the Raleigh Bike Ped Advisory Commission comes this one-stop look at Raleigh's greenways and bicycle routes, current and future. (Mostly, in the case of bike lanes, future.)
While reading the feeds the other day, I was delighted to see that the USDA IT department offers support for Apache Roller within the agency, below are the options. Wordpress MU is also supported.
Enterprise Solutions (NITC): Software As A Service
NITC offers a full service Blogging software service that can provide enhanced internal and external communication among management, operational and business staff, and the public. When this service is integrated into a web application, posted information is shared in a chronological fashion that delivers a high level of feedback and end-user interaction.
- Apache Roller Weblog or Wordpress MU software
- Apache Roller Weblog
- Multi-node, highly available architecture
- Production and non-Production environment
- USDA eAuthentication protection available
- Customizable theme packs, including standard USDA templates
- User Accounts for site administration / content authoring
- Wordpress MU
- Multi-node highly available solution
- Production and non-Production environment
- Optional add-ons to add additional functionality to blogs
- Customizable CSS-based themes
- RSS Feeds
Dave Johnson in Links 05:14AM Jun 23, 2010
This sounds cool. I'd love love to see the slides or better yet, a sceen-cast.
Collaborative estimation and planning is a key concept for all agile development process frameworks. We will present a solution for playing "Planning Poker" that enables distributed development teams to estimate the effort of work items and build consensus in a collaborative way.
The prototype uses Google Wave as a collaboration platform and OSLC (http://www.open-services.net) for seamless integration with the developer IDE and work environment. We will show a demo on how a distributed team can estimate user stories and tasks from a product backlog in a collaborative way, and instantly use the results as the base for further sprint planning.
Additionally, attendees will learn some basic concepts and features about Google Wave, OSLC and IBM Rational Team Concert.