Search

Overexploitation is a major threat to biodiversity and international trade in many species is regulated through the Convention on International Trade in Endangered Species of Wild Fauna and Flora (CITES). However, there is no established method to systematically determine which species are most at risk from international trade to inform potential trade measures under CITES. Here, we develop a mechanism using the International Union for Conservation of Nature's Red List of Threatened Species to identify species that are likely to be threatened by international trade. Of 2,211 such species, CITES includes 59% (1,307 species), leaving two-fifths overlooked and in potential need of international trade regulation. Our results can inform deliberations on potential proposals to revise trade measures for species at CITES Conference of the Parties meetings. We also show that, for taxa with biological resource use documented as a threat, the number of species threatened by local and national use is four times greater than species likely threatened by international trade. To effectively address the overexploitation of species, interventions focused on achieving sustainability in international trade need to be complemented by commensurate measures to ensure that local and national use and trade of wildlife is well-regulated and sustainable.

Governments have committed to conserving ?17% of terrestrial and ?10% of marine environments globally, especially “areas of particular importance for biodiversity” through “ecologically representative” Protected Area (PA) systems or other “area-based conservation measures”, while individual countries have committed to conserve 3–50% of their land area. We estimate that PAs currently cover 14.6% of terrestrial and 2.8% of marine extent, but 59–68% of ecoregions, 77–78% of important sites for biodiversity, and 57% of 25,380 species have inadequate coverage. The existing 19.7 million km2 terrestrial PA network needs only 3.3 million km2 to be added to achieve 17% terrestrial coverage. However, it would require nearly doubling to achieve, cost-efficiently, coverage targets for all countries, ecoregions, important sites, and species. Poorer countries have the largest relative shortfalls. Such extensive and rapid expansion of formal PAs is unlikely to be achievable. Greater focus is therefore needed on alternative approaches, including community- and privately managed sites and other effective area-based conservation measures.

Component-based software structuring principles are now commonplace at the application level; but componentization is far less established when it comes to building low-level systems software. Although there have been pioneering efforts in applying componentization to systems-building, these efforts have tended to target specific application domains (e.g., embedded systems, operating systems, communications systems, programmable networking environments, or middleware platforms). They also tend to be targeted at specific deployment environments (e.g., standard personal computer (PC) environments, network processors, or microcontrollers). The disadvantage of this narrow targeting is that it fails to maximize the genericity and abstraction potential of the component approach. In this article, we argue for the benefits and feasibility of a generic yet tailorable approach to component-based systems-building that offers a uniform programming model that is applicable in a wide range of systems-oriented target domains and deployment environments. The component model, called OpenCom, is supported by a reflective runtime architecture that is itself built from components. After describing OpenCom and evaluating its performance and overhead characteristics, we present and evaluate two case studies of systems we have built using OpenCom technology, thus illustrating its benefits and its general applicability.

Component-based software structuring principles are now commonplace at the application level; but componentization is far less established when it comes to building low-level systems software. Although there have been pioneering efforts in applying componentization to systems-building, these efforts have tended to target specific application domains (e.g., embedded systems, operating systems, communications systems, programmable networking environments, or middleware platforms). They also tend to be targeted at specific deployment environments (e.g., standard personal computer (PC) environments, network processors, or microcontrollers). The disadvantage of this narrow targeting is that it fails to maximize the genericity and abstraction potential of the component approach. In this article, we argue for the benefits and feasibility of a generic yet tailorable approach to component-based systems-building that offers a uniform programming model that is applicable in a wide range of systems-oriented target domains and deployment environments. The component model, called OpenCom, is supported by a reflective runtime architecture that is itself built from components. After describing OpenCom and evaluating its performance and overhead characteristics, we present and evaluate two case studies of systems we have built using OpenCom technology, thus illustrating its benefits and its general applicability.

The need for dynamic reconfiguration is a complicating factor in the design of dependable systems, as it demands from software architects both rigour and planning. Although recent research has shown that systematic and integrated "specification-to-deployment" environments are promising approaches to architecting dependable systems, few proposals have yet considered dynamic reconfiguration, and then only in specific situations. In this paper, we propose a generic approach to supporting dynamic reconfiguration in dependable systems. The proposed approach is built on our view that dynamic reconfiguration in such systems needs to be causally connected at runtime to a corresponding high-level software architecture specification. In more detail, we propose two causally-connected models: an architecture-level model and a runtime-level model. Dynamic reconfiguration can be applied either through an architecture specification at the architecture level, or through reconfiguration primitives at the runtime level. Both foreseen and unforeseen reconfigurations are supported. We discuss the issues involved in handling these two types of reconfiguration at both levels and the mapping between them. We also discuss an implementation of our approach that evaluates its main benefits.

Recent research has recognised the potential of coupling ADLs with underlying runtime environments to support systematic and integrated "specification-to-deployment" architectures. However, while some promising results have been obtained, much of this research has not considered the crucial issue of causally-connected dynamic reconfiguration and has considered only domain-specific areas. In this paper we discuss a specification-to-deployment architecture called Plastik that employs an extended general-purpose ADL and is underpinned by an efficient runtime that is suited both for high-level application development and low-level systems development (e.g. embedded systems). Runtime reconfiguration is supported both at the ADL level and at the runtime level, and both programmed reconfiguration and adhoc reconfiguration are supported. The paper focuses on the mapping of ADL-level specifications to runtime instantiations and on the necessary runtime support for causally-connected dynamic reconfiguration.

We propose a meta-framework called 'Plastik' which i) supports the specification and creation of runtime component-framework-based software systems and ii) facilitates and manages the runtime reconfiguration of such systems while ensuring integrity across changes. The meta-framework is fundamentally an integration of an architecture description language (an extension of ACME/Armani) and a reflective component runtime (OpenCOM). Plastik-generated component frameworks can be dynamically reconfigured either through programmed changes (which are foreseen at design time and specified at the ADL level); or through ad-hoc changes (which are unforeseen at design time but which are nevertheless constrained by invariants specified at the ADL level). We provide in the paper a case study that illustrates the operation and benefits of Plastik.

Recently developed networked services have been demanding architectures that accommodate an increasingly diverse range of applications requirements (e.g. mobility, multicast, QoS), as well as system requirements (e.g. specialized processing hardware). This is particularly crucial for architectures of network systems where the lack of extensibility and interoperability has been a constant struggle, hindering the provision of novel services. It is also clear that to achieve such flexibility these systems must support extensibility and re-configurability of the base functionality subsequent to the initial deployment. In this paper we present a component model that addresses these concerns. We also discuss the application of the component model in network processor-based programmable networking environments and discuss how our approach can offer a more deployable, flexible and extensible networking infrastructure.

OpenCOM v2 is our experimental language-independent component-based systems-building technology. OpenCOM offers more than merely a component-based programming model. First, it is a runtime component model and supports dynamic runtime reconfiguration of systems (i.e. one can load, unload, bind, and rebind components at runtime). Second, it explicitly supports the deployment of the model in a wide range of `deployment environments' (e.g. operating systems, PDAs, embedded devices, network processors). Third, it allows the particularities of different deployment environments to be selectively hidden from/ made visible to the OpenCOM programmer without inherent performance overhead.

Network processors (NPs) are emerging as a cost effective network element technology that can be more readily updated and evolved than custom hardware or ASIC-based designs. Moreover, NPs promise support for run-time reconfiguration of low-level networking software. However, it is notoriously difficult to develop software for NPs because of their complex design, architectural heterogeneity, and demanding performance constraints. In this paper we present a runtime component-based approach to programming NPs. The approach promotes conceptual uniformity and design portability across a wide variety of NP types while simultaneously exploiting hardware assists that are specific to individual NPs. To show how our approach can be applied in a wide range of types of NPs we characterise the design space of NPs and demonstrate the applicability of our concepts to the various classes identified. Then, as a detailed case study, we focus on programming the Intel IXP1200 NP. This demonstrates that our approach can be effectively applied, e.g. in terms of performance, in a demanding real-world NP environment.

Network Processors (NPs) are emerging as a cost effective network element technology that can be more readily updated and evolved than custom hardware or ASIC-based designs. Moreover, NPs promise support for run-time reconfiguration of low-level networking software. However, it is notoriously difficult to develop software for NPs because of their complex design, architectural heterogeneity, and demanding performance constraints. In this paper we present a run-time component-based approach to programming NPs. The approach promotes conceptual uniformity and design portability across a wide variety of NP types while simultaneously exploiting hardware assists that are specific to individual NPs. To show how our approach can be applied in a wide range of types of NPs we characterise the design space of NPs and demonstrate the applicability of our concepts to the various classes identified. Then, as a detailed case study, we focus on programming the Intel IXP1200 NP. This demonstrates that our approach can be effectively applied, e.g. in terms of performance, in a demanding real-world NP environment.

Recently developed net-worked services have been demanding architectures that accommodate an increasingly diverse range of applications requirements (e.g. mobility, multicast, QoS), as well as system requirements (e.g. specialized processing hardware). This is particularly crucial for architectures of network systems where the lack of extensibility and interoperability has been a constant struggle, hindering the provision of novel services. It is also clear that to achieve such flexibility these systems must support extensibility and re-configurability of the base functionality subsequent to the initial deployment. In this paper we present a component model that addresses these concerns. We also discuss the application of the component model in net-work processor-based programmable networking environments and discuss how our approach can offer a more deployable, flexible and extensible networking infrastructure.

While there has already been significant research in support of openness and programmability in networks, this paper argues that there remains a need for generic support for the integrated development, deployment and management of programmable networking software. We further argue that this support should explicitly address the management of run-time reconfiguration of systems, and should be independent of any particular programming paradigm (e.g. active networking or open signaling), programming language, or hardware/ operating system platform. In line with these aims, we outline an approach to the structuring of programmable networking software in terms of a ubiquitously applied software component model that can accommodate all levels of a programmable networking system from low-level system support, to in-band packet handling, to active networking execution environments to signaling and coordination.

In the past few years significant progress has been made in the design and implementation of reflective middleware platforms—i.e., platforms that, through reflection, can be flexibly configured, and run-time adapted/ reconfigured, especially in terms of non-functional properties like timeliness, resourcing, transactional behaviour, and security. Recently, we have initiated a project that investigates applying our previous reflective middleware work to the demanding and novel—for reflective middleware—area of programmable networking environments. In general, these environments offer the capability to inject code into network nodes so that their forwarding behaviour can be tailored on behalf of individual organisations, applications, or users. The fact that programmable networking software operates in a complex, Multilanguage and OS, environment and has strong requirements for dynamic deployment, 24x7 operation, managed software evolution, high performance, QoS/ resource management, adaptivity and security, makes it an ideal testing ground for the reflective middleware approach [Schmid,02]. In this position paper we outline salient characteristics of programmable networking environments and discuss how our particular reflective middleware approach, which employs a component-based architecture as one of its central tenets, offers the potential for more deployable, more flexible, and more evolvable programmable networking infrastructures. The remainder of the paper is structured as follows. First, §2 briefly surveys our previous work on reflective middleware, and §3 briefly characterises programmable networking environments. Next, §4 outlines our approach, and §5 discusses our progress to date. Finally, §6 analyses related work (in programmable networking, in component-based systems, and in reflective middleware), and §7 presents our conclusions and indicates areas of planned future work.

Recently developed net worked services have been demanding architectures that accommodate an increasingly diverse range of applications requirements (e.g. mobility, multicast, QoS), as well as system requirements (e.g. exploiting specialized processing hardware). This is particularly crucial for architectures of network systems where the lack of extensibility and interoperability has been a constant struggle, hindering the Provision of novel services. It is also clear that to achieve such flexibility these systems must support extensibility and re-configurability of the base functionality subsequent to the initial deployment. Based on our experience with middleware platforms, we argue that re-configurability of network services is best implemented by means of reflection. In this position paper we present component-based approach to developing flexible networked systems, especially targeted at the Intel IXP 1200 programmable networking environment and discuss how our approach can offer a more deployable, flexible and extensible networking infrastructure. We show the viability of our component model to re-configure services on the Intel 1XP1200 platform. An application scenario is presented to validate our approach to enable re-configuration of’ services across different layers of an IXP1200-based router platform.