JavaOne bug

I'll post about JavaOne later, but if you attended you really should check out Duane's blog concerning health issues around the conference. Luckily I wasn't affected, but I know others were!

DOA 2008

OTM 2008 Federated Conferences - Call For Papers
Monterry (Mexico), November 9 - 14, 2008
http://www.cs.rmit.edu.au/fedconf/

BRIEF OVERVIEW

"OnTheMove (OTM) to Meaningful Internet Systems and Ubiquitous Computing"
co-locates five successful related and complementary conferences:
- International Symposium on Distributed Objects and Applications (DOA'08)
- International Conference on Ontologies, Databases and Applications of
Semantics (ODBASE'08)
- International Conference on Cooperative Information Systems (CoopIS'08)
- International Symposium on Grid computing, high-performAnce and Distributed
Applications (GADA'08)
- International Symposium on Information Security (IS'08)

Each conference covers multiple research vectors, viz. theory (e.g. underlying
formalisms), conceptual (e.g. technical designs and conceptual solutions) and
applications (e.g. case studies and industrial best practices). All five
conferences share the scientific study of the distributed, conceptual and
ubiquitous aspects of modern computing systems, and share the resulting
application-pull created by the WWW.

PAPER SUBMISSION SITE
http://www.cs.rmit.edu.au/fedconf/index.html?page=submit

IMPORTANT DEADLINES:

- Abstract submission: June 8, 2008
- Paper submission: June 15, 2008
- Acceptance notification: August 10, 2008
- Camera ready: August 25, 2008
- Registration: August 25, 2008
- OTM Conferences: November 9 - 14, 2008

PROGRAM COMMITTEE CHAIRS

CoopIS PC Co-Chairs (coopis2008@cs.rmit.edu.au)
* Johann Eder, University of Klagenfurt, Austria
* Masaru Kitsuregawa, University of Tokyo, Japan
* Ling Liu, Georgia Institute of Technology, USA

DOA PC Co-Chairs (doa2008@cs.rmit.edu.au)
* Mark Little, Red Hat, UK
* Alberto Montresor, University of Trento, Italy
* Greg Pavlik, Oracle, USA

ODBASE PC Co-Chairs (odbase2008@cs.rmit.edu.au)
* Malu Castellanos, HP, USA
* Fausto Giunchiglia, University of Trento, Italy
* Feng Ling, Tsinghua University, China

GADA PC Co-Chairs (gada2008@cs.rmit.edu.au)
* Dennis Gannon, Indiana University, USA
* Pilar Herrero, Universidad Politécnica de Madrid, Spain
* Daniel S. Katz, Louisiana State University, USA
* María S. Pérez, Universidad Politécnica de Madrid, Spain

IS PC Co-Chairs (is2008@cs.rmit.edu.au)
* Jong Hyuk Park, Kyungnam University, Korea
* Bart Preneel, Katholieke Universiteit Leuven, Belgium
* Ravi Sandhu, University of Texas, USA
* André Zúquete, University of Aveiro, Portugal

WS-FM 2008

WS-FM 2008

5th International Workshop on Web Services and Formal Methods
September 4-5, 2008, Milan, Italy

http://www.informatik.uni-rostock.de/ws-fm2008/

Co-located with the 6th International Conference on
Business Process Management (BPM'08)

Important Dates
---------------

* Abstract submission deadline: May 19, 2008
* Paper submission deadline: May 26, 2008
* Author notification: June 23, 2008
* Camera-ready pre-proceedings: July 21, 2008
* Workshop dates September 4-5, 2008

Scope of the Workshop
---------------------

Web Service (WS) technology provides standard mechanisms and protocols
for describing, locating and invoking services available all over the
web. Existing infrastructures already enable providers to describe
services in terms of their interface, access policy and behavior, and
to combine simpler services into more structured and complex
ones. However, research is still needed to move WS technology
from skilled handcrafting to well-engineered practice, supporting
the management of interactions with stateful and long-running services,
large farms of services, quality of service delivery, inter alia.

Formal methods can play a fundamental role in the shaping of such
innovations. For instance, they can help us define
unambiguous semantics for the languages and protocols that underpin
existing WS infrastructures, and provide a basis for
checking the conformance and compliance of bundled services. They can
also empower dynamic discovery
and binding with compatibility checks against behavioural properties
and quality of service requirements. Formal analysis of security
properties and performance is also essential in application areas such as
e-commerce. These are just a few prominent aspects;
the scope for using formal methods in the area of Web Services is
much wider, and the challenges raised by this new area can
offer opportunities for extending the state of the art in formal techniques.

The aim of the workshop series is to bring together researchers
working on Web Services and Formal Methods in order to catalyze
fruitful collaboration. The scope of the workshop is not purely
limited to technological aspects. In fact, the WS-FM series has a strong
tradition of attracting submissions on formal approaches to
enterprise systems modeling in general, and business process modeling
in particular. Potentially, this could have a significant impact on
the on-going standardization efforts for Web Service technology.


List of Topics
--------------

This edition of the workshop will have a special focus on the
integration of different ways for conceiving Web Services, like
orchestration vs choreography, Petri nets and workflow models vs
process calculi ones, client-server interaction vs multiparty
conversation, secure but static service binding vs open dynamic
binding, etc.

Other topics of interest include, but are not limited to:

* Formal approaches to service-oriented analysis and design
* Formal approaches to enterprise modeling and business process modeling
* WS coordination and transactions frameworks
* Formal comparison of different models proposed for WS protocols and
standards
* Formal comparison of different approaches to WS choreography and
orchestration
* Types and logics for WS
* Goal-driven and semantics-based discovery and composition of WS
* Model-driven development, testing, and analysis of WS
* Security, performance and quality of services
* Semi-structured data management and XML technology
* WS ontologies and semantic description
* Innovative application scenarios for WS

We encourage also the submission of tool papers, describing tools
based on formal methods, to be exploited in the context of Web
Services applications.

Submissions
-----------

Submissions must be original and should neither be already published
somewhere else nor be under consideration for publication while being
evaluated for this workshop.

We are negotiating with Springer the publication of all accepted
papers in the workshop post-proceedings as a volume of Lecture Notes
in Computer Science (LNCS), to appear a few months after the workshop.

Papers are to be prepared in LNCS format and must not exceed 15 pages.

All papers must be submitted following the instructions at the
WS-FM'08 submission site, handled by EasyChair:

http://www.easychair.org/conferences/?conf=wsfm2008

History
-------

Information about previous editions of the workshop can be found at

WS-FM'07: http://bpm07.fit.qut.edu.au/ws-fm07/
WS-FM'06: http://www.cs.unibo.it/projects/ws-fm06/
WS-FM'05: http://www.cs.unibo.it/~lucchi/ws-fm05/
WS-FM'04: http://www.cs.unibo.it/~lucchi/ws-fm04/

Starting from 2007, the workshop has taken over the activities of the
online community formerly known as the "Petri and Pi" Group, which
allowed to bring closer the community of workflow oriented researchers
with that of process calculi oriented researchers. People interested
in the subject can still join the active mailing list on "Formal
Methods for Service Oriented Computing and Business Process
Management" (FMxSOCandBPM) available at

http://www.cs.unibo.it/cgi-bin/mailman/listinfo/fmxsocandbpm

Steering Committee
------------------

W. van der Aalst (Eindhoven University of Technology, The Netherlands)
M. Bravetti (University of Bologna, Italy)
M. Dumas (University of Tartu, Estonia)
J.L. Fiadeiro (University of Leicester, UK)
G. Zavattaro (University of Bologna, Italy)

Program Committee
-----------------

Co-chairs:

R. Bruni (University of Pisa, Italy)
K. Wolf (University of Rostock, Germany)

Other PC members:

F. Arbab (CWI, The Netherlands)
M. Baldoni (University of Torino, Italy)
A. Barros (SAP Research Brisbane, Australia)
B. Benatallah (University of New South Wales, Australia)
K. Bhargavan (Microsoft Research Cambridge, UK)
E. Bonelli (Universidad Nacional de Quilmes, Argentina)
M. Butler (University of Southhampton, UK)
P. Ciancarini (University of Bologna, Italy)
F. Curbera (IBM Hawthorne Heights, U.S.)
G. Decker (HPI Potsdam, Germany)
F. Duran (University of Malaga, Spain)
S. Dustdar (University of Vienna, Austria)
A. Friesen (SAP Research Karlsruhe, Germany)
S. Gilmore (University of Edinburgh, Scotland)
R. Heckel (University of Leicester, UK)
D. Hirsch (Intel Argentina, Argentina)
F. Leymann (University of Stuttgart, Germany)
M. Little (RedHat, UK)
N. Kavantzas (Oracle Inc., U.S.)
A. Knapp (LMU Munich, Germany)
F. Martinelli (CNR Pisa, Italy)
H. Melgratti (University of Buenos Aires, Argentina)
S. Nakajima (National Institute of Informatics, Japan)
M. Nunez (Complutense University of Madrid, Spain)
J. Padget (University of Bath, UK)
G. Pozzi (Politecnico Milano, Italy)
R. Pugliese (University of Florence, Italy)
A. Ravara (Technical University of Lisbon, Portugal)
S. Ross-Talbot (pi4tech)
N. Sidorova (Eindhoven University of Technology, The Netherlands)
C. Stahl (Humboldt-University Berlin, Germany)
E. Tuosto (University of Leicester, UK)
H. Voelzer (IBM Zurich, Switzerland)
D. Yankelevich (Pragma Consultores, Argentina)
P. Yendluri (Software AG, U.S.)

XTP

Have been doing some thinking and planning around what Extreme Transaction Processing should be. Now all I need do is fine time to do something about it!

A tribute to Jim

Not a lot more I can say. He is missed by all those who knew him.

OPENflow deserves another chance

While we were dutifully working on Arjuna, Arjuna2, JavaArjuna, OTSArjuna and other things, Stuart and Santosh (amongst others) were also hard at work on OPENflow. As with many things we did back then it began life as an attempt to improve standards: this time workflow in collaboration with Nortel (and was better received by users than the competitor specification from the WfMC). Over the next few years it went much further than the original submission and became one of our product offerings. Although the research and development took a bit of a back-seat to the JTS development when we were acquired by Bluestone, it still managed to be cutting edge.

Unfortunately when we were acquired by HP they already had a workflow product (Process Manager Interactive). The decision was taken to stop OPENflow and that was essentially that. (It was also the point that HP Middleware, a predominately Java-based division, decided to mothball our C++ transaction service.) But even today OPENflow offers capabilities that modern equivalents could benefit from. Quite a few capabilities to be perfectly honest. I think it's time to revisit past decisions and re-learn forgotten techniques!

I haven't even begun to blog about B2B Objects yet, either.

Degrees of coupling

Over the past few years we've seen the distributed system industry moving to embrace loose coupling as though it's a global panacea to all of the woes of the previous decades. I've said on many occasions that coupling (loose or close) is something that cannot be taken in isolation: as with most things there's a trade-off to be made and there are degrees of coupling (no innuendos intended). I made that point again with my first presentation of 2008 and as recently as QCon, also taking that opportunity to point out again that loose coupling isn't something discovered or invented by the distributed systems community. It's a general software engineering pattern that has been used since Noah used his ZX76BC.

Now what makes me write about this again, when it's old hat? Well Jim's written a nice piece on coupling and cohesion. It's worth a read, but what prompted me to add this entry wasn't the subject itself but the fact that it references Pete Lee. As with Jim, Pete was one of my undergraduate teachers and took me through two years of software engineering. And it was this course that first brought loose coupling and cohesion (and many other things) to my attention. When I was preparing my presentation for the winter school I wanted to pull some specific references from the software engineering book we used during that undergraduate course, but it's stuck up in the loft and I was too lazy to go and find it. It's been over 20 years since I last saw it, but I'm pretty sure it was the first edition of Ian Sommeville's excellent book. Maybe time to buy the latest edition!

Winter School presentation

Back in January I make a two day presentation on the evolution of distributed systems at CUSO Winter School. The audience was a mixture of students and professors with a variety of backgrounds (most not in distributed systems research). So I had a great opportunity to start with a blank slate and try to give an historical background as well as comparing and contrasting with different approaches. The feedback during the event was great, but also the act of just sitting down and having to create the presentation helped coalesce a lot of things that I've worked through over the past 20 years.

QCon London 2008

It's a bit late, but here's a quick summary of QCon London 2008. Although I've been an InfoQ editor for a couple of years, this was my first time at a QCon and I was impressed. The presentations I saw were all packed and technically very good: there was none of the "product placement" that you tend to see more and more at conferences. Even the vendor pavilion was less of a car salesroom and more another opportunity to share technical discussions. I was impressed.

I jumped across the tracks during the days I wasn't presenting. However, on the Thursday I stayed with my track. Given what I'd heard about the same track at the last QCon, I was expecting a lot of controversy. However, this time I think the community has moved on and accepted that one size doesn't fit all, which coincidentally was the subject of my presentation. The entire day of the track went well and I thought all of the presentations came together very cohesively.

Diving at long last

It's been really difficult to find the time and the weather to go diving. With the 6 month clock ticking, we finally bit the bullet and got wet. The weather wasn't great, so we opted for Ellerton again. Although my dive computer said it was 9C certain parts of my body registered much lower! Whereas others were diving in dry suits, we were roughing it in our 5mm wet suits. We managed to get nearly an hour dive time despite the temperature. And I'm sure my hands were blue when I started!

I love diving for a number of reasons. Not least of which is the silence and ability to think about things while I'm down there. I managed to resolve a few issues I haven't been able to get to during my normal working day and a couple of new blog entries will be coming as a direct result. Now it had better not be another 6 months before my next dive!

Another blast from the past

I was in Neuchatel this week for some meetings and one of our conversations moved on to failure detection/failure suspecting: the fact that you cannot reliably detect failures until (and unless) those failures are eventually recovered from. Typical "detection" uses timeouts and if you use the wrong value you can end up in a world of pain. That's where failure suspectors come in: the idea is that if you think something has failed then you make sure everyone else agrees with you so even if you are wrong you don't end up with split-brain syndrome. This reminded me of some work I did back in the 90's around quantum mechanics and failure detectors.

A couple of not so obvious facts around REST/HTTP

While composing an entry on QCon I came across a couple of factoids around REST/HTTP that I had thought obvious but when I mentioned them at the event a few people found them surprising. So rather than bury them in that post (when it eventually appears), I thought I'd bring them up here:

• I've been developing applications on the Web since it was first released: being at University at the time, I had a lot of freedom to play. I even wrote a browser in InterViews! (Anyone else remember gopher?) Anyway, I remember being glad when the first URN proposal came out because it looked to address some of the issues we mentioned at the time, through the definition of a specific set of name servers: no longer would you have to use URLs directly, but you'd use URNs and the infrastructure would look them up via the name server(s) for you. Sound familiar? Well fast forward 10 years and that never happened. Or did it? Well if you consider what a naming service (or trading service) does for you, WTF is Google or Yahoo?


• My friend and co-InfoQ colleague/editor Stefan has another nice article on REST. In it he addresses some of the common mis-conceptions around REST, and specifically the perceived lack of pub/sub. You what? As he and I mentioned separately, it seems pretty obvious that RSS and Atom are the right approach in RESTland. The feedback I got at QCon the other week put this approach high on my pet projects list for this vacation, so I've been working on that for our ESB as well as some other stealth projects of my own.

Now the folks I met at QCon were all very bright. So their surprise at these "revelations" came as a bit of a surprise to me. But hey, maybe it wasn't a good statistical sample.

Beautiful Code

Just back from QCon London and taking the day off (another one of those "use 'em or lose 'em" days). I'll say more about QCon in a separate entry, but I wanted to mention something that came up there but which has been playing on my mind for a while anyway: the art of beautiful code and refactoring. I heard a number of people saying that you shouldn't touch a programming language if you can't (easily) refactor applications written using it. I've heard similar arguments before, which comes back to the IDEs available. I'd always taken this as more of a personal preference than any kind of Fundamental Law, and maybe that (personal preference) is how many people mean it. However, listening to some at QCon it's starting to border on the latter, which really started me thinking.

Maybe it's just me, but I've never consciously factored in the question "Can I refactor my code?" when choosing a language for a particular problem. I think that's because when I started using computers you only had batch processing (OK, when I really started we were using punch card and paper-tape, but let's gloss over that one). Time between submitting and compiling was typically half an hour, not including the 6 floors you had to descend (and subsequently ascend). So you tried to get your programs correct as quickly as possible, or developed very good calf muscles! Refactoring wasn't possible back then, but even if it was I don't think most of us would have bothered because of the batch system implications.

I try (and fail sometimes) to get the structure of my programs right at the start, so even today I typically don't make use of refactoring in my IDE. (Hey, it's only recently that I stopped using emacs as my de-facto editor, just to shut up others!) But this is where I came in: it's a personal thing. Your mileage may vary and whatever you need to do to help you get by is fine, surely? Why should it be the subject of yet another fierce industry battle? Are we really so short of things to do that we have to create these sorts of opportunities?

Oh well, time to take the day off.