Input and Output Application Programming Interface for Plaid Standard Library

Awale game is one of the famous board games from Africa with many variants and is now played worldwide in various forms. In this paper, we propose an open-source Application Programming Interface (API) for developers to allow an easy implementation of the various variants of Awale as well as artificial intelligence based players. The API is available online at https://github.com/Machine-Intelligence-For-You/Awale. Based on this API, we propose a PC Awale game, a mobile Awale game, and an Augmented Reality Game. The Awale API, PC game, and mobile game are implemented in the programming language Java while the game in Augmented Reality is realized with the C# programming language, Unity 3D game engine and the Vuforia Augmented Reality SDK. The various tests carried out show that the API and the different games are totally functional. This API was also used for the first edition of MAIC, an Artificial Intelligence contest https://mify-ai.com/maic2017/.

Application Programming Interfaces (APIs) are everyday tools for every software professional. When creating an API, a designer typically abstracts the tasks the API intends to perform. The API user, on the other hand, should use the API to perform specific-propose tasks. During the development of an API, the designer needs to write dialogues with which the user will interact with the API, performing a conversation between them. In this way, an API capable of offering effective dialogues to its users is called a conversational API. A conversational API is the one that is capable of communicating to its users its form of use and its internal logic of operation, making it clear the design decisions when abstracting concepts and tasks. In this paper, we present Colloquy, an evidence-based method to support the design of conversational APIs. Colloquy was conceived based on the lessons learned from an action research we conducted to identify effective strategies for designing conversational APIs. For six months, we followed the redesign of an existing API developed at an R&D laboratory of a large IT company. In this paper, we also present the first empirical evaluation of Colloquy. We conducted a case study in which the method was employed to design an API for refactoring source code in the Java programming language. Among other benefits, we found that Colloquy was effective in developing empathy with users and modeling conversations with them. Besides, Colloquy contributed to identifying new requirements and created models as API documentation.

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.

A task-specific programming language (TSPL) is a domain-specific programming language (in programming languages terms) designed for a particular user task (in human-computer interaction terms). Users of task-specific programming are able to use the tool to complete useful tasks, without prior training, in a short enough period that one can imagine fitting it into a normal class (e.g., around 10 minutes). We are designing a set of task-specific programming languages for use in social studies and precalculus courses. Our goal is offer an alternative to more general purpose programming languages (such as Scratch or Python) for integrating computing into other disciplines. An example task-specific programming language for precalculus offers a concrete context: An image filter builder for learning basic matrix arithmetic (addition and subtraction) and matrix multiplication by a scalar. TSPLs allow us to imagine a research question which we couldn't ask previously: How much computing might students learn if they used a multiple TSPLs in each subject in each primary and secondary school grade?

Instead of writing SQL queries directly, programmers often prefer writing all their code in a general purpose programming language like Java and having their programs be automatically rewritten to use database queries. Traditional tools such as object-relational mapping tools are able to automatically translate simple navigational queries written in object-oriented code to SQL. More recently, techniques for translating object-oriented code written in declarative or functional styles into SQL have been developed. For code written in an imperative style though, current techniques are still limited to basic queries. JReq is a system that is able to identify complex query operations like aggregation and nesting in imperative code and translate them into efficient SQL queries. The SQL code generated by JReq exhibits performance comparable with hand-written SQL code.

An integrated object-oriented programming (OOP) approach for defining the abstract queueing system is described in this paper. It is based on a general purpose programming language, and is dedicated to flow control studies. The system runs on various platforms from a PC platform up to main frame platform. In addition, the system is equipped to interface with database packages and graphical packages. The system is designed to meet the demand of easier and more flexible flow control studies. Thus, such a system has been invaluable in providing a systematic approach to simulating the performance of flow control algorithms.

In large-scale software applications, programmers often combine different programming languages because this allows them to use the most suitable language for a given problem, to gradually migrate existing projects from one language to another, or to reuse existing source code. However, different programming languages have fundamentally different implementations, which are hard to combine. The composition of language implementations often results in complex interfaces between languages, insufficient flexibility, or poor performance. We propose TruffleVM, a virtual machine (VM) that can execute different programming languages and is able to compose them in a seamless way. TruffleVM supports dynamically-typed languages (e.g., JavaScript and Ruby) as well as statically typed low-level languages (e.g., C). It consists of individual language implementations, which translate source code to an intermediate representation that is executed by a shared VM. TruffleVM composes these different language implementations via generic access . Generic access is a language-agnostic mechanism that language implementations use to access foreign data or call foreign functions. It features language-agnostic messages that the TruffleVM resolves to efficient foreign-language-specific operations at runtime. Generic access supports multiple languages, enables an efficient multi-language development, and ensures high performance. We evaluate generic access with two case studies. The first one explains the transparent composition of JavaScript, Ruby, and C. The second one shows an implementation of the C extensions application programming interface (API) for Ruby. We show that generic access guarantees good runtime performance. It avoids conversion or marshalling of foreign objects at the language boundary and allows the dynamic compiler to perform its optimizations across language boundaries.

Generic programming is likely to become a new challenge for a critical mass of developers. Therefore, it is crucial to refine the support for generic programming in mainstream Object-Oriented languages — both at the design and at the implementation level — as well as to suggest novel ways to exploit the additional degree of expressiveness made available by genericity. This study is meant to provide a contribution towards bringing Java genericity to a more mature stage with respect to mainstream programming practice, by increasing the effectiveness of its implementation, and by revealing its full expressive power in real world scenario. With respect to the current research setting, the main contribution of the thesis is twofold. First, we propose a revised implementation for Java generics that greatly increases the expressiveness of the Java platform by adding reification support for generic types. Secondly, we show how Java genericity can be leveraged in a real world case-study in the context of the multi-paradigm language integration. Several approaches have been proposed in order to overcome the lack of reification of generic types in the Java programming language. Existing approaches tackle the problem of reification of generic types by defining new translation techniques which would allow for a runtime representation of generics and wildcards. Unfortunately most approaches suffer from several problems: heterogeneous translations are known to be problematic when considering reification of generic methods and wildcards. On the other hand, more sophisticated techniques requiring changes in the Java runtime, supports reified generics through a true language extension (where clauses) so that backward compatibility is compromised. In this thesis we develop a sophisticated type-passing technique for addressing the problem of reification of generic types in the Java programming language; this approach — first pioneered by the so called EGO translator — is here turned into a full-blown solution which reifies generic types inside the Java Virtual Machine (JVM) itself, thus overcoming both performance penalties and compatibility issues of the original EGO translator. Java-Prolog integration Integrating Object-Oriented and declarative programming has been the subject of several researches and corresponding technologies. Such proposals come in two flavours, either attempting at joining the two paradigms, or simply providing an interface library for accessing Prolog declarative features from a mainstream Object-Oriented languages such as Java. Both solutions have however drawbacks: in the case of hybrid languages featuring both Object-Oriented and logic traits, such resulting language is typically too complex, thus making mainstream application development an harder task; in the case of library-based integration approaches there is no true language integration, and some “boilerplate code” has to be implemented to fix the paradigm mismatch. In this thesis we develop a framework called PatJ which promotes seamless exploitation of Prolog programming in Java. A sophisticated usage of generics/wildcards allows to define a precise mapping between Object-Oriented and declarative features. PatJ defines a hierarchy of classes where the bidirectional semantics of Prolog terms is modelled directly at the level of the Java generic type-system.

The test and training enabling architecture (TENA) middleware is the result of a joint interoperability initiative of the Director, Operational Test and Evaluation (DOT&E) of the Office of the Secretary of Defense (OSD). The goals of the initiative are to enable interoperability among ranges, facilities, and simulations in a quick and cost-efficient manner, and to foster reuse of range assets and future range system developments. The TENA middleware uses Unified Modeling Language (UML)-based model-driven code generation to automatically create a complex Common Object Request Broker Architecture (CORBA) application. This model-driven automatic code-generation greatly reduces the amount of software that must be hand-written and tested. Furthermore, the TENA middleware combines distributed shared memory, anonymous publish-subscribe, and model-driven distributed object-oriented programming paradigms into a single distributed middleware system. This unique combination yields a powerful middleware system that enables its users to rapidly develop sophisticated yet understandable distributed applications. The TENA middleware offers powerful programming abstractions that are not present in CORBA alone and provides a strongly-typed application programmer interface (API) that is much less error-prone than the existing CORBA API. These high-level, easy-to-understand programming abstractions combined with an API designed to reduce programming errors enable users to quickly and correctly express the concepts of their applications. Re-usable standardized objects farther simplify the development of applications. The net result of this combination of features is a significant reduction of application programming errors yielding increased overall reliability and decreased overall development time. Distributed applications developed using the TENA middleware exchange data using the publish-subscribe paradigm. Although many publish-subscribe systems exist, the TENA middleware represents a significant advance in the field due to the many high-level, model-driven programming abstractions it presents to the programmer. The TENA middleware API relies heavily on compile-time type-safety to help ensure reliable behavior at runtime. Careful API design allows a great number of potential errors to be detected at compile-time that might otherwise go unnoticed until run-time - where the cost of an error could be extremely high! The implementation of the TENA middleware uses C++, as well as a real-time CORBA ORB. The TENA middleware is currently in use at dozens of Department of Defense (DoD) testing and training range facilities across the county and has been used to support major test and training events such as Joint Red Flag '05. The TENA Middleware is available at http://www.tena-sda.org/

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.

It is easier than ever before to build complex web applications that handle sensitive user data. At same time, regulatory shifts have made data breaches more costly than ever before.While starting Akita, I discovered just how difficult it is for software teams to maintain an up-to-date picture of how sensitive data flows across complex applications. A major challenge is that modern web applications run across many heterogenous components, often communicating via remote procedure calls. Unfortunately, network calls subvert all known software analysis methods for the application layer---and using network tools alone do not yield the full picture. The result is that developers end up piecing the whole story together through reading code, logs, and documentation.At Akita, we observed that network-based application programming interfaces (APIs) are both a root cause of what we call the Software Heterogeneity Problem---and also the key to the solution. The proliferation of APIs for both internal and external use, with the rise of service-oriented architectures and the growth of the API economy, have made it easy to quickly build applications that are amalgams of cross-service network calls. At the same time, there is consolidation around a handful of interface definition languages for web APIs. This makes it possible for us to address the Software Heterogeneity problem by applying programming languages techniques at the API layer.In this talk, I will introduce the Software Heterogeneity Problem and its consequences, demonstrate one way to tackle it at the API layer, and outline API-level security problems I believe we can solve as a community.

Although there has been widespread proliferation of creative-coding programming languages, the design of many toolkits and application programming interfaces (APIs) for expression and interactivity do not take full advantages of the unique space of mobile multitouch devices. In designing a new API for this space we first consider five major problem spaces and present an architecture that attempts to address these to move beyond the low-level manipulation of graphics giving first-class status to media objects. We present the architecture and design of a new API, called C4, that takes advantage of Objective-C, a powerful yet more complicated lower-level language, while remaining simple and easy to use. We have also designed this API in such a way that the software applications that can be produced are efficient and light on system resources, culminating in a prototyping language suited for the rapid development of expressive mobile applications. The API clearly presents designs for a set of objects that are tightly integrated with multitouch capabilities of hardware devices. C4 allows the programmer to work with media as first-class objects; it also provides techniques for easily integrating touch and gestural interaction, as well as rich animations, into expressive interfaces. To illustrate C4 we present simple concrete examples of the API, a comparison of alternative implementation options, performance benchmarks, and two interactive artworks developed by independent artists. We also discuss observations of C4 as it was used during workshops and an extended 4-week residency.

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.

Information appliances (IAs) are able to interact and share information with each other using their communication abilities. However, current inter-IA interaction development using the general purpose programming language, e.g., C/C++ and Java approach, involves lots of time for system development process, i.e., (1) program writing, (2) source code compilation, (3) executable code loading, and (4) executable code distribution. In this paper, we introduce the concept of instantaneous reflection of inter-IA interaction development to help fast inter-IA interaction development without going through the above 4 processes. In this paper, we have designed an Inter-IA Interaction Development Platform (I^2DP) that enables instantaneous reflection of inter-IA interaction development using the high level script language approach. Main components of the I^2DP platform architecture include (ⅰ) IAs and (ⅱ) Administration Gateway that is responsible for the inter-entity communication and execution of inter-IA interactions. The core of I^2DP consists of (ⅰ) Service Invocation Protocol (SIP), which is a control protocol for IAs, and (ⅱ) Service Interaction Script language (SIS), which is a script language that can specify inter-IA interactions. As a result, instantaneous reflection of inter-IA interaction development using high level script language can be achieved in I^2DP.

The paper examines the necessity and possibility of interface interaction of the information modeling program Revit Autodesk with the common office program MS Excel. Such interaction makes it easier to prepare project documentation in accordance with the requirements of Russian standards, GOST. An analysis of the capabilities of the built-in Revit tools for creating specifications and their design according to GOST requirements showed an insufficient level of automation of these processes. Ready-made foreign and Russian solutions in the field of Revit plugins that implement interaction with Excel have a number of disadvantages. The purpose of this article is to demonstrate the capabilities of the application programming interface (API) for creating applications using the example of a developed software solution for automating the unloading of information from a BIM model into an Excel electronic document, in order to bring data presentation standards in line with GOST requirements. The application is developed using a tool environment: the C# programming language, the MS Visual Studio development environment, the WPF user interface creation tool, the Revit-side application programming interface .Net API, an interface for interacting with Excel ClosedXML files. As a result, the interface of the developed plugin is presented. The program allows you to export documents-statements and specifications - to Excel, designed according to the requirements of GOST. The user-friendly tab-based user interface, the compliance of the program design with the Revit system and the implemented functionality give the program advantages over its analogues. The application is available for free download to any Revit user, which is of practical importance.