The Apache Tuscany project provides multiple
language implementations of the Service Component Architecture (SCA)
specifications and related technologies. An upcoming book, Tuscany
SCA in Action, is a guide for developing technology-agnostic,
service-oriented composite applications using Apache Tuscany's
implementation of SCA. It was co-written by Mark Combellack, Raymond
Feng, Simon Laws, Haleh Mahbod and Simon Nash. In this interview, two of
the authors, Mahbod and Feng, speak about Tuscany and SCA. Mahbod is an
Apache Tuscany PMC member and committer. She has led development
organizations that delivered SOA-based integration platforms and
solutions in open source, in Fortune 500 and start-ups. Feng is an
Apache Tuscany PMC member and committer and a senior engineer at IBM.
SearchSOA.com: Tell us about Tuscany, an implementation of
Service Component Architecture (SCA) and an open source Apache project.
Haleh Mahbod: You need a common way to describe an assembly of
distributed services regardless of the technologies used, and to do so
without polluting the business logic. That's what SCA provides, and what
Tuscany implements: a way to follow a SOA paradigm and use SCA as a
programming model to assemble these services. To take a step back,
really Tuscany is composed of two major pieces: The infrastructure side
of it, which frees the application from being polluted from extra code;
and implementing a standard language for SOA, which gives you
flexibility and portability. The architecture is very modularized. You
can take pieces of Tuscany and embed it in your own software.
Tuscany 1.x is a full implementation of SCA 1.0 developed by [the
Open SOA Collaborative, which developed version 1.0 of the SCA spec,
before turning it over to OASIS]. The OSOA version 1.0 is pretty mature
now, and it has many users. SCA 1.1 is in the process of being
standardized at OASIS. The Tuscany 2.x version is implementing that, and
we'll be helping the standards team with compliance testing for SCA 1.1
to make sure the 2.x version of Tuscany is compliant with the SCA 1.1
SSOA: What was the impetus for Tuscany?
Mahbod: IBM started developing SCA. At the time WebSphere,
the process server and the ESB were based on SCA. Later on, SCA was
developed in the open into specifications through collaboration with
OSOA and moved to OASIS to create a standard. For Tuscany itself, the
goal was to introduce the technology to the market globally. Tuscany
behaved as an implemenation testbed for the spec. The community provided
early implementation for the spec, and provided feedback [from the
developers] and user feedback from people using Tuscany, strengthening
the implementation. The other thing Tuscany did was serve as an
innovation test for spearheading new projects—Tuscany has an Android
implementation, and we've experimented with cloud computing on Google
Apps, for example.
Raymond Feng: I think innovation goes beyond adding
extensions to what's not been specified in the SCA spec. Tuscany expands
SCA in that direction, with new extensions to cover popular
programs/frameworks. Tuscany also identifies new opportunities for SCA,
not just purely as a programming model but also how it fits to new
opportunities, such as integration between SCA and the OSGi enterprise
SSOA: Is OSGi, a component integration platform and dynamic
module system for Java, complementary to SCA?
Feng: When people talk about OSGi they're possibly talking
about different things. One is as a Java module assistant to make a
complex platform more manageable. It also defines a service programming
model that allows you to use Java. Tuscany covers OSGi from both
perspectives. It has a runtime implementation of the SCA spec, so it
enables Tuscany to host OSGi bundles. In Tuscany, you make OGSi bundles
viable as SCA components.
Mahbod: SCA extends OSGi with its high-level, coarse-grained
composition. It enables you to incorporate components that are not Java
SSOA: Microsoft hasn't been part of the SCA effort. How has
Tuscany addressed this?
Feng: From the spec side, even though Microsoft is not
involved, they have made some comments in public review. At this point I
don't see any implementation of SCA on a Microsoft platform, but it
doesn't exclude that. There has been some discussion, but there is no
contribution coming from the [Tuscany] community yet.
SSOA: What will readers take away from your book, Tuscany
SCA in Action?
Mahbod: The book is a tool for learning SCA for the first
time, with detailed practical examples for creating composite
applications from services. The main example in the book is a travel
booking application. You start implementing small components and grow to
[implementing larger components]. All the source code is available in
the Tuscany project. It's intended for developers who care about
creating reusable services and assembling them. We focus on the freedom
of choice of technology for developing components, choosing protocols
[and] the hosting environment. We show how easy it is to use SCA. Part
four talks to people who want to extend Tuscany and incorporate any
technology we might not be providing out of the box. We provide many out
Your takeaway is you'll understand SCA and how useful it is to
business. You'll gain hands-on experience developing a travel booking
application, and from that you can jump-start your own business
application. We have best practices outlined—how to work with Apache
Tuscany, how to get help, how to participate.