programming is a fundamental subject in the majority of technology-oriented degrees, particularly in Computer Engineering programs. Mastering programming requires continuous practice to understand the syntax, semantic...
详细信息
A key scalability challenge for interprocedural dataflow analysis comes from large libraries. Our work addresses this challenge for the general category of interprocedural distributive environment (IDE) dataflow probl...
详细信息
ISBN:
(纸本)9783540787907
A key scalability challenge for interprocedural dataflow analysis comes from large libraries. Our work addresses this challenge for the general category of interprocedural distributive environment (IDE) dataflow problems. Using pre-computed library summary information, the proposed approach reduces significantly the cost of whole-program IDE analyses without any loss of precision. We define an approach for library summary generation by using a graph representation of dataflow summary functions, and by abstracting away redundant dataflow facts that are internal to the library. Our approach also handles object-oriented features, by employing an IDE type analysis as well as special handling of polymorphic library call sites whose target methods depend on the future (unknown) client code. Experimental results show that dramatic cost savings can be achieved withthe help of these techniques.
the proceedings contain 28 papers. the special focus in this conference is on Trees in Algebra and programming. the topics include: Model checking and boolean graphs;SIGNAL as a model for real-time and hybrid systems;...
ISBN:
(纸本)9783540552536
the proceedings contain 28 papers. the special focus in this conference is on Trees in Algebra and programming. the topics include: Model checking and boolean graphs;SIGNAL as a model for real-time and hybrid systems;towards an adequate notion of observation;proving safety of speculative load instructions at compile-time;typed norms;compositional refinements in multiple blackboard systems;fully persistent arrays for efficient incremental updates and voluminous reads;back to direct style;extraction of strong typing laws from action semantics definitions;detecting determinate computations by bottom-up abstract interpretation;ELIOS-OBJ theorem proving in a specification language;incremental garbage collection without tags;approximate fixed points in abstract interpretation;dynamic typing;automatic parallelization of lazy functional programs;reversing abstract interpretations;a theory of qualified types;a semantics for multiprocessor systems;interprocedural type propagation for object-oriented languages;using the centaur system for data-parallel SIMD programming;the tensor product in wadler's analysis of lists;basic superposition is complete;observers for linear types;type inference for partial types is decidable;a provably correct compiler generator;an adequate operational semantics of sharing in lazy evaluation;modules for a model-oriented specification language and typing references by effect inference.
A hallmark of object-orientedprogramming is the ability to perform computation through a set of interacting objects. A common manifestation of this style is the notion of a package, which groups a set of commonly use...
详细信息
ISBN:
(纸本)9783642548048;9783642548031
A hallmark of object-orientedprogramming is the ability to perform computation through a set of interacting objects. A common manifestation of this style is the notion of a package, which groups a set of commonly used classes together. A challenge in using a package is to ensure that a client follows the implicit protocol of the package when calling its methods. Violations of the protocol can cause a runtime error or latent invariant violations. these protocols can extend across different, potentially unboundedly many, objects, and are specified informally in the documentation. As a result, ensuring that a client does not violate the protocol is hard. We introduce dynamic package interfaces (DPI), a formalism to explicitly capture the protocol of a package. the DPI of a package is a finite set of rules that together specify how any set of interacting objects of the package can evolve through method calls and under what conditions an error can happen. We have developed a dynamic tool that automatically computes an approximation of the DPI of a package, given a set of abstraction predicates. A key property of DPI is that the unbounded number of configurations of objects of a package are summarized finitely in an abstract domain. this uses the observation that many packages behave monotonically: the semantics of a method call over a configuration does not essentially change if more objects are added to the configuration. We have exploited monotonicity and have devised heuristics to obtain succinct yet general DPIs. We have used our tool to compute DPIs for several commonly used Java packages with complex protocols, such as JDBC, HashSet, and ArrayList.
Multiparty Session Types (MPST) is a typing discipline for communication protocols. It ensures the absence of communication errors and deadlocks for well-typed communicating processes. the state-of-the-art implementat...
详细信息
this report summarizes the results of the eleventh workshop on pedagogies and tools for the teaching and learning of object-oriented concepts. the focus of this year's workshop was on desirable properties of examp...
ISBN:
(纸本)9783540781943
this report summarizes the results of the eleventh workshop on pedagogies and tools for the teaching and learning of object-oriented concepts. the focus of this year's workshop was on desirable properties of examples and the usage of simple tools. the workshop gathered 17 participants, all from academia, from 7 different countries.
this paper presents a language framework for a concurrent description and an implementation of a synchronization mechanism in distributed object-oriented computation. Some concurrent object-oriented languages are cons...
详细信息
this paper presents a language framework for a concurrent description and an implementation of a synchronization mechanism in distributed object-oriented computation. Some concurrent object-oriented languages are considered to be constructed from a user-defined function and a synchronization constraint. We propose the language for the synchronization constraint, which allows to define mutual exclusion and conditional synchronization by using declarative notations. the synchronization constraint is separated from user-defined functions, and the relation between them is described in the binding code. the binding mechanism reduces the dependency between them and contributes to code reuse. this framework makes it is easy for programmers to understand and describe the use-defined functions and synchronization constraints independently. the implementation of the synchronization mechanism is based on a reconfigurable object model that we are developing. the user-defined function and synchronization mechanism are implemented as its own separated module in the single object. then the synchronization mechanism has flexibility and preserves the concept of object-orientation.
objectorientedprogramming languages have raised the level of abstraction by supporting the object querying on collections. programming languages can execute first class query constructs, using query optimization tec...
详细信息
ISBN:
(纸本)9781467358330
objectorientedprogramming languages have raised the level of abstraction by supporting the object querying on collections. programming languages can execute first class query constructs, using query optimization techniques from the database field, for run time optimizations. Existing approaches, however, such as Java Query Language (JQL), which executes such query constructs on collections have high run time overhead. therefore, we propose an approach to reduce the burden of run time overhead by performing most of the query optimization for object queries on collections at compile time. this approach both analyzes the source code and obtains the metadata provided through annotations. It relies on building histograms from the metadata information. then, the predicate and join selectivity estimates within a query are computed from these histograms. the selectivity estimates are maintained accurate withthe incremental maintenance of histograms to the data changes in the program at run time. Next, boththe selection and join optimizations are applied on the queries. the optimizations help in skipping and eliminating the execution of some of the predicates and joins based on the collected metadata. Finally, a query plan is generated at the compile time through the proposed selectivity cost heuristic. the query itself is executed at run time according to the determined query plan. But, in cases of inaccurate metadata and significant data changes in the source code, the query plan is modified at run time according to the correct selectivity estimates obtained from the updated histograms. Our experimental results demonstrate that our approach reduces the run time overhead of a program with collections more than the earlier approaches such as JQL.
暂无评论