July/August 2010

In this paper we study the problem of developing efficient distributed algorithms for dense wireless networks. For many problems in this setting, fast solutions must leverage the reality that radio signals fade with distance, which can be exploited to enable concurrent communication among multiple sender/receiver pairs. To simplify the development of these algorithms we describe a new communication abstraction called FadingMAC which exposes the benefits of this concurrent communication, but also hides the details of the underlying low-level radio signal behavior. This approach splits efforts between those who develop useful algorithms that run on the abstraction, and those who implement the abstraction in concrete low-level wireless models, or on real hardware. After defining FadingMAC, we describe and analyze an efficient implementation of the abstraction in a standard low-level SINR-style network model. We then describe solutions to the following problems that run on the abstraction: max, min, sum, and mean computed over input values; process renaming; consensus and leader election; and optimal packet scheduling. Combining our abstraction implementation with these applications that run on the abstraction, we obtain near-optimal solutions to these problems in our low-level SINR model - significantly advancing the known results for distributed algorithms in this setting. Of equal importance to these concrete bounds, however, is the general idea advanced by this paper: as wireless networks become more dense, both theoreticians and practitioners must explore new communication abstractions that can help tame this density.

A System Perspective on Business Models

Requirements engineering for complex software intensive systems has become a major challenge in many software development projects. Especially the automotive industry experiences the increasing complexity of software in vehicles, during the last years. An actual premium vehicle, for instance embodies up to hundred electronic control units (ECU) with easily a few hundred features, each. Beneath the definition of abstract features, an electronic control unit is described by different goals, scenarios, requirements, and constraints. To create a manageable and traceable requirements specification for complex systems that enables the change and reuse of requirements, many companies claim assistance for a seamless specification of requirements. To satisfy this claim necessary requirements-artefacts and abstraction levels have to be defined. Further the interrelations between different requirements-artefacts of one, and among different abstraction levels have to be analyzed and defined. Recent research in this area has shown the benefits of goals and scenarios in addition to traditional requirements. Moreover, several researchers and practitioners have already researched the interrelations between goals and scenarios. However these works do not focus on the interrelationships of goals, scenarios, and requirements on different abstraction levels. In a joint project with DaimlerChrysler and the Software Systems Engineering Group at the University of Duisburg-Essen, we introduced goals, scenarios, and requirements on different abstraction levels and applied it in the context of a development project at DaimlerChrysler.

In summary, the aim of this research thesis is to fill a gap left by existing 3D GIS: the generation of a meaningful, interactive, three-dimensional presentation of a selected database, especially in terms of the graphical abstraction and progressive transfer in a heterogeneous network environment. The intention here is to expand the concept of an openly distributed GIS infrastructure of the OpenGIS Consortium (OGC) [BuMc96] to three-dimensional geodata. In contrast to previous work such as [Lang99], the main goal is not to depict a virtual landscape and/or an urban region as photorealistically as possible. Rather, the visual processing of the database should strive to support the user’s information needs. In contrast to computer-graphics rendering, in which a geometric model is depicted on a two-dimensional surface in proper perspective, the goal of the visualization is to transmit information to the user [Fole92]. Apart from the actual rendering, this process also requires a selection procedure that decides which elements of a scene contribute to the information content. This kind of visualization is called graphical abstraction. In a heterogeneous network environment, the problem of resource-adaptive data transfer and visualization is second to the graphical abstraction problem. The question is not only how to suitably describe the selected data, but also how to develop an adequate data transfer that presents the viewer with an initial visual result as quickly as possible. Additional data can be transferred later. This progressive data transfer is crucial for the use of 3D data on the Internet [Ross98]. Core concepts and components of the 3D geodata server developed within this thesis are the development of a query-oriented data model for efficient analysis of topological relations in three-dimensional spatial data, and a method for evaluating the relevance of single feature based on a user specific query. Based on this, a method to generate a graphical abstraction of the query result is developed. In order to compress the resulting model, a compression technique for triangle meshes for progressive transmission is invented. These concepts are proofed by a prototypical implementation within a 3D geodata server.

This thesis offers a philosophical study of computation, which is understood here as a method of abstraction that systematises reality through logico-quantitative means. The thesis challenges the view that computation’s abstractive processes are simple and static ‘formulae’ that capture the world’s dynamism. By engaging with the formal and axiomatic character of computing, it argues that computation is itself dynamic, because it has a potential to actualise itself. This potentiality is theorised in aesthetic terms. Drawing from Deleuze, aesthetics is viewed as an investigation into the conditions of real experience. For Deleuze, these conditions pertain to virtuality, i.e. to the indeterminacy of sensation, and of thought’s immanence to affect. However, through a novel reading of the ontological significance of Gödel’s incompleteness theorems and of Turing’s notion of incomputability, the thesis demonstrates that indeterminacy does not pertain uniquely to virtual life, but rather lies at the axiomatic heart of computational logic. Computation is thus shown to be contingent, because it is always indeterminate. This contingency is formal, not empirical; it is the status of self-sufficient processes of algorithmic determination, which always confront quantitative infinity by means of formal abstraction. Whitehead’s philosophy is used to extend aesthetics from the sensible to the intelligible. Experience is thereby understood as self-actualisation. Its conditions are tied to physical and conceptual operations of determination. Computational processes are addressed as Whitehead’s ‘actual occasions’: as events that constitute themselves through the dynamic processing of eternal and actual data. This dynamism is not pre-determined a priori, and therefore breaks with the computationalist and cognitivist paradigms, which reduce actualisation to universalising prescriptions. This dynamism cannot be flattened onto sense-empirical factuality either. Instead, an aesthetics of contingent computation conceptualises ‘computational actual occasions’ as discrete processes of determination that conclude with the production of a structure or a ‘form’ of actualisation.

As lithographic processes’ size to manufacture transistors shrink, the number of available transistors on integrated circuits (IC) increases. Newly manufactured ICs require innovations to leverage improved performances or area occupation, and feature more and more components on the same chip, which work together and/or independently to provide an advanced set of functions. The complexity of hardware design flows consequently increased: from circuit description to functional verification and in-system interface, every stage is now more and more driven by a cross-product function between a set of reusable functional units and constraints to target a specific technology (ASIC, FPGAs etc…) and configuration. This diversity in the possible outputs for a set of components calls for the development of new methodologies to raise the abstraction level in the design flows. A better abstraction allows optimizing and automating more processes, from component specification to final implementation and interfacing. New Abstraction levels have always emerged through industry standards like Verilog and VHDL for digital circuit description, SystemVerilog/UVM/e for functional verification, or by vendor specific toolchains. However, standards and software toolchains usually lack flexibility as they operate for a bounded range of functionalities. This thesis presents some novel applications covering various stages of the design flow, ranging from digital design input (register file generator) and ASIC circuit implementation (Hierarchical Floorplaning), up to in-system IC integration (Part design language). They are backed by a generic software design methodology based on functional programming used to develop domain specific languages embedded in the TCL interpreter. To complete the design flow path from circuit implementation to software integration, a hardware-software interfacing point linked with the Register File Generator design tool will be presented. It is based on a generic and innovative XML-Data binding technology which was developed during this work. The iterative loop between application definition and flexible software components reuse presented along this work also provides a general guideline to develop future design flow components, and guarantee their integration in any target environment.

While GPUs are increasingly popular for high-performance computing, optimizing the performance of GPU programs is a time-consuming and non-trivial process in general. This complexity stems from the low abstraction level of standard GPU programming models such as CUDA and OpenCL: programmers are required to orchestrate low-level operations in order to exploit the full capability of GPUs. In terms of software productivity and portability, a more attractive approach would be to facilitate GPU programming by providing high-level abstractions for expressing parallel algorithms.OpenMP is a directive-based shared memory parallel programming model and has been widely used for many years. From OpenMP 4.0 onwards, GPU platforms are supported by extending OpenMP's high-level parallel abstractions with accelerator programming. This extension allows programmers to write GPU programs in standard C/C++ or Fortran languages, without exposing too many details of GPU architectures.However, such high-level parallel programming strategies generally impose additional program optimizations on compilers, which could result in lower performance than fully hand-tuned code with low-level programming models. To study potential performance improvements by compiling and optimizing high-level GPU programs, in this paper, we 1) evaluate a set of OpenMP 4.× benchmarks on an IBM POWER8 and NVIDIA Tesla GPU platform and 2) conduct a comparable performance analysis among hand-written CUDA and automatically-generated GPU programs by the IBM XL and clang/LLVM compilers.

We describe a method for representing knowledge graphs that capture an intensional representation of the original extensional information. This representation is very compact, and it abstracts away from individual links, allowing us to find better path candidates, as shown by the results of link prediction using this information. The data in this archive consists of the abstract graphs built from several configurations of Freebase and NELL (used in the experiments described in Gardner et al. 2014), the abstract paths extracted from these graphs, the grounded paths and the negative sampling used in the experiments described in (Nastase and Kotnis, 2019). The motivation for this work was to find better patterns in knowledge graphs than those obtained using the PRA approach. This dataset contains: AbstractGraphs_Garder2014data.tar.gz: the abstract graphs AbstractPathsGroundedPaths.tar.gz: the abstract paths, grounded paths, train/test data and the corresponding negative samples (for each abstract graph) For a brief description of the data in each archive, please see README_AbstractGraphs.txt.

Distributed shared memory (DSM) systems allow programmers to use a shared memory programming model on distributed systems. However, DSM systems present new challenges to performance evaluation and debugging. While programmers write programs with a shared memory model using shared variables and shared memory synchronization primitives to coordinate processes, most performance problems arise from the implementation of these abstractions with messages. Because the DSM abstraction hides the underlying message passing, it is difficult to identify the sources of performance problems. We have developed an instrumentation system and performance evaluation techniques for DSM systems that correlate message passing behavior in the lower levels of a DSM system with the higher-level shared memory programming abstractions. We have developed a prototype tool called Xunify to demonstrate the feasibility of such an approach. Xunify provides graphical animations of DSM programs at three distinct levels and offers a powerful event filtering facility capable to help show system behavior corresponding to specific DSM constructs.

The current research aimed to explore the rhetorical moves in abstracts of English and Persian Mining Engineering research articles. For this purpose, 60 abstracts written by native speakers of English and Persian were analyzed based on Hyland’s (2000) model of five rhetorical moves to explore the pattern of moves in abstract sections. Findings suggested that there were four conventional moves in abstracts in the English corpus (PMPrC), while there were five conventional moves in abstracts in the Persian corpus (IPMPrC). Results of statistical analyses show that there was a statistically significant difference in Purpose move in the two dataset. However, there were not any significance differences in the use of other moves such as product, method, and conclusion moves in the corpora. Keyword: Abstract, Genre, Move pattern, Mining Engineering

Graph models have been useful abstraction for examining the programmer's perspective of the static structure of imperative programs. A number of Graph models referring to control flow and data dependencies have appeared in the literature. The primary objective of this research is to develop a more general graph-theoretic model for describing programs written in arbitrary imperative languages and to compute a structural measure based on this abstraction. The proposed model is a synthesis of the control flow graph and the data dependency graph. This new unified abstraction, called the Generalized Program Graph (GPG), is structurally equivalent to the string from of a program. However, because of its graph structure, the new model is better suited for structural analysis of a program than original string form.

在B3LYP/6-31+G(d,p)理论水平下采用基于波恩-奥本海默近似的从头算分子动力学方法重新研究了O-与CH3F,反应经抽氢生成OH-和生成H2O的两条产物通道.反应轨线从反应初始过渡态开始,采用300 K时的热取样确定初始条件,同时为对比不同的初始碰撞平动能条件下产物通道的变化,分别限定过渡矢量上的能量为2.1、36.8及62.8 kJ·mol-1进行轨线计算,所有轨线计算的结果表明抽氧生...

Abstract—–Flash photolysis at 450 nm over the temperature range 0.8–60°C was used to determine Arrhenius parameters for the first and second order disappearance of triplet lumiflavin (1.66 µ.M) at a flash energy of 2 kj in deaerated phosphate buffer at varying pH:3Lf → Lf03Lf +3Lf → Lf0+ Lf0Arrhenius parameters were also determined for the pseudo first‐order quenching of triplet lumiflavin by 10 µMferri‐ and ferrocyanide ions,3Lf + Fe3+→ Fe3+→ Lf0+ Fe3+(energy transfer)3Lf + Fe2+→ Lf‐+ Fe3+(electron transfer)and for disappearance of the semireduced lumiflavin in the presence of ferrocyanide at pH 6.8, by the second‐order reactionLf‐+Lf‐→ Lf0+ Lf=.

The present manuscript-based doctoral thesis addresses the question of how approaches to interaction design can be made more structured. This is an attempt to make it more transparent how one can come to a final design of a user interface starting from the results of foundational user research. The results of this analysis can help designers to work very systematic at times, to better reflect on their own idiosyncratic design process “on the job”, or to learn interaction design in the first place. In user-centered design (UCD) there are lifecycles and methods that already provide a certain degree of structuring with the discrimination of different phases etc. But they leave open some gaps here and there. This work is an attempt to close some of the gaps and bring closer together these individual methods. Interaction design patterns are a way to describe solutions to problems in designing user in-terfaces in a very systematic way. However, pattern libraries usually are far from complete. They mostly lack patterns to support the early phases of interaction design and therefore they do usually not link to the abstract models of conceptual design. The third manuscript describes an organizational scheme for interaction design patterns to support the process of implementing a complete pattern language covering all the different levels of the solution domain. The scheme has been found by analyzing several established UCD lifecycles and it has been evaluated by organizing all the individual patterns of several public pattern libraries into it. The first manuscript describes a process of systematically building up a pattern language alongside of a redesign project of a complex application in a corporate environment. The second manuscript describes how patterns have been evaluated in the aforementioned project, when there were several different solutions for one problem. This is shown with two interaction design patterns for the problem of making required input fields visible to users. The fourth manuscript is an attempt to bring together the idea of a complete pattern language, as a description of the solution domain of interaction design, with the different parts of the problem domain. Therefore, the same UCD lifecycles (as in the third manuscript) have been analyzed to find a universal structure of the problem domain. Then all the mappings between the individual parts of the two domains have been described in order to link the two domains in this direct way. Another way of looking at the gap between the problem domain and the solution domain is by seeing it as a distance of levels of abstraction between results of foundational user research and the final user interface. From this point of view a bridging of the gap can be seen in different intermediate representations (abstract models, sketches, and prototypes) and linking them together in a coherent way. These different ways of bridging the gap between foundational user research and the final design of a user interface can be seen as cognitive artifacts to foster problem solving and learning of interaction designers.

With the explosion of broadband Internet connections in the late 80s, new types of applications, called distributed applications, came to light. These applications typically seek to provide a user with remote services that appear to that user as if they were local. For instance, when a user browses the Internet, web pages are downloaded from different servers and are displayed on the screen of the client's computer as if they were directly available on the computer itself. Typically one distinguishes two kinds of actors in such applications: clients, searching for information, and servers, providing the information. Furthermore, there are generally two models of interaction according to which these actors exchange information. In the first model, the client requests specific information and waits until the server replies to it. In the second model, the client registers its interests in some information with a set of servers and is notified when new information is available. Both models have their advantages and disadvantages but the second has obvious asynchrony benefits in a large-scale system in which it is very difficult to know the time taken to answer a request. The second model is usually encapsulated within the celebrated publish/subscribe abstraction. According to this abstraction, clients are either subscribers which express interest in specific information, or publishers which create and send pieces of information usually transmitted in the form of events (e.g., as HTML pages or plain data). The subscriber does not need to know a publisher or to be on-line with it to receive its published events. These properties are sometimes refer to as space and time decoupling respectively. Newsgroups are the most well known example of publish/subscribe system. While indeed appealing, the publish/subscribe abstraction is not easy to implement effectively. There are at least two challenging issues: (1) the representation of the events and (2) their dissemination on a large-scale or in a mobile environment. Events are usually transferred as XML messages or byte arrays. The system must therefore transform events into pieces of software implemented in its underlying language (e.g., Java, C#) before handling them. In addition, the reliable dissemination on a large-scale or in a mobile environment is not trivial, especially as in practice it is necessary to minimize the number of duplicates and parasite events (i.e., events of no interest) to save bandwidth and processing power. We focus in this thesis on devising and implementing algorithms which address the above two issues in publish/subscribe systems implemented in object-oriented languages (e.g., Java, C#) and such that the events that are transferred between the different actors correspond to serialized objects. These systems are also called type-based publish/subscribe systems. We first present techniques to detect events of interest and throw away parasite events. We show that these techniques are of major use for reliably disseminating events either on a large-scale or in a mobile environment without flooding the network. Finally, we illustrate type interoperable rules that let instances of two different types, but still representing the same entity, to be used indistinguishably. Together with the algorithms, we exhibit implementation prototypes and performance measures conducted over them.