Distributed software development is a globally accepted practice by large organizations for achieving significant cost savings in research and development. However when it comes to product quality, defect prevention and early detection has always been a challenge. Factors such as differences in language, coding standards and documentation styles across distributed teams can aggravate the situation. These issues, if not addressed, will manifest themselves as product defects leading to enormous costs in fixing at later phases of development. This in turn reduces the business partner or product owner's confidence. Thus, along with defining effective processes to address these issues, it becomes very important to ensure that the product quality expectations of various stakeholders are understood and mutually agreed upon. This paper summarizes our approach and practice in managing these issues while also delivering the expected product quality in our recent project.

Siemens has wide ranging experience in global development. Corporate development centers located in different geographical areas define their own processes to deal with the challenges in their respective location. It is to be understood that there is no "true globalization" in any business. From previous studies of managing offshore centers for product development, one expects that there is an amount of localization which comes in to play in projects when compared to the organization as a whole. This paper is an effort to describe how we achieve and sustain high performance effectively, in a globally distributed development, considering some of the main parameters of localization, where interaction among Germany, India, Hungary and China is involved. We describe some key practices that enable our offshore team to achieve and sustain high performance. We also show the value addition done by the offshore team along with awards, recognition, and ratings received that makes it a success story.

DoS attacks have least impact when detected and mitigated close to the attacks' source. This is more important for Distributed DoS (DDoS) attacks since they are difficult to mitigate at the victim without affecting service to legitimate flows. This is a challenging task since DDoS attack traffic may have relatively low flow rates and attack packets are indistinguishable from legitimate packets. Current source-end detection schemes such as MULTOPS and D-WARD are centralized and hence, are not easily deployable in multi-gateway stub networks with asymmetric traffic. Moreover, these systems require modifications to current routers for successful deployment. We present a scalable, distributed DDoS detection system that can be deployed in single- as well as multi-homed stub networks to detect DDoS attacks using TCP packets. The detection system can detect attacks with very low flow rates and in multi-gateway networks, even with significant asymmetric TCP flows. We evaluate the performance of our detection system using extensive packet level simulations under different attack scenarios. Our results show that with relatively less node state and processing, in networks with symmetric flows, our system can accurately detect attack flows that are one-third the intensity of an average flow in the network. In the case of multi-gateway networks, the detection system can detect all attacks for all rates of asymmetry when the attack rate is at least five times the average flow rate in the network. We extend the system to detect attacks aimed at multiple hosts in a subnet instead of a single host. Subnet attacks seem more diffused for detection schemes designed to detect host attacks. Hence, it is harder for these schemes to detect these attacks. Our subnet attack detection scheme can detect attacks that target hosts in large subnets (/21) and in the presence of non-attack traffic to other hosts in the subnet. Our packet level simulations show that, in single gateway networks, our scheme can detect attacks with an aggregate flow intensity equal to an average flow in the network in less than a minute. Using these simulations, we also show that our scheme detects attacks in networks with up to four gateways and when up to 50% of the flows are asymmetric.

Current wireless networks commonly consist of nodes with different capabilities (e.g., laptops and PDAs). Link quality such as link error rate and data transmit rate can differ widely. For efficient operation, the design of wireless networks must take into account such heterogeneity among nodes and wireless links. We present systematic approaches to overcome problems due to heterogeneous node capability and link quality in wireless networks. We first present a general framework called WISE (Wireless Integration Sublayer Extension) that abstracts specific details of low-level wireless communication technologies (e.g., modulation or backoff scheme). WISE provides a set of common primitives, based on which upper-level protocols can operate efficiently without knowing the underlying details. We also present a number of protocol extensions that employ the WISE framework to enhance the performance of specific upper-level protocols while hiding lower-level heterogeneity (e.g., link error rate). Our multihop WLAN architecture improves system performance by allowing client nodes to use multihop paths via other clients to reach an AP. Our geographic routing extension considers both location and link quality in the next hop selection, which leads to optimal paths under certain conditions. To address heterogeneity in node capability, we consider virtual routing backbone construction in two settings: cooperative and selfish. In the cooperative setting, we present a protocol extension that constructs an optimal backbone composed of a small number of high-capability nodes, which can be generalized to a more resilient backbone. For the selfish case, we use game theory and design an incentive-compatible backbone construction scheme. We evaluate our work from multiple perspectives. We use theoretical analysis to prove that our extensions lead to optimal solutions. We use simulations to experiment with our schemes in various scenarios and real-world implementation to understand the performance in practice. Our experiment results show that our schemes significantly out-perform existing schemes.

We describe a best-effort scheme to support diverse applications in low-bandwidth mobile networks. The improvements due to our scheme are motivated by the observation that different applications typically have different preferences for latency and recency of data, which are not considered by traditional caching techniques. In our scheme, clients express their preferences using voluntary profiles : application-specific targets for latency and recency of data. We describe a complete framework for incorporating profile-based decision making into the cache utilization, downloading, and scheduling decisions at a mobile base station. We analyze the performance of profiles using simulations. Our results show that even simple profiles are useful in discriminating the service received by different applications, and using profiles in both caching and scheduling decisions improves performance. Further, clients who give uncooperative profiles increase the latencies of their own applications, thus providing all clients an incentive to provide fair and accurate profiles.

This paper presents a case study in implementing a moderately complex, useful service on an active network platform. The active application is reliable multicast with congestion control; the platform comprises the Bowman Node Operating System and the Composable Active Network Elements (CANEs) Execution Environment. The importance of the work stems from the lessons it provides about the design and implementation of active platforms in general and Bowman/CANEs in particular. For example, our experience shows that timer-driven active node processing is as important as packet-arrival-driven processing. Thus, execution environments cannot focus exclusively on forwarding, but must also provide efficient timers and allow timer handlers the same capabilities as packet-driven computations. Other areas in which the implementation provides insight include service decomposition approaches for active applications and information sharing among service components.

We describe a scheme to improve application performance in low-bandwidth mobile networks. The improvements due to our scheme are motivated by the observation that different applications typically have different preferences for latency and recency of data. Traditional caching and scheduling schemes do not provide interfaces for clients to express these preferences. In our scheme, client preferences are expressed using voluntary profiles: application-specific targets for latency and recency. We describe a complete framework for incorporating profilebased decision making into the cache utilization, downloading, and scheduling decisions at a mobile base station. We analyze the performance of profiles using simulations, and compare profile-driven access to different profile-unaware schemes. Our experiments show three main results:(1) Even very simple profiles are enough to discriminate the service received by different applications, and are thus useful in supporting diverse application sets;(2) Compared to profile-unaware schemes, profileaware accesses improve resource utilization on the wireless downlink as well as the fixed network access link, thus giving service providers an incentive to support profiles; and (3) Clients who give uncooperative profiles increase the latencies of their own applications, thus providing all clients an incentive to provide fair and accurate profiles.

Server replication improves the ability of a service to handle a large number of clients. One of the important factors in the efficient utilization of replicated servers is the ability to direct client requests to the "best" server, according to some optimality criteria. In the anycasting communication paradigm, a sender communicates with a receiver chosen from an anycast group of equivalent receivers. As such, anycasting is well suited to the problem of directing clients to replicated servers. This paper examines the definition and support of the anycasting paradigm at the application-layer, providing a service that uses an anycast resolver to map an anycast domain name and a selection criteria into an IP address. By realizing anycasting in the application-layer, we achieve flexibility in the optimization criteria and ease the deployment of the service. As a case study, we examine the performance of our system for a key service: replicated Web servers. To this end, we develop an approach for estimating the response time that a client will experience when accessing given servers. Such information is maintained in the anycast resolver that clients query to obtain the identity of the server with the best estimated response time. Our performance collection technique combines server push with resolver probes to estimate the expected response time without undue overhead. Our experiments show that selecting a server using our architecture and estimation technique can improve the client response time by a factor of two over nearest server selection and by a factor of four over random server selection.

Hot spots are a major obstacle to achieving scalability in the Internet. At the application layer, hot spots are usually caused by either (a) high demand for some data or (b) high demand for a certain service. This high demand for data or services, is typically the result of a real-life event involving availability of new data or approaching deadlines; therefore, relief of these hot spots may improve quality of life. At the application layer, hot spot problems have traditionally been dealt with using some combination of (1) increasing capacity; (2) spreading the load over time, space, or both; and (3) changing the workload.We note that the classes of solutions stated above have been studied mostly in the context of applications using the following types of communication (a) one-to-many, (b) many-to-many, and (c) one-to-one. However, to the best of our knowledge there is no existing work on making applications using many-to-one communication scalable and efficient (existing solutions, such as web based submissions, simply use many independent one-to-one transfers). This corresponds to an important class of applications, whose examples include the various upload applications such as submission of income tax forms, conference paper submission, proposal submission through the NSF FastLane system, homework and project submissions in distance education, voting in digital democracy applications, voting in interactive television, and many more. Consequently, the main focus of this paper is scalable infrastructure design for relief of hot spots in wide-area upload applications .The main contributions of this paper are as follows. We state (a) a new problem, specifically, the many-to-one communication, or upload, problem as well as (b) the (currently) fundamental obstacles to building scalable wide-area upload applications. We also propose a general framework, which we term the Bistro system, for a class of solutions to the upload problem. In addition, we suggest a number of open research problems, within this framework, throughout the paper.

We introduce spatial clustering of multicast group members as a mechanism to scale wide-area multicast-based applications. To motivate the use of such structures, we present a clustering based re-keying scheme for secure multicast. Using amortized analysis, we show that the communication, processing, and storage costs for this scheme to distribute keys upon membership changes is of constant order. This improves upon the previously known best-case logarithmic bounds under the same assumptions. Next, we develop a clustering algorithm and a cluster formation protocol that can be built atop IP multicast to create clusters with properties required to implement the secure multicast scheme. To show the viability of such a clustering scheme on the Internet, we present results from implementing this clustering technique on a Internet map of over 280,000 IP routers. We describe how a small set (64) of multicast addresses can be used to eeciently implement intra-cluster communication in large groups (> 64K members). Finally, we present results from packet-level simulations of the clustering protocol to demonstrate protocol robustness under varying membership dynamics.

Bowman is an extensible platform for active networking: it layers active networking functionality in user space software over variants of the System V UNIX operating system. The packet processing path implemented in Bowman incorporates an efficient and flexible packet classification algorithm, supports multi-threaded per-flow processing, and utilizes real time processor scheduling to achieve deterministic performance in the user-space. In this paper we describe the design and implementation of Bowman; discuss the support that Bowman provides for implementing execution environments for active networking; discuss the network-level architecture of Bowman that can be used to implement virtual networks; and present performance data showing that Bowman is able to sustain 100 Mbps throughput while forwarding IP packets over fast Ethernets

Control-on-demand is a paradigm for network programmability at the network transport level. Prior work on active and programmable networking at this level either achieves flexibility by inserting significant software in the critical path of forwarding or achieves efficiency by sacrificing functionality and relegating programmability to connection management. In contrast, control-on-demand acts both in the control plane and in the data plane, still without adding software in the critical forwarding path. Rather than applying essential programs to every datagram, our approach is to apply the installed service logic asynchronously from data forwarding. This way we avoid essential processing in the critical forwarding path, applying the (user) installed service logic for service enhancement only. In this paper, we describe control-on-demand and how its service model provides sufficient richness to act in the data path. Set is restrictive enough to avoid the significant performance overhead of other in-data path approaches. The expressiveness of the programmable model is limited to observing and suggesting to the forwarding engine, but is never essential for correct processing, thus significantly reducing security and robustness concerns. Consequently, control-on-demand is efficient enough to make it viable for elementary services. Rather than replacing the interoperability layer, control-on-demand represents an evolution of router (switch) control functionality. As the required modification of router forwarding engines is insignificant, control-on-demand is viable in practice in the near future. These concepts have been prototyped as part of the Pronto Control Platform. In this paper, we describe our IPv6 router prototype implementation and discuss the application of control-on-demand on a number of interesting problems.

Control on demand is a paradigm for network programmability at the network transport level. Previous work on active and programmable networking at this level either achieves flexibility by inserting significant software in the critical forwarding path, or achieves efficiency by sacrificing functionality, relegating programmability to control plane connection management. In contrast, control-on-demand takes the middle ground, acting both in the control plane and in the data plane, still without adding software in the critical forwarding path. Rather than applying essential programs to every datagram our approach is to apply the installed programs asynchronously from data forwarding. This way we avoid essential processing in the critical forwarding path, applying the (user) installed service logic for service enhancement only. By retaining the current forwarding model, control-on-demand is consistent with current trends in router architectures with increasingly optimize and hardware enhanced forwarding engines. Applying the service logic asynchronously barely impacts router performance and robustness, making control-on-demand viable in practice in the near future. The main contribution of this paper is the control-on-demand paradigm, and the interface between application (service/user) programs and the forwarding engine. User programs execute in an execution environment, and use this interface to program the facilities of the forwarding engine, and to access the data-path. We describe our prototype control-on-demand IPv6 router, and discuss abstractions and mechanisms we have developed to support control-on-demand, most notably featherweight flows. We discuss two applications we have experimented with to demonstrate the potential of asynchronous enhancement controls.

In parallel with active networks research, eeorts have been underway to deene and standardize an architectural framework. The framework divides the function-ality of an active network node into two components: an Execution Environment (EE) deenes a programming interface that allows users to control the active network , a NodeOS deenes a set of basic functions to access and manage the resources of the active node. EEs use the abstractions provided by the NodeOS to build a virtual machine made available to users. Feedback from implementation eeorts is critical for reening the standards being developed. We are building an active network comprised of the CANEs execution environment and the Bowman NodeOS. Bowman is constructed by layering active-network-speciic operating system functionality on top of a standard host operating system. The host operating system provides low level mechanisms; Bowman provides a channel communication abstraction, an a-ow computation abstraction and a state-store memory abstraction, along with an extension mechanism to enrich the functionality. The CANEs EE provides a composition framework for active services based on customizing a generic underlying program by injecting code to run in speciic points called slots. This paper reports on our experience in implementing Bowman, instantiating CANEs on top of Bowman, and developing applications within CANEs.