On the roles of the northeast cold surge, the Borneo vortex, the Madden-Julian Oscillation, and the Indian Ocean Dipole during the extreme 2006/2007 flood in southern Peninsular Malaysia

The mid-December 2006 to late January 2007 flood in southern Peninsular Malaysia was the worst flood in a century and was caused by three extreme precipitation episodes. These extreme precipitation events were mainly associated with strong northeasterly winds over the South China Sea. In all cases, the northeasterlies penetrated anomalously far south and followed almost a straight trajectory. The elevated terrain over Sumatra and southern Peninsular Malaysia caused low-level convergence. The strong easterly winds near Java associated with the Rossby wave-type response to Madden-Julian Oscillation (MJO) inhibited the counter-clockwise turning of the northeasterlies and the formation of the Borneo vortex, which, in turn, enhanced the low-level convergence over the region. The abrupt termination of the Indian Ocean Dipole (IOD) in December 2006 played a secondary role as warmer equatorial Indian Ocean helped in the MJO formation.

Contesting Forests and Power : Dispute, Violence and Negotiations

"Contesting Forests and Power; Dispute, Violence and Negotiations in Central Java" is an ethnographic analysis of an ongoing forest land dispute and its negotiations in an upland forest village in the district of Wonosobo, Central Java. Rather than focusing only on the village site, this ethnography of global connections explores the inequalities of power in different negotiation arenas and how these power relations have had an effect on the dispute and efforts made to settle it. Today, national and transnational connections have an effect on how land disputes develop. This study argues that different cosmological and cultural orientations influence how the dispute and its negotiations have evolved. It draws its theoretical framework from legal and political anthropology by looking at the position of law in society, exploring state formation processes and issues of power. The dispute over state forest land is about a struggle over sovereignty which involves violence on the parts of different parties who maintain that they have a legitimate right to the state forest land. This anthropological study argues that this dispute and its negotiations reflect the plurality of laws in Java and Indonesia in a complex way. It shows that this dispute over forests and land in Java has deep historical roots that were revealed as the conflict emerged. Understanding land disputes in Java is important because of the enormous potential for conflicts over land and other natural resources throughout Indonesia. After the fall of President Suharto in 1998, disputes over access to state forest land emerged as a problem all over upland Java. As the New Order came to an end, forest cover on state forest lands in the Wonosobo district was largely destroyed. Disputes over access to land and forests took another turn after the decentralization effort in 1999, suggesting that decentralization does not necessarily contribute to the protection of forests. The dispute examined here is not unique, but, rather, this study attempts to shed light on forest-related conflicts all around upland Indonesia and on the ways in which differential power relations are reflected in these conflicts and the negotiation processes meant to resolve them.

Stand growth and management scenarios for Paraserianthes falcataria smallholder plantations in Indonesia

Paraserianthes falcataria is a very fast growing, light wood tree species, that has recently gained wide interest in Indonesia for industrial wood processing. At the moment the P. falcataria plantations managed by smallholders are lacking predefined management programmes for commercial wood production. The general objective of this study was to model the growth and yield of Paraserianthes falcataria stands managed by smallholders in Ciamis, West Java, Indonesia and to develop management scenarios for different production objectives. In total 106 circular sample plots with over 2300 P. falcataria trees were assessed on smallholder plantation inventory. In addition, information on market prices of P. falcataria wood was collected through rapid appraisals among industries. A tree growth model based on Chapman-Richards function was developed on three different site qualities and the stand management scenarios were developed under three management objectives: (1) low initial stand density with low intensity stand management, (2) high initial stand density with medium intensity of intervention, (3) high initial stand density and strong intensity of silvicultural interventions, repeated more than once. In general, the 9 recommended scenarios have rotation ages varying from 4 to 12 years, planting densities from 4x4 meters (625 trees ha-1) to 3x2 meters (1666 trees ha-1) and thinnings at intensities of removing 30 to 60 % of the standing trees. The highest annual income would be generated on high-quality with a scenario with initial planting density 3x2 m (1666 trees ha-1) one thinning at intensity of removing 55 % of the standing trees at the age of 2 years and clear cut at the age of 4 years.

RPS: Repeats in Protein Sequences

Repeats are two or more contiguous segments of amino acid residues that are believed to have arisen as a result of intragenic duplication, recombination and mutation events. These repeats can be utilized for protein structure prediction and can provide insights into the protein evolution and phylogenetic relationship. Therefore, to aid structural biologists and phylogeneticists in their research, a computing resource (a web server and a database), Repeats in Protein Sequences (RPS), has been created. Using RPS, users can obtain useful information regarding identical, similar and distant repeats (of varying lengths) in protein sequences. In addition, users can check the frequency of occurrence of the repeats in sequence databases such as the Genome Database, PIR and SWISS-PROT and among the protein sequences available in the Protein Data Bank archive. Furthermore, users can view the three-dimensional structure of the repeats using the Java visualization plug-in Jmol. The proposed computing resource can be accessed over the World Wide Web at http://bioserver1.physics.iisc.ernet.in/rps/.

Bandwidth management in a hybrid wireless network: For superstore applications

The integration of different wireless networks, such as GSM and WiFi, as a two-tier hybrid wireless network is more popular and economical. Efficient bandwidth management, call admission control strategies and mobility management are important issues in supporting multiple types of services with different bandwidth requirements in hybrid networks. In particular, bandwidth is a critical commodity because of the type of transactions supported by these hybrid networks, which may have varying bandwidth and time requirements. In this paper, we consider such a problem in a hybrid wireless network installed in a superstore environment and design a bandwidth management algorithm based on the priority level, classification of the incoming transactions. Our scheme uses a downlink transaction scheduling algorithm, which decides how to schedule the outgoing transactions based on their priority level with efficient use of available bandwidth. The transaction scheduling algorithm is used to maximize the number of transaction-executions. The proposed scheme is simulated in a superstore environment with multi Rooms. The performance results describe that the proposed scheme can considerably improve the bandwidth utilization by reducing transaction blocking and accommodating more essential transactions at the peak time of the business.

Null Dereference Verification via Over-approximated Weakest Pre-conditions Analysis

Null dereferences are a bane of programming in languages such as Java. In this paper we propose a sound, demand-driven, inter-procedurally context-sensitive dataflow analysis technique to verify a given dereference as safe or potentially unsafe. Our analysis uses an abstract lattice of formulas to find a pre-condition at the entry of the program such that a null-dereference can occur only if the initial state of the program satisfies this pre-condition. We use a simplified domain of formulas, abstracting out integer arithmetic, as well as unbounded access paths due to recursive data structures. For the sake of precision we model aliasing relationships explicitly in our abstract lattice, enable strong updates, and use a limited notion of path sensitivity. For the sake of scalability we prune formulas continually as they get propagated, reducing to true conjuncts that are less likely to be useful in validating or invalidating the formula. We have implemented our approach, and present an evaluation of it on a set of ten real Java programs. Our results show that the set of design features we have incorporated enable the analysis to (a) explore long, inter-procedural paths to verify each dereference, with (b) reasonable accuracy, and (c) very quick response time per dereference, making it suitable for use in desktop development environments.

Fragment Finder 2.0: a computing server to identify structurally similar fragments

Fragment Finder 2.0 is a web-based interactive computing server which can be used to retrieve structurally similar protein fragments from 25 and 90% nonredundant data sets. The computing server identifies structurally similar fragments using the protein backbone C alpha angles. In addition, the identified fragments can be superimposed using either of the two structural superposition programs, STAMP and PROFIT, provided in the server. The freely available Java plug-in Jmol has been interfaced with the server for the visualization of the query and superposed fragments. The server is the updated version of a previously developed search engine and employs an in-house-developed fast pattern matching algorithm. This server can be accessed freely over the World Wide Web through the URL http://cluster.physics.iisc.ernet.in/ff/.

Reuse, recycle to de-bloat software

Most Java programmers would agree that Java is a language that promotes a philosophy of “create and go forth”. By design, temporary objects are meant to be created on the heap, possibly used and then abandoned to be collected by the garbage collector. Excessive generation of temporary objects is termed “object churn” and is a form of software bloat that often leads to performance and memory problems. To mitigate this problem, many compiler optimizations aim at identifying objects that may be allocated on the stack. However, most such optimizations miss large opportunities for memory reuse when dealing with objects inside loops or when dealing with container objects. In this paper, we describe a novel algorithm that detects bloat caused by the creation of temporary container and String objects within a loop. Our analysis determines which objects created within a loop can be reused. Then we describe a source-to-source transformation that efficiently reuses such objects. Empirical evaluation indicates that our solution can reduce upto 40% of temporary object allocations in large programs, resulting in a performance improvement that can be as high as a 20% reduction in the run time, specifically when a program has a high churn rate or when the program is memory intensive and needs to run the GC often.

A dynamic bandwidth allocation scheme for interactive multimedia applications over cellular networks

Cellular networks played key role in enabling high level of bandwidth for users by employing traditional methods such as guaranteed QoS based on application category at radio access stratum level for various classes of QoSs. Also, the newer multimode phones (e.g., phones that support LTE (Long Term Evolution standard), UMTS, GSM, WIFI all at once) are capable to use multiple access methods simulta- neously and can perform seamless handover among various supported technologies to remain connected. With various types of applications (including interactive ones) running on these devices, which in turn have different QoS requirements, this work discusses as how QoS (measured in terms of user level response time, delay, jitter and transmission rate) can be achieved for interactive applications using dynamic bandwidth allocation schemes over cellular networks. In this work, we propose a dynamic bandwidth allocation scheme for interactive multimedia applications with/without background load in the cellular networks. The system has been simulated for many application types running in parallel and it has been observed that if interactive applications are to be provided with decent response time, a periodic overhauling of policy at admission control has to be done by taking into account history, criticality of applications. The results demonstrate that interactive appli- cations can be provided with good service if policy database at admission control is reviewed dynamically.

Scalable flow-sensitive pointer analysis for fava with strong updates

The ability to perform strong updates is the main contributor to the precision of flow-sensitive pointer analysis algorithms. Traditional flow-sensitive pointer analyses cannot strongly update pointers residing in the heap. This is a severe restriction for Java programs. In this paper, we propose a new flow-sensitive pointer analysis algorithm for Java that can perform strong updates on heap-based pointers effectively. Instead of points-to graphs, we represent our points-to information as maps from access paths to sets of abstract objects. We have implemented our analysis and run it on several large Java benchmarks. The results show considerable improvement in precision over the points-to graph based flow-insensitive and flow-sensitive analyses, with reasonable running time.

A prototype of a first-responder indoor localization system

In this paper we present an approach to build a prototype. model of a first-responder localization system intended for disaster relief operations. This system is useful to monitor and track the positions of the first-responders in an indoor environment, where GPS is not available. Each member of the first responder team is equipped with two zero-velocity-update-aided inertial navigation systems, one on each foot, a camera mounted on a helmet, and a processing platform strapped around the waist of the first responder, which fuses the data from the different sensors. The fusion algorithm runs real-time on the processing platform. The video is also processed using the DSP core of the computing machine. The processed data consisting of position, velocity, heading information along with video streams is transmitted to the command and control system via a local infrastructure WiFi network. A centralized cooperative localization algorithm, utilizing the information from Ultra Wideband based inter-agent ranging devices combined with the position estimates and uncertainties of each first responder, has also been implemented.

Discovering Math APIs by Mining Unit Tests

In today's API-rich world, programmer productivity depends heavily on the programmer's ability to discover the required APIs. In this paper, we present a technique and tool, called MATHFINDER, to discover APIs for mathematical computations by mining unit tests of API methods. Given a math expression, MATHFINDER synthesizes pseudo-code to compute the expression by mapping its subexpressions to API method calls. For each subexpression, MATHFINDER searches for a method such that there is a mapping between method inputs and variables of the subexpression. The subexpression, when evaluated on the test inputs of the method under this mapping, should produce results that match the method output on a large number of tests. We implemented MATHFINDER as an Eclipse plugin for discovery of third-party Java APIs and performed a user study to evaluate its effectiveness. In the study, the use of MATHFINDER resulted in a 2x improvement in programmer productivity. In 96% of the subexpressions queried for in the study, MATHFINDER retrieved the desired API methods as the top-most result. The top-most pseudo-code snippet to implement the entire expression was correct in 93% of the cases. Since the number of methods and unit tests to mine could be large in practice, we also implement MATHFINDER in a MapReduce framework and evaluate its scalability and response time.

Two techniques to improve the precision of a demand-driven null-dereference verification approach

The problem addressed in this paper is sound, scalable, demand-driven null-dereference verification for Java programs. Our approach consists conceptually of a base analysis, plus two major extensions for enhanced precision. The base analysis is a dataflow analysis wherein we propagate formulas in the backward direction from a given dereference, and compute a necessary condition at the entry of the program for the dereference to be potentially unsafe. The extensions are motivated by the presence of certain ``difficult'' constructs in real programs, e.g., virtual calls with too many candidate targets, and library method calls, which happen to need excessive analysis time to be analyzed fully. The base analysis is hence configured to skip such a difficult construct when it is encountered by dropping all information that has been tracked so far that could potentially be affected by the construct. Our extensions are essentially more precise ways to account for the effect of these constructs on information that is being tracked, without requiring full analysis of these constructs. The first extension is a novel scheme to transmit formulas along certain kinds of def-use edges, while the second extension is based on using manually constructed backward-direction summary functions of library methods. We have implemented our approach, and applied it on a set of real-life benchmarks. The base analysis is on average able to declare about 84% of dereferences in each benchmark as safe, while the two extensions push this number up to 91%. (C) 2014 Elsevier B.V. All rights reserved.

Multithreaded Test Synthesis for Deadlock Detection

Designing and implementing thread-safe multithreaded libraries can be a daunting task as developers of these libraries need to ensure that their implementations are free from concurrency bugs, including deadlocks. The usual practice involves employing software testing and/or dynamic analysis to detect. deadlocks. Their effectiveness is dependent on well-designed multithreaded test cases. Unsurprisingly, developing multithreaded tests is significantly harder than developing sequential tests for obvious reasons. In this paper, we address the problem of automatically synthesizing multithreaded tests that can induce deadlocks. The key insight to our approach is that a subset of the properties observed when a deadlock manifests in a concurrent execution can also be observed in a single threaded execution. We design a novel, automatic, scalable and directed approach that identifies these properties and synthesizes a deadlock revealing multithreaded test. The input to our approach is the library implementation under consideration and the output is a set of deadlock revealing multithreaded tests. We have implemented our approach as part of a tool, named OMEN1. OMEN is able to synthesize multithreaded tests on many multithreaded Java libraries. Applying a dynamic deadlock detector on the execution of the synthesized tests results in the detection of a number of deadlocks, including 35 real deadlocks in classes documented as thread-safe. Moreover, our experimental results show that dynamic analysis on multithreaded tests that are either synthesized randomly or developed by third-party programmers are ineffective in detecting the deadlocks.

Trace Driven Dynamic Deadlock Detection and Reproduction

Dynamic analysis techniques have been proposed to detect potential deadlocks. Analyzing and comprehending each potential deadlock to determine whether the deadlock is feasible in a real execution requires significant programmer effort. Moreover, empirical evidence shows that existing analyses are quite imprecise. This imprecision of the analyses further void the manual effort invested in reasoning about non-existent defects. In this paper, we address the problems of imprecision of existing analyses and the subsequent manual effort necessary to reason about deadlocks. We propose a novel approach for deadlock detection by designing a dynamic analysis that intelligently leverages execution traces. To reduce the manual effort, we replay the program by making the execution follow a schedule derived based on the observed trace. For a real deadlock, its feasibility is automatically verified if the replay causes the execution to deadlock. We have implemented our approach as part of WOLF and have analyzed many large (upto 160KLoC) Java programs. Our experimental results show that we are able to identify 74% of the reported defects as true (or false) positives automatically leaving very few defects for manual analysis. The overhead of our approach is negligible making it a compelling tool for practical adoption.