the adoption of organisation-based agent-orientedprogramming has been quite limited, due to the lack of programminglanguages which are expressive enough to tackle the complexity brought by the dynamism of multi-agen...
详细信息
ISBN:
(纸本)9781479929023
the adoption of organisation-based agent-orientedprogramming has been quite limited, due to the lack of programminglanguages which are expressive enough to tackle the complexity brought by the dynamism of multi-agent systems. Oragent is an organisation-based agent-orientedprogramming language which provides explicit language primitives to program organisational concepts such as agents and groups as first-class entities, and to realise adaptation of multi-agent systems via role enactment and role-based interaction. In this paper, we present the execution mechanisms for Oragent language, which support adaptation of agent behaviour via role enactment, and role-based interaction among agents. A case study is presented to demonstrate the viability of these mechanisms.
Some programminglanguages become widely popular while others fail to grow beyond their niche or disappear altogether. This paper uses survey methodology to identify the factors that lead to language adoption. We anal...
详细信息
Some programminglanguages become widely popular while others fail to grow beyond their niche or disappear altogether. This paper uses survey methodology to identify the factors that lead to language adoption. We analyze large datasets, including over 200,000 SourceForge projects, 590,000 projects tracked by Ohloh, and multiple surveys of 1,000-13,000 programmers. We report several prominent findings. First, language adoption follows a power law;a small number of languages account for most language use, but the programming market supports many languages with niche user bases. Second, intrinsic features have only secondary importance in adoption. Open source libraries, existing code, and experience strongly influence developers when selecting a language for a project. Language features such as performance, reliability, and simple semantics do not. Third, developers will steadily learn and forget languages. The overall number of languages developers are familiar with is independent of age. Finally, when considering intrinsic aspects of languages, developers prioritize expressivity over correctness. They perceive static types as primarily helping with the latter, hence partly explaining the popularity of dynamic languages.
Programmers who need high performance currently rely on low-level, architecture-specific programming models (e. g. OpenMP for CMPs, CUDA for GPUs, MPI for clusters). Performance optimization with these frameworks usua...
详细信息
ISBN:
(纸本)9783642390388
Programmers who need high performance currently rely on low-level, architecture-specific programming models (e. g. OpenMP for CMPs, CUDA for GPUs, MPI for clusters). Performance optimization with these frameworks usually requires expertise in the specific programming model and a deep understanding of the target architecture. Domain-specific languages (DSLs) are a promising alternative, allowing compilers to map problem-specific abstractions directly to low-level architecture-specific programming models. However, developing DSLs is difficult, and using multiple DSLs together in a single application is even harder because existing compiled solutions do not compose together. In this paper, we present four new performance-oriented DSLs developed with Delite, an extensible DSL compilation framework. We demonstrate new techniques to compose compiled DSLs embedded in a common back-end together in a single program and show that generic optimizations can be applied across the different DSL sections. Our new DSLs are implemented with a small number of reusable components (less than 9 parallel operators total) and still achieve performance up to 125x better than library implementations and at worst within 30% of optimized stand-alone DSLs. The DSLs retain good performance when composed together, and applying cross-DSL optimizations results in up to an additional 1.82x improvement.
Software designers widely use UML Class Models to specify the static structure of object-orientedsystems. Temporal properties of class models can be expressed using the TOCL, an extension of OCL with elements of a li...
详细信息
Software designers widely use UML Class Models to specify the static structure of object-orientedsystems. Temporal properties of class models can be expressed using the TOCL, an extension of OCL with elements of a linear temporal logic. Specification and verification of temporal properties expressed in TOCL is non-trivial and no automated tools exist that aid such verification. Existing approaches rely on transforming the UML models to other languages that have automated analysis support. Such transformation is complex and can introduce errors. Towards this end, this paper proposes a framework for specifying and directly analyzing temporal properties expressed in TOCL. The framework was validated using two demonstration case studies and in both cases, the approach uncovered design faults.
Framework based software tends to get bloated by accumulating optional features (or concerns) just-in-case they are needed. The good news is that such feature bloat need not always cause runtime execution bloat. The b...
详细信息
Framework based software tends to get bloated by accumulating optional features (or concerns) just-in-case they are needed. The good news is that such feature bloat need not always cause runtime execution bloat. The bad news is that often enough, only a few statements from an optional concern may cause execution bloat that may result in as much as 50% runtime overhead. We present a novel technique to analyze the connection between optional concerns and the potential sources of execution bloat induced by them. Our analysis automatically answers questions such as (1) whether a given set of optional concerns could lead to execution bloat and (2) which particular statements are the likely sources of bloat when those concerns are not required. The technique combines coarse grain concern input from an external source with a fine-grained static analysis. Our experimental evaluation highlights the effectiveness of such concern augmented program analysis in execution bloat assessment of ten programs.
Emerging high-performance architectures are anticipated to contain unreliable components that may exhibit soft errors, which silently corrupt the results of computations. Full detection and masking of soft errors is c...
详细信息
Emerging high-performance architectures are anticipated to contain unreliable components that may exhibit soft errors, which silently corrupt the results of computations. Full detection and masking of soft errors is challenging, expensive, and, for some applications, unnecessary. For example, approximate computing applications (such as multimedia processing, machine learning, and big data analytics) can often naturally tolerate soft errors. We present Rely, a programming language that enables developers to reason about the quantitative reliability of an application - namely, the probability that it produces the correct result when executed on unreliable hardware. Rely allows developers to specify the reliability requirements for each value that a function produces. We present a static quantitative reliability analysis that verifies quantitative requirements on the reliability of an application, enabling a developer to perform sound and verified reliability engineering. The analysis takes a Rely program with a reliability specification and a hardware specification that characterizes the reliability of the underlying hardware components and verifies that the program satisfies its reliability specification when executed on the underlying unreliable hardware platform. We demonstrate the application of quantitative reliability analysis on six computations implemented in Rely.
Type systems that permit developers to express themselves more precisely are one of the primary topics in programming language research, as well as in industrial software development. While it seems plausible that an ...
详细信息
Type systems that permit developers to express themselves more precisely are one of the primary topics in programming language research, as well as in industrial software development. While it seems plausible that an expressive static type system increases developer productivity, there is little empirical evidence for or against this hypothesis. Generic types in Java are an example: as an extension of Java's original type system, some claim that Java 1.5 improves the type system's "expressiveness." Even if this claim is true, there exists little empirical evidence that claimed expressiveness leads to a measurable increase in developer productivity. This paper introduces an experiment where generic types (in comparison to raw types) have been evaluated in three different directions: (1) the documentation impact on undocumented APIs, (2) the time required for fixing type errors, and (3) the extensibility of a generic type hierarchy. The results of the experiment suggest that generic types improve documentation and reduce extensibility - without revealing a difference in the time required for fixing type errors.
The proceedings contain 9 papers. The topics discussed include: TeJaS: retrofitting type systems for javascript;type refinement for static analysis of javascript;cast insertion strategies for gradually-typed objects;i...
ISBN:
(纸本)9781450324335
The proceedings contain 9 papers. The topics discussed include: TeJaS: retrofitting type systems for javascript;type refinement for static analysis of javascript;cast insertion strategies for gradually-typed objects;improved type specialization for dynamic scripting languages;efficient dynamic access analysis using javascript proxies;polymorphic identifiers: uniform resource access in objective-smalltalk;all about the with statement in javascript: removing with statements in javascript applications;optimizing MATLAB feval with dynamic techniques;and whalesong: running racket in the browser.
I present an approach to avoid functional failures at runtime in component-based application systems. The approach exploits the intrinsic redundancy of components to find workarounds as alternative sequences of operat...
详细信息
ISBN:
(纸本)9781467330763
I present an approach to avoid functional failures at runtime in component-based application systems. The approach exploits the intrinsic redundancy of components to find workarounds as alternative sequences of operations to avoid a failure. A first Java prototype is presented, and an evaluation plan, as some preliminary results, are discussed.
Modern object-oriented applications commonly suffer from severe performance problems that need to be optimized away for increased efficiency and user satisfaction. Many existing optimization techniques (such as object...
详细信息
Modern object-oriented applications commonly suffer from severe performance problems that need to be optimized away for increased efficiency and user satisfaction. Many existing optimization techniques (such as object pooling and pretenuring) require precise identification of object lifetimes. However, it is particularly challenging to obtain object lifetimes both precisely and efficiently: precise profiling techniques such as Merlin introduce several hundred times slowdown even for small programs while efficient approximation techniques often sacrifice precision and produce less useful lifetime information. This paper presents a tunable profiling technique, called Resurrector, that explores the middle ground between high precision and high efficiency to find the precision-efficiency sweetspot for various liveness-based optimization techniques. Our evaluation shows that Resurrector is both more precise and more efficient than the GC-based approximation, and it is orders-of-magnitude faster than Merlin. To demonstrate Resurrector's usefulness, we have developed client analyses to find allocation sites that create large data structures with disjoint lifetimes. By inspecting program source code and reusing data structures created from these allocation sites, we have achieved significant performance gains. We have also improved the precision of an existing optimization technique using the lifetime information collected by Resurrector.
暂无评论