Simon Dobson (Posts about middleware)

Workshop on naturally-inspired service ecosystems

Simon Dobson — Tue, 19 Jun 2012 11:10:59 GMT

The Sapere project (of which I'm a member) is running a workshop at SASO 2012 in Lyons on new ways to design service ecosystems. Emerging distributed computing scenarios (mobile, pervasive, and social) are characterised by intrinsic openness, decentralisation, and dynamics. According, the effective deployment and execution of distributed services and applications calls for open service frameworks promoting situated and self-adaptive behaviours, and supporting diversity in services and long-term evolvability. This suggests adopting nature-inspired and/or socially-inspired approaches, in which services are modelled and deployed as autonomous individuals in an ecosystem of other services, data sources, and pervasive devices. Accordingly, the self-organizing interactions patterns among components and the resulting emerging dynamics of the system, as those of natural systems or of social systems, can inherently exhibit effective properties of self-adaptivity and evolvability. Although many initiatives (like those named upon digital/business service ecosystems) recognise that the complexity of modern service systems is comparable to that of natural ecosystems, the idea that nature – other than a mean to metaphorically characterise their complexity – can become the source of inspiration for their actual modelling and implementation is only starting being metabolised. The goal of this workshop is to bring together researchers and practitioners, with the aims of unfolding the many challenges related to the modelling, design and implementation of adaptive service ecosystems in natural and social terms, and identifying promising approaches and solutions. Topics of interest include, but are not limited to:

Software architectures for emergent distributed systems.
Bio-inspired self-organising patterns design patterns.
Coordination models and languages.
Middleware platforms
Dynamic services composition.
Adaptive coordination models and patterns
Self-organisation and coordination
Coordination in systems of feedback loops
Middleware for adaptive coordination
Multiagent systems
Methodologies for adaptive and self-organising system engineering

All accepted papers will be published by IEEE Xplore following the workshop. Submission deadline is 4 July 2012. For more details please see the workshop web site. UPDATE: Fixed typo in the submission deadline

The middleware doughnut

Simon Dobson — Fri, 16 Dec 2011 11:09:49 GMT

Where has the "middle" of middleware gone? This week I attended a couple of the workshops at the Middleware conference, the main venue for the research community working on systems integration middleware. In particular I was an invited speaker at the Future of Middleware (FoME) workshop, which attracted a great bunch of people with views on where the field is going. Listening to all the talks, one of the things that jumped out was the diversity of concerns people were expressing. Those working at enterprise level were concerned with scaling-out systems to millions of users using cloud computing; at the other extreme were sensor networks people like me, worried about programming low-powered sensor motes with at least a semblance of programming language support and software engineering process. That a group of people with this spread of interests can find useful things to talk about together says a lot about how broad a term middleware actually is. But if we compare this to years past, it was also clear that the concerns asymmetrically affected the different groups. There were very few issues that really commanded broad interest. This led me to wonder: where has the "middle" gone from "middleware"? In the 1990s, middleware people (including me) were working with CORBA and the like. These systems were intended for broad application in integrating client and server components into single systems. In CORBA's case this involved designing object-oriented domain models that could then be implemented using any chosen programming language and support interactions seamlessly, regardless of implementation or distribution. CORBA provided (and indeed provides) a lot of supporting infrastructure, including dedicated wire protocols, a shared type system and object model, higher-level services, binding, call models and other groovy toys. It achieved enormous penetration into markets that value long-term interoperability and evolution, such as financial services. It also influenced a whole range of subsequent developments, including web services and service-oriented architectures that are, to some extent, defined by their similarity to, or differences with, CORBA. (For a discussion of these differences see Baker and Dobson. Comparing service-oriented and distributed object architectures. LNCS 3760. 2005.) As is pretty much apparent from this, CORBA sits resolutely in the middle of middleware. It is intended to integrate disparate systems and allow them to work together, and evolve somewhat separately, while managing the complexity of the overall architecture. It tries to avoid the problem, identified by Bertrand Meyer, that large systems exhibit non-linear behaviour in which the cost of making any change to them is proportional, not to the size of the change being made, but to the size of the system being changed. It doesn't completely succeed in this, of course -- no system does -- but it provides a common centre around which to organise largely independent components. Another way of looking at CORBA is less flattering: that it was inherently compromised by conflicting, and in large part irreconcilable, goals. It was reasonably performant, but by no stretch of the imagination high-performance given the overheads of a complex and general-purpose wire format. It was reasonably portable, as long as one accepted the limits imposed by the single type system: no first-class functions or mobile code, for example. It was reasonably easy to port and to support new languages, but every new language binding did require considerable ingenuity both in terms of technical design and standardisation of interfaces. Sitting in the middle, in other words, was tricky and uncomfortable. The causes of, and justifications for, these compromises aren't hard to find: what else can one do if one is trying to support the whole range of applications? Each piece of middleware sits at a particular point in the design space, trading-off performance against generality for example, or advanced typing against making bindings awkward or impossible for some languages. And it's this generality that seemed to be missing from discussions of the future of middleware: no-one intends to support this range any more. Instead we're seeing a division of the design space in which different application communities focus on one or two design dimensions that are undoubtedly the most important -- and largely forget the rest. For Twitter, for example, the main design goal is lightweight interaction at clients so that Twitter clients are easy to writ. They have no concern whatever with typing or reliability: if tweets are lost, who cares? For the web services community -- perhaps closest to the "spirit of the middle" -- the issues are extensibility and use of standards, with no concern for protocols, performance or end-point complexity. It's fairly easy to see that these design issues are simply too diverse to be spanned by a single middleware platform. I don't think this necessarily spells the death of integrating middleware -- and that's just as well, given that we still have to integrate these systems despite their increasing heterogeneity. What it does do, though, is change the locus of innovation away from ever-larger, more complex and more general platforms towards more specialised platforms that can integrate as far as needed -- and no further, so as not to over-burden applications or developers. Several speakers talked about using component-based approaches to build platforms as well as applications. In our talk we discussed similar ideas, removing the a priori assumptions underlying middleware platforms and focusing instead on how to optimise what hits the metal. (Dearle and Dobson. Mission-oriented middleware for sensor-driven scientific systems. Journal of Internet Services and Applications. 2011.) This will give rise to a whole range of further challenges -- how do we guarantee the right features are available? How do we add (and remove) features on the fly? How do we find the features we need? -- that are radically different from those encountered for CORBA and similar systems. But the result will (hopefully) be to improve our ability to create, manage and evolve ever more sophisticated combinations of applications and services, and make it easier to roll-out and scale-out the next generation of applications and scientific experiments.

Call for papers: MidSens'11

Simon Dobson — Mon, 06 Jun 2011 09:30:18 GMT

Papers are invited on topics in middleware, tools and services for sensor and other embedded systems.

Sixth International Workshop on Middleware Tools, Services and Run-time Support for Networked Embedded Systems (MidSens’11)

Co-located with Middleware 2011 (December 12th - December 16th, 2011), Lisbon, Portugal

The aim of MidSens’11 is to stimulate research in the specific domain of middleware for networked embedded systems. This year’s focus is on sensor networks and robotics control – a broader focus than the previous editions – since we believe that the extended scope will result in complementary and synergetic submissions from researchers working in both niches. Along with the ‘core’ topic of middleware architectures, services and tool support, MidSens’11 will also seek quality papers describing novel programming languages, run-time support and relevant experience reports. As with previous editions of this workshop, MidSens’11 will investigate how middleware support can relieve developers from low-level, platform specific concerns, while enabling optimal exploitation of available resources. We hope that you will be able to join us in Lisbon on December 12th 2011. Middleware for networked embedded systems such as sensor networks and robotics is a critical research domain which addresses key challenges that application developers are facing today. The five previous editions of this workshop (MidSens'06, MidSens'07, MidSens'08, MidSens'09 and MidSens'10) attracted researchers from Europe, Asia, and the United States. The MidSens workshop series has served to trigger and guide research efforts to create an integrated middleware vision, which is required to handle the challenges inherent in developing, deploying and managing complex networked embedded applications in an efficient way. The workshop seeks papers in, but not limited to:

Middleware Tools and Architectures:
- Architectures for networked embedded systems.
- Novel programming abstractions.
- Lightweight agent middleware for embedded systems.
- Testing and simulation tools.
- Fault identification, diagnosis and repair.
Middleware services:
- Location tracking, localization, and synchronization.
- Support for real-time and safety-critical systems.
- Data management, aggregation and filtering.
- Energy-aware middleware mechanisms.
- Fault tolerance, reliability and quality of service.
- Privacy and security services.
- Virtualization, sharing and trading of resources.
Run-time Support:
- Overlay and topology creation, maintenance and management.
- Resource/Service discovery and management.
- Support for reconfiguration and adaptation.
- Effective naming and addressing schemes.
- Support for modeling and enacting safe software reconfiguration.
Management and Experiences:
- Managing heterogeneity and network dynamism.
- Integration of embedded systems with web services.
- Experience and evaluation of middleware platforms.
- Support for the unification of various networked embedded platforms.
- Shared infrastructure embedded systems.

Submission

Submitted papers must be original work in English without substantial overlap with papers that have been published or that are simultaneously submitted to a journal or conference with proceedings. Submissions must not exceed 6 pages, must strictly follow the ACM conference proceedings format, and must be submitted in PDF format. All workshop papers will be uploaded to the ACM Digital Library. Full instructions can be found here.

Important dates

Paper submission: 15 August 2011
Review notification: 29 September 2011
Camera-ready: 10 October 2011
Registration: 7 October 2011

Programme committee

Gordon Blair, Lancaster University, UK
Vinny Cahill, Trinity College, Ireland
Paolo Costa, Imperial College London, UK
Simon Dobson, University of St. Andrews, UK
Michael Fisher, University of Liverpool, UK
Wen Hu, CSIRO, Australia
Joerg Kaiser, University of Magdeburg, Germany
Torsten Kroeger, Stanford University, USA
Ajay Kshemkalyani, University of Illinois at Chicago
Kristof Van Laerhoven, Technical University of Darmstadt
Sam Michiels, K.U.Leuven, Belgium
Nader Mohamed, United Arab Emirates University, UAE
Luca Mottola, SICS, Sweden
Mirco Musolesi, University of Birmingham, UK
Dennis Pfisterer, University of Lübeck, Germany
Kay Römer, University of Lübeck, Germany
Coen De Roover, Vrije Universiteit Brussel, Belgium
Romain Rouvoy, INRIA Lille, France
Jo Ueyama, Universidade de Sao Paulo, Brazil