This paper presents object-oriented design of library meant for modeling and simulating Timed Colored Petri Net models. The approach is prepared to integrate TCPN models with crucial parts of larger applications imple...
详细信息
ISBN:
(纸本)9781467344715
This paper presents object-oriented design of library meant for modeling and simulating Timed Colored Petri Net models. The approach is prepared to integrate TCPN models with crucial parts of larger applications implemented in object-oriented languages. The formal models can be tightly joined with applications allowing the latter to interpret states of the formal model in their domain of responsibility. This approach allows less error-prone and more pervasive use of formal methods to improve quality of software created with imperative languages.
Business Process Management (BPM) suffers from inadequate concepts and tools for monitoring and evaluation of process executions at runtime. Conversely, models at runtime promise to give insights into the state of a s...
详细信息
Business Process Management (BPM) suffers from inadequate concepts and tools for monitoring and evaluation of process executions at runtime. Conversely, models at runtime promise to give insights into the state of a software system using the abstract and concrete appearance of design time process models. Therefore, we at first advocate to use models at runtime in business process (BP) modeling. Then, we outline the implementation of a prototypical modeling framework for BP runtime models based on metaprogramming. This framework supports the integration of BP type models - models that are enhanced with statistics of runtime data - and instance models - visual representations of executed BPs - resulting in versatile process monitoring dashboards. The approach is superior to object-orientedprogramming, as it provides a common representation for models and code at various levels of classification, and represents an attractive alternative to object-oriented languages for the implementation of runtime models in general.
Concurrency is a ubiquitous phenomenon in modern software ranging from distributed systems communicating over the Internet to communicating processes running on multi-core processors and multi-processors. Therefore mo...
Concurrency is a ubiquitous phenomenon in modern software ranging from distributed systems communicating over the Internet to communicating processes running on multi-core processors and multi-processors. Therefore modern programming languages offer ways to program concurrency effectively. Still, writing correct concurrent programs is notoriously difficult because of the complexity of possible interactions between concurrent processes and because concurrency-related errors are often subtle and hard to reproduce, especially for safety-critical applications. This thesis develops and formally investigates different static analysis methods for various concurrency-related problems in concurrent object-orientedprogramming languages to guarantee the absence of common concurrency-related errors, hence contribute to the quality of concurrent programs.
Aspects covered by our analyses involve lock-based concurrency, transaction-based concurrency, resource consumption and inheritance. In the lock-based setting, using explicit locks in a non-lexical scope to protect critical regions might be the source of aliasing problems or misuse of locks. In the transaction-based model, a similar problem of misuse of non-lexical transactions can happen in the same way as the misuse of explicit locks. Furthermore, for the purpose of checking conflicts and supporting rollback mechanisms, additional storage are required to keep track of changes during transactions’ execution which can lead to resource consumption problems. So it is useful to investigate different analysis methods to achieve safe concurrent programs. In open systems, the combination of inheritance and late-binding problematic, e.g., replacing one base class by another, seemingly satisfying the same interface description, may break the code of the client of the base class. This thesis also investigates an observable interface behavior of open systems for a concurrent object-oriented language with single-class inheritance where c
Understanding and analyzing multi-threaded program performance and scalability is far from trivial, which severely complicates parallel software development and optimization. In this paper, we present bottle graphs, a...
详细信息
ISBN:
(纸本)9781450323741
Understanding and analyzing multi-threaded program performance and scalability is far from trivial, which severely complicates parallel software development and optimization. In this paper, we present bottle graphs, a powerful analysis tool that visualizes multi-threaded program performance, in regards to both per-thread parallelism and execution time. Each thread is represented as a box, with its height equal to the share of that thread in the total program execution time, its width equal to its parallelism, and its area equal to its total running time. The boxes of all threads are stacked upon each other, leading to a stack with height equal to the total program execution time. Bottle graphs show exactly how scalable each thread is, and thus guide optimization towards those threads that have a smaller parallel component (narrower), and a larger share of the total execution time (taller), i.e. to the 'neck' of the bottle. Using light-weight OS modules, we calculate bottle graphs for unmodified multi-threaded programs running on real processors with an average overhead of 0.68%. To demonstrate their utility, we do an extensive analysis of 12 Java benchmarks running on top of the Jikes JVM, which introduces many JVM service threads. We not only reveal and explain scalability limitations of several well-known Java benchmarks;we also analyze the reasons why the garbage collector itself does not scale, and in fact performs optimally with two collector threads for all benchmarks, regardless of the number of application threads. Finally, we compare the scalability of Jikes versus the OpenJDK JVM. We demonstrate how useful and intuitive bottle graphs are as a tool to analyze scalability and help optimize multi-threaded applications.
The proceedings contain 52 papers. The topics discussed include: mining source code repositories with boa;Panini: a capsule-orientedprogramming language for implicitly concurrent program design;finding architectural ...
详细信息
ISBN:
(纸本)9781450319959
The proceedings contain 52 papers. The topics discussed include: mining source code repositories with boa;Panini: a capsule-orientedprogramming language for implicitly concurrent program design;finding architectural flaws in android apps is easy;finding the missing eclipse perspective: the runtime perspective;automated assessment of students' testing skills for improving correctness of their code;implementing a scripting language parser with self-extensible syntax;program transformation techniques applied to languages used in high performance computing;a secure play store for android;refactoring multicore applications towards energy efficiency;the poor man's proof assistant: using prolog to develop formal language theoretic proofs;dictionary-based query recommendation for local code search;a screen-oriented representation for mobile applications;and source code management for projectional editing.
programming languages rely on type systems to safeguard the correctness of a program. In existing technologies, types defined in a program are meaningful only within its runtime, so the definition of a remote resource...
详细信息
ISBN:
(纸本)9781450316569
programming languages rely on type systems to safeguard the correctness of a program. In existing technologies, types defined in a program are meaningful only within its runtime, so the definition of a remote resource must be obtained and verified to ensure a correct and type-safe interaction. However, obtaining a consistent meaning of a resource in a distributed environment requires much human effort and coordination, thus making the development process difficult to scale to an Internet-like open environment. The key lies in the lack of a truly global naming scheme to unambiguously and automatically resolve programmatic types in the Internet. In light of this, we propose Uniform Type Locator (UTL), a worldwide scope type naming scheme. We also design and implement a new strongly typed object-orientedprogramming language called Meso to natively support UTLs, and a protocol to facilitate program interoperations. We illustrate through examples how Meso can be used to make developing applications in an Internetlike open environment as easy and type-safe as developing them in a single runtime environment. Copyright 2013 ACM.
Data mining discovers knowledge and useful information from large amounts of data stored in databases. With the increasing popularity of object-oriented database system in advanced database applications, it is signifi...
详细信息
In this paper we explore how we can use Specification and Description Language, to represent simulation models that make an intensive use of geographical information, like environmental simulation models. The purpose ...
详细信息
ISBN:
(纸本)9781479939503;9781479920778
In this paper we explore how we can use Specification and Description Language, to represent simulation models that make an intensive use of geographical information, like environmental simulation models. The purpose is to perform a complete unambiguous, graphical and formal representation of a wildfire simulation model. Specification and Description Language is a modern objectoriented language that allows the definition of distributed systems. It has focused on the modeling of reactive, state/event driven systems, and has been standardized by the International Telecommunications Union (ITU) in the Z. 100. Thanks to the graphical representation of the simulation model, the interaction between the experts that usually come from different areas is simplified. Also, due to the unambiguous and modular nature of the language, all the details of the model can be validated by personnel that do not necessarily are used with programming languages or simulation infrastructures.
The advantages of object-orientedprogramming for crop modeling are discussed. Contrarily to procedural languages such as Fortran77, objectorientedprogramming yields a code that is intrinsically modular and whose ar...
详细信息
This paper introduces JT2FIS, a Java Class Library for Interval Type-2 Fuzzy Inference systems that can be used to build intelligent object-orientedapplications. The architecture of the system is presented and its ob...
详细信息
暂无评论