An abstract machine for an object-oriented language with top-level classes

This thesis proposes a novel way of performing type checking, whose results are incremental, depending on the provided local information. This new way of type checking is called co-contextual, where all context information of expressions, methods, classes, etc., is removed. Instead, we introduce corresponding structures using requirements. Standard type systems are translated to the co-contextual ones systematically using dualism as technique. Type systems play an important role to prevent execution errors from occurring during runtime. They are used to check programs statically for potential errors. Programs are type checked against a given set of rules. Depending on these rules programs are well-typed or not. The set of these rules is called typing rules. Each type rule associates types to the constructs of a program given a certain context. There can be different forms of contexts, depending on the features of the typed programming language. Functional languages use a typing context of variables and their types; object-oriented (OO) languages use additional class tables. Class tables are used for example to ensure that method and class declarations are well-typed. Type checking is performed top-down. While traversing the syntax tree of a program, typing contexts are extended with information on the expressions and their types. In case of OO, class tables are extended with clauses from class declarations, including the class members, i.e., fields, methods, or constructors. Contexts are passed through the nodes of the syntax tree in order to coordinate type checking between them. Therefore, while traversing the syntax tree top-down, the type checker creates dependencies between otherwise independent subexpressions. This way, it inhibits incrementalization and parallelization of type checking. That is, a change to a node of the syntax tree would require to redo the type check of the whole syntax tree. In this thesis a novel formulation of type systems is proposed, in order to remove dependencies between subexpressions. We propose a co-contextual formulation of typing rules that depends only on the local program constructs, e.g., expressions, methods, classes. The co-contextual typing rules have as conclusion a type and sets of requirements. That is, contexts and class tables are replaced by the dual concept of context and class table requirements. In addition, operations on contexts and class tables are replaced by new dual operations on requirements. The co-contextual type checker traverses a syntax tree bottom-up and merges context requirements of independently checked subexpressions. We describe a method for systematically constructing a co-contextual formulation of type rules from a regular context-based formulation and we show how co-contextual type rules give rise to incremental type checking. We derive co-contextual type checkers for functional and OO languages. As a representative of functional languages we consider PCF and extensions of it: records, parametric polymorphism, structural subtyping and let-polymorphism. Also, we investigate featherweight java (FJ) as the basis of OO languages and extensions of it: method overloading and generics. We build a1 co-contextual type checker for FJ enabling key features of OO languages: subtype polymorphism, nominal typing and implementation inheritance. The dualism between the co-contextual and contextual type systems preserves the correctness of the contextual calculus. That is, we prove the correctness of the co-contextual calculus via the equivalence between contextual type rules and their co-contextual formulations. We implemented an incremental type checker for PCF along with a performance evaluation showing that co-contextual type checking has performance comparable to standard context-based type checking, and incrementalization can improve performance significantly. Regarding FJ, we implemented a co-contextual type checker with incrementalization and compared its performance against javac on a number of realistic programs. Our performance evaluation shows significant speedups for the co-contextual type checker with incrementalization in comparison to javac.

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.

Concurrent object-oriented programming systems require support for concurrency control, to enforce consistent commitment of changes and to support program-initiated rollback after application-specific failures. We have explored three different concurrency control models atomic blocks, serializable transactions, and commit-serializable transactions - as part of the MELD programming language. We present our designs, discuss certain programming problems and implementation issues, and compare our work on MELD to other concurrent object-based systems.

Correctness of software systems can be proven by using static verification techniques. Static verifiers such as Spec# and ESC/Java have been developed for object-oriented languages. These verifiers have shown that static verification can be applied to object-oriented languages such as C# and Java. However, these verifiers are not easy to use, as they introduce many new concepts that programmers have to learn. To apply these verifiers to a real project, one has to modify existing code by adding contracts and annotations such as pure method marks or ownership information. Eiffel supports Design by Contract. Current libraries and programs are therefore already annotated with contracts. The goal of this thesis is to develop an automatic verifier for Eiffel which can prove existing code without the need of further annotations. The main features supported by the tool are agents and dynamic invocation. The tool, called EVE Proofs, translates Eiffel programs to Boogie and runs a fully automatic theorem prover to check correctness of the code. EVE Proofs is integrated in EVE, the Eiffel Verification Environment. This integration enables Eiffel programmers to use it directly from the programming environment. To reason about framing of routines, one needs modifies clauses. To prove existing Eiffel code, we implemented an automatic extraction of modifies clauses. Although the extraction of modifies clauses is limited, it enables us to prove examples with simple frame conditions. To show the feasibility of EVE Proofs, we present some examples which can be successfully verified. The examples include the command pattern to show the verification of agents and the strategy pattern to show the verification of dynamic invocation.

With the advent of computers, life has become a lot easier. The computer's ability to perform numerous tasks at a high speed has helped humans in many ways. Complex calculations that were previously done by hand, can now be done quickly using computers. Unlike humans, computers don't get tired. These machines can do monotonous mechanical computations reliably and efficiently. However, as computers cannot think, making a complex decision is certainly not possible for a computer. These machines face trouble in understanding complex real world problems. For instance, can a computer diagnose a disease based on the symptoms the person exhibits? This is why artificial intelligence steps in. It allows the computer to think like human. This paper discuss how software engineering is important to build an artificial indulgence. The requirement of software engineering in AI is for increased modularity, re-use ability and maintainability in the software which has accentuated interest in the object-oriented programming paradigm. In this regard, the approaches to AI, its procedure, and aspects in both dimension has been analyzed. In addition, the field of Distributed Artificial Intelligence (DAI) needs special emphasis on object-oriented multi-agent systems and particularly manufacturing applications. An application of artificial intelligence technology to the implementation of a rapid prototyping method in object-oriented performance design (OOPD) for real-time systems is very important.

This paper discusses the considerations that have played a role in the design of the language POOL2. This language integrates the structuring techniques of object-oriented programming with mechanis...

Has done research for the analysis and design of software evaluation clinical practice assessment (PKL / PKN) WEB based on the Diploma Program Radiodiagnostic and Radiotherapy Techniques Semarang. Needs analysis has been conducted for designing software evaluation clinical practice assessment (PKL / PKN) Web-based programming using PHP and MySQL. Analyses were performed with several stages of system analysis, analysis of the weaknesses of the old system based PIECES, a new system needs analysis, feasibility analysis and design of software systems sistem.Desain done with methods for object-oriented programming (Object Oriented Programming) created using the Unified Modeling Language (UML) that is using the use case, the database and interface design. With the analysis and design of the software, will be developed (development) and monitoring and evaluation in the next stage of research.

Dynamic type-checking and object-oriented programming often go hand-in-hand; scripting languages such as Python, Ruby, and JavaScript all embrace object-oriented (OO) programming. When scripts written in such languages grow and evolve into large programs, the lack of a static type discipline reduces maintainability. A programmer may thus wish to migrate parts of such scripts to a sister language with a static type system. Unfortunately, existing type systems neither support the flexible OO composition mechanisms found in scripting languages nor accommodate sound interoperation with untyped code. In this paper, we present the design of a gradual typing system that supports sound interaction between statically- and dynamically-typed units of class-based code. The type system uses row polymorphism for classes and thus supports mixin-based OO composition. To protect migration of mixins from typed to untyped components, the system employs a novel form of contracts that partially seal classes. The design comes with a theorem that guarantees the soundness of the type system even in the presence of untyped components.

Journeys up the mountain: Different paths to learning object-oriented programming

Laminar flame modeling is an important element in turbulent combustion research. The accuracy of a turbulent combustion model is highly dependent upon our understanding of laminar flames and their behavior in many situations. How much we understand combustion can only be measured by how well the model describes and predicts combustion phenomena. One of the most commonly used methane combustion models is GRI-Mech 3.0. However, how well the model describes the reacting flow phenomena is still uncertain even after many attempts to validate the model or quantify uncertainties. In the present study, the behavior of laminar flames under different aerodynamic and thermodynamic conditions is studied numerically in a stagnation-flow configuration. In order to make such a numerical study possible, the spectral element method is reformulated to accommodate the large density variations in methane reacting flows. In addition, a new axisymmetric basis function set for the spectral element method that satisfies the correct behavior near the axis is developed, and efficient integration techniques are developed to accurately model axisymmetric reacting flow within a reasonable amount of computational time. The numerical method is implemented using an object-oriented programming technique, and the resulting computer program is verified with several different verification methods. The present study then shows variances with the commonly used GRI-Mech 3.0 chemical kinetics model through a direct simulation of laboratory flames that allows direct comparison to experimental data. It is shown that the methane combustion model based on GRI-Mech 3.0 works well for methane-air mixtures near stoichiometry. However, GRI-Mech 3.0 leads to an overprediction of laminar flame speed for lean mixtures and an underprediction for rich mixtures. This result is slightly different from conclusion drawn in previous work, in which experimental data are compared with a one-dimensional numerical solutions. Detailed analysis reveals that flame speed is sensitive to even slight flame front curvature as well as its finite extension in the radial direction. Neither of these can be incorporated in one-dimensional flow modeling.

Reinforced concrete slabs supported on columns fail by punching when a conical plug of concrete perforates the slab above the column. This failure has been mostly investigated experimentally, so what can numerical simulation contribute to understand this phenomenon? To answer this question, a computational simulation tool based on the finite element method is developed. This numerical model is implemented into a computer code in applying the object-oriented programming concept. The requirements that the numerical model should fulfill are derived from a review of the experimental results published in the literature and obtained in our laboratory. The numerical model reproduces the non-linear material behavior characterizing reinforced concrete structures by decoupling the actions of steel reinforcement and concrete. The steel reinforcement is represented by uniaxial truss elements which follow a bi-linear stress-strain response. The concrete is modeled with continuum elements which are described at the constitutive level within the framework of the incremental flow theory of plasticity. The concrete triaxial strength is delimitated with a new failure criterion. A plastic flow rule is derived so as to reproduce the evolution of the plastic strain observed experimentally. Cracking induces strain-softening which refers to a gradual decrease in tensile strength with increasing deformations. The reduction of the tensile strength is controlled by an isotropic decohesion process which is monitored by constant fracture energy. The stiffness degradation due to cracking is reproduced with an isotropic elastic damage model. A perfect bond between concrete and steel is assumed. The capabilities of the numerical model are illustrated by simulating the localized shear failure in soil under a footing, the uniaxial tensile, and the confined compressive tests in plain and reinforced concrete specimens. The simulation of punching failure is investigated for three circular reinforced concrete slabs. The comparison with experimental results indicates that: (1) the punching failure mechanism –characterized by a localized inclined punching crack– is generated, (2) the value of the punching load is predicted, (3) the cracking sequence is reproduced, (4) the global response is slightly too stiff. For slabs with orthogonal reinforcement, the perfect bond hypothesis does not allow to capture the punching failure mechanism and the numerical model is improved by relaxing this hypothesis. The developed computational simulation tool reproduces the punching failure observed experimentally and is consequently used to investigate the failure mechanism. First, it is shown that the punching crack results from a crack coalescence phenomenon at the top of the slab followed by a crack propagation in the direction of the corner slab-column. Second, a condition for punching failure to occur is determined. Third, it is illustrated that the size-effect observed experimentally is reproduced and is reflected by a modification of the tensile stress distribution along the punching crack. Finally, a parametric study of the punching failure is performed revealing that punching failure is governed by the tensile strength of concrete. It is also shown that increasing the percentage of reinforcement raises the punching load and reduces the ductility of failure. Lastly, the computational simulation tool allows to demonstrate that in a circular slab, the applied bending moment is not determinant for the value of the punching load.

In this thesis, the JavaDL logic is amended by a new modality for the verification of termination-insensitive, object-sensitive, flow-sensitive noninterference of memory locations in object-oriented programs, that is local variables and heap object fields. Noninterference is a security model applied in information flow analysis and the amended JavaDL logic improves the information flow analysis of Java Card programs using the JavaDL sequent calculus. JavaDL formulae are a superset of first-order logic formulae and the logic additionally contains dynamic logic modalities as well as a concept called updates for the transition and evaluation of Java Card program states. Noninterference of memory locations is a property of programs and the respective pairs of start and end states of their executions. The satisfaction of the property implies that a particular set of memory locations does not interfere with the memory locations not included in this set. A set of memory locations does not interfere with another set if the evaluations of the included memory locations in the end state of any execution are independent of the evaluations of the memory locations included in the other set. Noninterference in Java Card programs has already been formulated and verified in JavaDL by a concept called self-composition which compares the end states of two independent executions of the same program with respect to a particular set of memory locations. This investigation is realisable with the means provided by JavaDL, in particular the dynamic logic modalities. However, in many cases the double execution poses unnecessary proof overhead and the new modality defined in this thesis aims at reducing this overhead. The new calculus reaches this goal by partially interpreting the verified program on a single execution path. As soon as this execution path branches the calculus must return to self-composition or the analysis loses precision.

In traditional object-oriented languages, the dynamic dispatch algorithm is hardwired: for every polymorphic call, only the most specific method is used. Clos, the Common Lisp Object System, goes beyond the traditional approach by providing an abstraction known as method combinations: when several methods are applicable, it is possible to select several of them, decide in which order they will be called, and how to combine their results, essentially making the dynamic dispatch algorithm user-programmable. Although a powerful abstraction, method combinations are under-specified in the Common Lisp standard, and the Mop, the Meta-Object Protocol underlying many implementations of Clos, worsens the situation by either contradicting it or providing unclear protocols. As a consequence, too much freedom is granted to conforming implementations. The exact or intended behavior of method combinations is unclear and not necessarily coherent with the rest of Clos. In this paper, we provide a detailed analysis of the problems posed by method combinations, the consequences of their lack of proper specification in one particular implementation, and a Mop-based extension called method combinators, aiming at correcting these problems and possibly offer new functionality.

A class dictionary defines all data structures that appear in a program as well as a language for describing data specified by the data structures. We demonstrate that class dictionaries are ideal for simplifying object-oriented programming. Our class dictionary-based approach to object-oriented programming is independent of any particular programming language, so it is applicable to a large variety of object-oriented systems. The experience in designing and using over one hundred class dictionaries has resulted in a set of useful design techniques. This novel approach to object-oriented programming makes interesting links between language design, data structure design, and data-base design.

We present a general storage model that reflects features of object oriented (OO) languages with pure reference semantics. Based on this model, we develop an OO Separation Logic (OOSL) to specify and verify OO programs. Many inference rules in the Separation Logic still hold in OOSL. Additionally, OOSL has certain properties important to OO reasoning. We introduce Hoare-Triple for a small OO language, and use the Schorr-Waite Marking Algorithm as a verification example.