First-Class Relationships in an Object-Oriented Language

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.

Abstract. At a fundamental level, functional and object-oriented programming languages are all ‘higher-order’, in the sense that they support computing with values that are themselves pieces of program code encapsulated with a local environment. In functional languages these ‘active’ values are functions, while in object-oriented languages they are objects. Both styles of higher-order language claim to provide good support for writing adaptable programs, but functional and object-oriented languages achieve this adaptability in different ways: functional programs rely on parameterisation at the value, type and module level, while object-oriented languages rely primarily on subtyping and implementation inheritance. Here we compare these two approaches, mainly in terms of the features and properties of their type systems, and consider the benefits and disadvantages of unifying (or merging) the two paradigms by adding object-oriented features to ML as a base language. We argue that while some of the simpler aspects of object-oriented languages are compatible with ML, adding a full- edged class-based object system to ML leads to an excessively complex type system and relatively little expressive gain, especially if we aim to preserve that mostly functional style of programming that is a major advantage of ML.

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.

Computer programming language is the foundation of developing computer application technologies and software. C language and object-oriented programming language belong to commonly-utilized advanced computer languages, and they have certain relevance in logic. Meanwhile, they have their own advantages. In other words, C language and object-oriented programming language possess both relevance and differences in the aspects of selection and application. The work discussed the compiling essentials of C language and object-oriented programming language. Besides, the differences and applicability of those two languages in the aspect of programming were further analyzed.

The understanding of object-oriented programming languages is generally based on their included features. In this understanding, these features form the underlying concepts of both the languages and the modeling processes based on the languages. Consequently, object-oriented languages are generally compared and evaluated based on these features. Alternatively, object-oriented programming languages may be seen as supporting a conceptual perspective on programming. Instead of the features, the underlying concepts are then concepts such as phenomenon and concept , and also the abstraction processes in relation to these concepts. A comparison of object-oriented languages from the conceptual perspective gives additional understanding of each language and the mutual relations and differences between these.

Chapter 5 discusses some fundamentals of object-oriented programming languages (Section 5.1) and distributed programming languages (Section 5.4). It also specifically summarizes the major features of two object-oriented programming languages: c++ (Section 5.2) and SMALLTALK (Section 5.3), and one distributed programming language, namely, OCCAM and its predecessor CSP (Section 5.5). Although there are other object-oriented languages (e.g., ACTOR 1 and EFFEL 2 and distributed programming languages (see Section 5.4), these three languages are chosen to illustrate some basic ideas behind object-oriented programming and distributed programming. It is assumed that the reader is familiar with c.

Answer Set Programming (ASP) is a declarative programming paradigm which allows for easy modeling and solving of hard problems that are often cumbersome to implement in object-oriented programming languages. It was successfully applied to a range of applications from artificial intelligence, such as combinatorial or scheduling problems. On the other hand, real-world applications for end-users usually consist also of components which cannot be (easily) solved in ASP, such as user interaction via graphical user interfaces, presentation of results, and interfaces to data sources. Instead, realizing such components is typically in the domain of traditional (object-oriented) programming languages. To address this issue, we introduce a language which allows for a formal specification of the input and output of an ASP program, which can be exploited to easily interface the program from object-oriented languages using a dedicated library. While the language is independent from the concrete object-oriented language, we also provide and present a reference implementation as a Python library. We then discuss some applications which can be realized on top of our approach.

Automation software systems usually implement the IEC 61131-3 and IEC 61499 standards. Nowadays, these applications request, among others, reusability, flexibility, reliability, and modularity via both standards. These characteristics can be achieved by a traditional paradigm called Object-Oriented Programming (OOP). OOP is an older method that applied with various programming languages to generate a replicable style of programming, i.e., code composed by Functions, Methods, etc. A well-defined programming method makes the code understandable for programmers. OOP defines the reusability, accessibility, adaptability, and robustness of software programs. It means that using gradual methods gained experience improves the quality of programs and simplifies their organization. OOP also increases the security of applications from its core features, i.e., Abstraction, Instantiation, Encapsulation, Polymorphism, and others. Therefore, OOP has been applied and discussed for both standards; however, OOP’s complexity and implementation using these IEC standards have not been compared yet. This work proposes the typical application of the Function Block (FB) to define classes and objects for industrial automation systems based on OOP. We implement one particular case of study for both standards. The FB employments are evaluated in order to compare OOP applicability and advantages of each standard. Adapting automation software regarding new industry requirements implies greater modularity. Code programmed by OOP generates abstractions levels which improve the design and make the software application in maintenance more comfortable to read and more adaptable to future extensions. This research shows how both standards (their latest updates) address OOP. Object-oriented programs in the field of automation engineering face another paradigm shift that impacts the methods used to program control systems. OOP would facilitate the design patterns implementations, which are a reusable understanding of common problems.

Object-oriented programming has often been advocated as a means of improving and enhancing the facilities provided by a given programming environment. This thesis is concerned with an examination of the benefits of providing object-oriented facilities in the Logic programming language - Prolog. We consider these benefits from two different perspectives, specifically examining what benefits Prolog can gain from objects, and conversely, what benefits object-oriented programming can gain from Prolog. A previously proposed model of object execution in Prolog was used as the basis of this research. In implementing this proposal we have critically examined how well the model supports the principles of object-oriented programming, and in those areas which we consider deficient, identified alternatives for improving the model which have subsequently been implemented for the purposes of assessment. The name we have selected for our augmented system is ObLog, drawn from Ob(jects) in (Pro)log. We critically examine the suitability of ObLog in terms of object-oriented programming by implementing a series of example applications based on a Block World specification. The thesis concludes by proposing some areas in which further research might usefully be conducted.

Describes how the object-oriented implementation language C++ has been incorporated into the first year of the software engineering curriculum in the School of Computer Science and Computer Engineering at La Trobe University. The reasons for choosing an object-oriented language are discussed, as well as the reasons for selecting C++ in particular. A revised course structure is presented that is based on an exercise in evaluating both the strengths and weaknesses of C++ as a first-year language. The resulting course structure provides a better learning framework for software engineering students.

Object-oriented design and programming are big topics—entire books are devoted solely to the process of object-oriented design or to using object-oriented programming in various languages and on various programming platforms. My focus in this book isn’t to teach the basics of object-oriented design or programming but rather to show how you may apply them to the creation of distributed. NET applications.KeywordsApplication ServerBusiness LogicBusiness ObjectMobile ObjectLogical LayerThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Object-oriented programming languages are suitable for describing real-world objects, functional programming languages for algebraic values. In this paper we propose an object-oriented functional programming language, called TOFL, which combines many desired properties of the two paradigms. In particular, TOFL unifies object classes, inheritance, (method) redefinitions and late binding as in object-oriented languages, algebraic data types, higher-order functions, type classes and type inference (without type reconstruction in this paper) as in functional languages. We translate TOFL into a stratified and explicitly typed λ-calculus T with overloaded functions, where redefinitions and late binding become late binding of overloaded functions. The operational semantics of T gives a semantics and a simple prototyping implementation of TOFL.

Describes the metamodelling approach towards evaluating the fit of object-oriented analysis and design (OOAD) methodologies to object-oriented programming (OOP) languages. Metamodelling has been applied successfully to evaluate and integrate OOAD methodologies. In this paper, the use of metamodelling is extended to describe OOP languages. This paper describes an approach to use OOAD and OOP metamodels to analyse the fit of OOAD methods to OOP languages. The approach is illustrated by evaluating the fit of Booch OOAD on Smalltalk, Eiffel and C++. It is concluded that using metamodelling an objective assessment of the match of an OOAD methodology to an OOP language can be made.

Generic Programming enables program constructs to be reused in a variety of situations. In programming languages, idea of generic programming is being opted through a variety of generic mechanisms. Generic mechanisms are either directly applied to pre-existing language constructs or it provides its own components for generic implementation. In this paper, we present such generic mechanisms in an organized way such that it appears as "one mechanism intensify other". Our aim is to exhibit generic evolution among mainstream object oriented programming languages (OOPLs). Hence, we analyze such approaches for better expressiveness and type-safety of generic programming as they evolved in OOPLs. This brief review article will help developers and researchers to precisely understand the generic mechanism in mainstream OOPLs.

An Open System Operational Semantics for an Object-Oriented and Component-Based Language