JASMINE: A Java Tool for Multimedia Collaboration on the Internet

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.

In this paper, the authors propose a smart home-care system built on an Android smartphone. The database and application programming interface (API) are set up on the server side. The database collects information from various sensors and stores it, and the API acts as a bridge between the mobile phone and the database. The API prevents the leakage of private data. In the associated Android smartphone app, two functions are provided: instant monitoring based on in-home sensor data and fall detection using the three-axis accelerometer, gyroscope, and orientation sensor inbuilt into the smartphone. When the sensor data are abnormal, the remote controller is notified immediately. Moreover, the remote controller can view real-time images by using an IP camera to guarantee home safety. As for fall detection, given that falls cause severe injuries in elder people and children, the proposed app can detect a fall event, send a help message, and indicate the user’s location by using the global positioning system and Google Maps API. According to the simulation results obtained in this study, the proposed system exhibited a fall-detection sensitivity of 92.5% and specificity of 97.6%, thus proving that the system can be effectively used for home care.

Chapter 6 - Sockets and middleware

Recently, scripting languages have received growing attention from the software engineering community. With the advent of Java, existing scripting languages have started to integrate with the rich API of the Java platform. In this work we introduce Iava, an interpreter for scripting the Java platform. In contrast to existing scripting languages for the Java platform, the Iava interpreter accepts a strict subset of Java. Iava is implemented in Java using the reflection Application Programming Interface (API) and can be integrated into any Java-based application. This article describes why we consider scripting Java software systems with Iava a useful approach. We explain why Iava only accepts a subset of Java and what the difference between that subset and the full language is. We describe the implementation patterns that provide a high level of integration between Iava and embedding Java classes. We demonstrate the benefits of Iava using a scriptable text editor. As another example for the use of Iava, we integrate Iava with an existing framework for class testing (Ref. [1], Beck K, Gamma E. Test infected: Programmers love writing tests. Java Report; SIGS Publications, 1998.). We sketch how to use Iava for distribution script processing – a useful tool for testing distributed Java applications. Copyright © 2000 John Wiley & Sons, Ltd.

The authors analyzed the file system of Windows Mobile,and studied the structure and call logic of the system Application Program Interface(API).Then a way establishing hook function for the system API to intercept the relevant API operations was put forward as the basis of the design and implementation of the file monitoring system based on Windows Mobile.The experimental results show that the system can monitor all file access operations.

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.

SPEED is a hardware and software platform gaining wide acceptance for use as the basis of many wireless, service node, and converged network applications in Lucent Technologies. It is optimized to provide high performance, scalability, and highly reliable bearer channel processing at industry-leading density and cost. It comprises a backplane, several types of circuit modules, and a suite of system software and application programming interfaces (APIs). The SPEED platform provides functions such as interfaces (for example, IP, ATM, and TDM at rates up to 622 Mb/s), bandwidth management, digital signal processing, protocol processing and adaptation, call control, feature control, and operations, administration, maintenance, and provisioning (OAM&P). This paper introduces programmable bearer channel processing platforms and discusses the history and architecture — both hardware and software — of the SPEED platform. It also includes five case studies of current SPEED applications in wireless and converged voice/data networks. The final section of this paper presents an overview of some future platform evolution work.

This paper describes our ongoing work on developing a multimedia data processing toolbox for the Khoros system. We first identify the functions commonly used in processing multimedia information. We then discuss how we implement these functions based on the Khoros system data structures and application programming interfaces (API). So far we have developed utilities for format conversion, editing, color conversion, etc., while the implementation of audio and video analysis algorithms is under way.

Containers simplify the packaging, deployment and orchestration of diverse workloads on distributed infrastructure. Containers are primarily used for web applications, databases, application servers, etc. on infrastructure that consists of CPUs, Memory, Network and Storage. Accelerator hardware such GPUs are needed for emerging class of deep learning workloads with unique set of requirements that are not addressed by current container orchestration systems like Mesos, Kuberentes, and Docker swarm. In this extended abstract, we discuss the requirements to support GPUs in container management systems and describe our solutions in Kubernetes. We will conclude with a set of open issues that are yet to be addressed to fully support deep learning workloads on distributed infrastructure.Operating system (OS) allows flexible sharing and load balancing of resources like CPU, Memory and Network among multiple processes and containers. Unlike these GPU's are unique quantities (GPU 0, GPU 1, ...) and they must be allocated accordingly (e.g., allocate GPU 0 to Container 1). GPU topology, will heavily affect the bandwidth of GPU to GPU communication and must take into consideration. Moreover, GPU topology even affects GPU capabilities. In some systems, for example, GPUs on different CPU socket cannot have Peer to Peer communication capability.To address these issues, firstly, we have enabled GPU support on Kubernetes. We implemented a GPU allocator module to record GPU number-to-device mapping. Kubernetes users only request number of GPUs need for their workload; GPU allocator module maps the number to actual GPU devices according to required scheduling policy and expose the allocated GPUs to application inside the container. Secondly, we have developed two advanced GPU schedulers, a bin-packing scheduler and a topology-aware scheduler, to improve GPU utilization and GPU performance. Bin-packing scheduler tries to bundle GPU jobs to fewer servers, so that other idle servers can be reserved for potentially large jobs. Topology-aware scheduler can automatically collect GPU topology information of each worker node, and assign nodes that deliver the highest possible bandwidth to the application.Access to CPU, Memory, Network and Storage devices are abstracted by operating system (OS) application programming interface (API) calls. The OS translates the application calls into device specific calls internally. Unlike these resources, GPUs have device access calls that are not yet abstracted under OS API's so applications that require access to GPU devices need those GPU devices mounted inside the container, they need access to auxiliary device interfaces (like nvidia-uvm), and they need the GPU drivers inside that container. The device driver inside the container must exactly match the driver on the host for proper operation. To solve these issues, we enhanced Kubernetes to gather the device drivers on kubelet startup and mount these drivers into the container automatically. This ensures portability of the workloads across systems with potentially different drivers. A similar approach is taken by Mesos, Nvidia Docker and other systems.In addition, unlike CPU and memory, GPU is an external PCIe device and in our experience it experiences software and hardware failures far more frequently than the rest of the system. Failures could include bad connection to the PCIe slot, GPU kernel crash, bad power supply, and so on. To deal with such issues, we enabled GPU liveness check on Kubernetes (like the liveness check in any cloud service). The kubelet periodically checks the healthiness of GPU devices. Once the GPU failure is detected, the GPU will automatically be removed out from the resources pool.Finally to support multiple users, we added GPU quota support in Kubernetes so that GPU resources can be limited by different namespaces; We auto-labeled GPU devices model to Kubernetes worker nodes so that the job can use such information to filter GPUs. All these new features are originated from our real requirements and aim to enhance the usability of GPUs in a cloud context.We consider GPU related scheduling policy and algorithm to improve both GPU performance and utility as open issues. We plan to extend CPU topology and affinity support to Kubernetes, so that we can make CPU-GPU joint topology optimized scheduling. The exploration of CPU-GPU bandwidth will bring more possibilities for performance improvement especially for servers with NVLink technology (like IBM Minsky) between CPU-GPU.

Collection/Distribution process is nowadays an increasingly important technique in smart applications. It is having highly uncertain behaviors due to variable node capacity. To deal with this Internet of Things (IoT) techniques are mentioned in this paper. It provides real-time information about the status of statically defined nodes. System communication is implemented by using IoT lightweight protocol. In the proposed work Decision Support System (DSS) is designed in order to improve operations efficiency for transportation. This information is used for forming a route for collection/distribution purpose using effective routing algorithm. With the help of Geographical Information System (GIS) and Geo-location Application Programming Interface (API), the formation of an optimal route is done. This paper presents designing and development of collection/distribution process framework with preliminary level results. It will guarantees minimization in a load of collection/distribution system and transportation costs with respect to time, money, distance and It also makes route selection process automotive.

The paper proposes a new approach as an alternative to full automation of processes that meets current economic trends — collaborative multi-agent systems. In this concept, people and robots are considered as agents in a single sensory-information field, who perform tasks to achieve the goals of the collaborative multi-agent system. The urgency of collaborative multi-agent systems results from the fact that the industrial use of fully automated multi-component systems is limited by the financial and infrastructural unavailability of various industries to switch to completely unmanned technologies. The proposed approach combines the latest, but remaining quite recouped, technological advances along with highly skilled human labor. The use of collaborative multi-agent systems will be economically justified in the manufacture of products in small batches, in the conditions of rapid change of product lines, as well as the presence of staff shortages. The article shows that such an approach can significantly reduce automation costs, while ensuring that the specified production indicators are met. This approach allows taking a fresh look at a human, considering him and a robot as equal partners within a collaborative system. The basic concepts and distinctive characteristics of collaborative multi-agent systems are formulated and presented in the work, justifications for their use are given. Creating a new class of collaborative multi-agent systems requires solving a number of problems associated with the interaction of man and robot. The article considers issues related to the work of a person within a collaborative system, with a rational separation of human functions and an automated production system, in accordance with the necessary level of collaboration. The inclusion of a person with his psychoemotional and physical characteristics as an equivalent agent of a multi-agent system causes difficulties in formalizing collaborative multi-agent systems associated with the need to take these features into account and create a sensory-information system. The inclusion of a person with his psychoemotional and physical characteristics as an equivalent agent of a multi-agent system causes difficulties in formalizing collaborative multi-agent systems associated with the need to take these features into account and create a sensory-information system. The paper discusses ways to formalize a collaborative multi-agent system and management approaches.

Object oriented (OO) is the most accepted object modeling languages nowadays. Although OO languages are successful in modeling real world entities, nevertheless, there is little to no support for modeling state of object precisely in code. To overcome this problem, a new general purpose programming language is proposed that is built on two paradigms which are typestate-oriented and permission-based. One of the most vital factor for every language to be accepted and effective for users is having an enhanced standard library and clearly one of the most important parts is Input and Output (I/O) Application Programming Interface (API). One of a new programming language is Plaid language. Since the Plaid is at its early stage of development, I/O features provided by the Plaid standard library are very basic and limited. This paper presents I/O API that we have developed for the Plaid based on the features provided by Java I/O API. For the evaluation we used two metrics which are the number of features provided by I/O API, and the number of exceptions eliminated by using Plaid and typestate-oriented programming language.

Computing Languages for Bioinformatics: Java

: This document is a textual comparison study of the IEEE 1003.1 Portable Operating System Interface (POSIX) - Part 1: System Application Program Interface (C Language) (IEEE 1003.1:1990) and X/OPEN Single UNIX Specification (SUS). The purpose of this document is to aid in determining the criteria needed for the successor to FIPS PUB 151-2. It can also be used as a tool to ascertain the differences between the two specifications. However, note that this document does not attempt to address application portability concerns between the two specifications. To determine the application portability of some commands between an XPG4 UNIX-Branded implementation and a PIPS 151-2 certified implementation, further study is required.