Showing papers on "Java API for XML-based RPC published in 2015"

K-Java: A Complete Semantics of Java

Abstract: This paper presents K-Java, a complete executable formal semantics of Java 1.4. K-Java was extensively tested with a test suite developed alongside the project, following the Test Driven Development methodology. In order to maintain clarity while handling the great size of Java, the semantics was split into two separate definitions -- a static semantics and a dynamic semantics. The output of the static semantics is a preprocessed Java program, which is passed as input to the dynamic semantics for execution. The preprocessed program is a valid Java program, which uses a subset of the features of Java. The semantics is applied to model-check multi-threaded programs. Both the test suite and the static semantics are generic and ready to be used in other Java-related projects.

Use at your own risk: the Java unsafe API in the wild

Abstract: Java is a safe language. Its runtime environment provides strong safety guarantees that any Java application can rely on. Or so we think. We show that the runtime actually does not provide these guarantees---for a large fraction of today's Java code. Unbeknownst to many application developers, the Java runtime includes a "backdoor" that allows expert library and framework developers to circumvent Java's safety guarantees. This backdoor is there by design, and is well known to experts, as it enables them to write high-performance "systems-level" code in Java. For much the same reasons that safe languages are preferred over unsafe languages, these powerful---but unsafe---capabilities in Java should be restricted. They should be made safe by changing the language, the runtime system, or the libraries. At the very least, their use should be restricted. This paper is a step in that direction. We analyzed 74 GB of compiled Java code, spread over 86,479 Java archives, to determine how Java's unsafe capabilities are used in real-world libraries and applications. We found that 25% of Java bytecode archives depend on unsafe third-party Java code, and thus Java's safety guarantees cannot be trusted. We identify 14 different usage patterns of Java's unsafe capabilities, and we provide supporting evidence for why real-world code needs these capabilities. Our long-term goal is to provide a foundation for the design of new language features to regain safety in Java.

Apiwave: Keeping track of API popularity and migration

Abstract: Every day new frameworks and libraries are created and existing ones evolve. To benefit from such newer or improved APIs, client developers should update their applications. In practice, this process presents some challenges: APIs are commonly backward-incompatible (causing client applications to fail when updating) and multiple APIs are available (making it difficult to decide which one to use). To address these challenges, we propose apiwave, a tool that keeps track of API popularity and migration of major frameworks/libraries. The current version includes data about the evolution of top 650 GitHub Java projects, from which 320K APIs were extracted. We also report an experience using apiwave on real-world scenarios.

A tool to improve code-first Web services discoverability through text mining techniques

Abstract: Service-oriented development is challenging mainly because Web service developers tend to disregard the importance of the exposed service APIs, which are specified using Web Service Description Language WSDL documents. Methodologically, WSDL documents can be either manually generated or inferred from service implementations using WSDL generation tools. The latter option, called code first, is the most used approach in the industry. However, it is known that there are some bad practices in service implementations or defects in WSDL generation tools that may cause WSDL documents to present WSDL anti-patterns, which in turn compromise the chances of documents of being discovered and understood. In this paper, we present a software tool that assists developers in obtaining WSDL documents with as few WSDL anti-patterns as possible. The tool combines text mining and meta-programming techniques to process service implementations and is developed as an Eclipse plug-in. An evaluation of the tool by using a data-set of real service implementations in terms of anti-pattern avoidance accuracy and discovery performance by using classical Information Retrieval metrics-Precision-at-n, Recall and Normalized Discounted Cumulative Gain-is also reported.Copyright © 2014 John Wiley & Sons, Ltd.

Interactive synthesis using free-form queries

Abstract: We present a new code assistance tool for integrated development environments. Our system accepts free-form queries allowing a mixture of English and Java as an input, and produces Java code fragments that take the query into account and respect syntax, types, and scoping rules of Java as well as statistical usage patterns. The returned results need not have the structure of any previously seen code fragment. As part of our system we have constructed a probabilistic context free grammar for Java constructs and library invocations, as well as an algorithm that uses a customized natural language processing tool chain to extract information from free-form text queries. The evaluation results show that our technique can tolerate much of the flexibility present in natural language, and can also be used to repair incorrect Java expressions that contain useful information about the developer's intent. Our demo video is available at http://youtu.be/tx4-XgAZkKU.

SWIN: Towards Type-Safe Java Program Adaptation between APIs

Abstract: Java program adaptation between different APIs is a common task in software development. When an old API is upgraded to an incompatible new version, or when we want to migrate an application from one platform to another platform, we need to adapt programs between different APIs. Although different program transformation tools have been developed to automate the program adaptation task, no tool ensures type safety in transforming Java programs: given a transformation program and any well-typed Java program, the transformed result is still well-typed. As a matter of fact, it is often observed that a dedicated adaptation tool turns a working application into a set of incompatible programs. We address this problem by providing a type-safe transformation language, SWIN, for Java program adaptation between different APIs. SWIN is based on Twinning, a modern transformation language for Java programs. SWIN enhances Twinning with more flexible transformation rules, formal semantics, and, most importantly, full type-safe guarantee. We formally prove the type safety of SWIN on Featherweight Java, a known minimal formal core of Java. Our experience with three case studies shows that SWIN is as expressive as Twinning in specifying useful program transformations in the case studies while guaranteeing the type safety of the transformations.

Dripcast - Architecture and Implementation of Server-less Java Programming Framework for Billions of IoT Devices

Abstract: We propose “Dripcast,” a new server-less Java programming framework for billions of IoT (Internet of Things) devices. The framework makes it easy to develop device applications working with a cloud, that is, scalable computing resources on the Internet. The framework consists of two key technologies; (1) transparent remote procedure call (2) mechanism to read, write and process Java objects with scale-out style distributed datastore. A great benefit of the framework is that there is no need to write a server-side program nor a database code. A very simple client-side program is enough to work with the framework, to read, write or process Java objects on a cloud. The mechanism is infinitely scalable since it works with scale-out technologies. In this paper, we describe the concept and the architecture of the Dripcast framework. We also implement the framework and evaluate from two points of views, 1) from the view point of scalability about cloud resources, 2) from the view point of method call encapsulation overhead in client IoT devices.

Assisting developers to build high-quality code-first web service APIs

Abstract: Searching and understanding Web Services is challenging mainly because service developers tend to disregard the importance of the exposed service APIs. In many situations these APIs are defined using WSDL documents, which are written in an XML dialect. Service developers can opt between manually writing these documents or inferring them from service implementations. This work is focused on the later methodology and provides techniques and tools for generating WSDL documents avoiding wellknown bad practices (e.g., lack of textual comments or representative names) that compromise Web Service API quality. Our experiments show that by using our approach the obtained WSDL documents are more likely to be free from these undesirable practices so they better describe service functionality. In addition, these experiments show that the WSDL documents generated using our approach also have other important quality-related features, such as less redundant data-type definitions and better defined data-types. Experiments have been performed by comparing our proposal against WSDL generation tools/approaches from both the industry and the academy.

Web portal api test report generation

Abstract: A system for generating application programming interface (“API”) test reports for a software application derives one or more Java APIs to be tested from the software application and derives Java Unit (“JUnit”) test methods used to test the Java APIs. The system then maps each Java API with a corresponding JUnit test method and generates one or more test reports.

Enhanced security for java virtual machines

Abstract: A computer architecture providing enhanced JVM security and a method of providing enhanced security for a JVM are disclosed. The host computer runs a single, first, trusted JAVA API library above which is located a hypervisor software layer, and then at least one untrusted JAVA API library. The code of each second, upper, untrusted JAVA API library is modified at, or before runtime to call the hypervisor software layer instead of the JVM to thereby create a silo corresponding to each of the second, upper, untrusted JAVA API libraries. Each silo extends between the host computer and the corresponding second, upper, untrusted JAVA API library. The hypervisor software layer is operated to only permit communication between each of the second, upper, untrusted JAVA API libraries and a corresponding portion of the memory and functional assets of the host computer. Consequently, each of the second, upper, untrusted JAVA API libraries cannot communicate with all of the host computer memory and/or all of the host computer functional assets. A computer program product is also disclosed.

Programming Google App Engine with Java: Build & Run Scalable Java Applications on Google's Infrastructure

Abstract: This practical guide shows intermediate and advanced web and mobile app developers how to build highly scalable Java applications in the cloud with Google App Engine. The flagship of Google's Cloud Platform, App Engine hosts your app on infrastructure that grows automatically with your traffic, minimizing up-front costs and accommodating unexpected visitors. Youll learn hands-on how to perform common development tasks with App Engine services and development tools, including deployment and maintenance.For Java applications, App Engine provides a J2EE standard servlet container with a complete Java 7 JVM and standard library. Because App Engine supports common Java API standards, your code stays clean and portable.Get a hands-on introduction to App Engine's tools and features, using an example applicationSimulate App Engine on your development machine directly from EclipseStructure your app into individually addressable modules, each with its own scaling configurationExploit the power of the scalable Cloud Datastore, using queries, transactions, and data modeling with JPAUse Cloud SQL for standard relational databases with App Engine applicationsLearn how to deploy, manage, and inspect your application on Google infrastructure

Pro Java 8 Programming

Abstract: Pro Java 8 Programming covers the core Java development kit and the finer points of the core standard edition (SE) and development kit version 8. You'll discover the particulars of working with the Java language and APIs to develop applications in many different contexts. You will also delve into more advanced topics like lambda expressions, closures, new i/o (NIO.2), enums, generics, XML, metadata and the Swing APIs for GUI design and development. By the end of the book, youll be fully prepared to take advantage of Java's ease of development, and able to create powerful, sophisticated Java applications. What youll learn How to use and design your own libraries, classes and methods How to use the new lambda expressions, closures, stream API and more How to use the new thread and I/O APIs for today's Java applications that must perform at enterprise and parallel scales How to use the improved collections APIs How to build a better Java UI/UX using layout managers, Swing's JTable and JTree APIs, cut-and-paste, and drag-and-drop How to use Java Database Connectivity (JDBC) to connect and integrate with various MySQL, Oracle, and No SQL databases How to work with internationalization, localization and more How to effectively use XML and add annotations to your Java applications and more Who this book is for This book is for experienced Java programmers or developers looking to further refine or add to their skills and knowledge base.

Test case selection for regression testing of applications using web services based on WSDL specification changes

Abstract: There is much enthusiasm around web services in today's world. Web Services take the advantage of internet to communicate between two electronic devices connected via a network. Testing a Web Service is a challenge as the Service Requester does not have the source code and somehow needs to fully test the impact of changes on his application. Regression testing verifies the integrity of the application and makes sure that the changes have not introduced new software errors. Our approach involves the parsing of the WSDL XML file to extract information regarding the operation name, input message and output message. Both the original and changed XML files for the web service are parsed to extract their respective information from the port type and message element of WSDL. Then, we generate a hash table form the extracted information for both the original and delta WSDL. We pass the hash tables to a Comparator as input, which then compares the hash tables and generates the operation changes as output. In the last step test cases are selected for regressing testing of the changed web service based upon the changes in operations provided by the comparator.

Automatic generation of test data for XML schema-based testing of web services

Abstract: Service-Oriented Architecture (SOA) is a widely accepted paradigm for development of distributed applications using interoperable and flexible software components. Still the preferred technology for SOA implementation is provided by the web services. Their interface as well as complex interactions are described with XML-based standards, such as Web Service Description Language (WSDL) and Business Process Execution Language for Web Services (WS-BPEL). The WSDL and WS-BPEL documents allow automation of test data generation through instantiation of the referenced XML Schemas. The approach proposed in this paper is a step towards such goal. It provides derivation of XML instances from a given XML Schema. The approach is automated in a software tool supporting data-driven test definition. The tool automatically extracts an XML Schema form a WSDL or WS-BPEL documents and generates XML messages needed for web service interactions. Since the proposed approach supports generation of both correct and incorrect XML instances, the tool is applicable to functional as well as robustness testing of web services.

A modelling language for the effective design of Java annotations

Abstract: This paper describes a new modelling language for the effective design of Java annotations. Since their inclusion in the 5th edition of Java, annotations have grown from a useful tool for the addition of meta-data to play a central role in many popular software projects. Usually they are conceived as sets with dependency and integrity constraints within them; however, the native support provided by Java for expressing this design is very limited. To overcome its deficiencies and make explicit the rich conceptual model which lies behind a set of annotations, we propose a domain-specific modelling language. The proposal has been implemented as an Eclipse plugin, including an editor and an integrated code generator that synthesises annotation processors. The language has been tested using a real set of annotations from the Java Persistence API (JPA). It has proven to cover a greater scope with respect to other related work in different shared areas of application.

A new customizable security framework for preventing WSDL attacks

Abstract: The Service Oriented Architecture (SOA) has emerged as a dominant paradigm in the recent era for Enterprise Application Integration (EAI). Web Services are the implementation of SOA, where a service is Software component which does a specific functionality and does not depend on the context of other services. These services support distributed functionalities which operate irrespective of machine architectures, operating systems and programming languages; where the data transmission is done through the simple Internet protocols such as HTTP in Web Services. As the data is transferred in XML format which is a plain text, it is prone for attacks. The Web Service Description Language (WSDL) is an XML document that describes the services including their input/output parameters, while Simple Object Access Protocol (SOAP) describes the communication part. The standard SOA does not provide any sufficient security mechanisms for both WSDL and SOAP messages. Through literatures, it has been shown that there is a huge interest in developing solutions for SOAP message level attacks; however, there is not much on WSDL attacks. As a matter of fact, the WSDL attacks are severe in nature which can even halt the entire web services down. An attacker can reveal sensitive information as well as can interpret the list of operations that are provided by the web services. In this paper, the possible WSDL attacks are critically analyzed with their impact. A new SOA security framework which prevents the WSDL attacks and preserves the confidentiality and integrity of transmitted WSDL document is proposed. This framework effectively applies available security standards, and as a novelty it uses Artificial Neural Networks for knowledge acquisition of WSDL attacks dynamically.

Practices of fill-in-blank problem s in Java programming course

Abstract: To assist Java programming educations, we have developed a Web-based Java Programming Learning Assistant System (JPLAS). JPLAS provides fill-in-blank problems to study the Java grammar by filling blank elements in a high-quality code that are composed of reserved words, identifiers, and control symbols. A graph-based blank element selection algorithm has been proposed to automatically select as many blanks as possible that have grammatically correct unique answers. In this paper, we show and discuss their application results to a Java programming course in our department.

Study on Rainfall Information Integration System Based on Java Web Start

Abstract: To avoid the shortcomings of traditional methods of software deploy, this paper analyzed the principles and advantages of adopting Java Web Start (JavaWS) to deploy the applications of client, put emphasis on transforming applications to jar file, digitally signed the file and created Java Networking Language Protocol (JNLP) file, and the applications were finally accessed by web server. Application of rainfall information integration system based on the WebGIS in Shaanxi province indicates the convenience and security of the system when using JavaWS, which allows users to deploy and use the system offline, and thus it has a good prospect.

Using of the client-side computations when implementing web services for spatial data processing, the case study of java web start technology

Abstract: One of the key areas of Web geotechnology development is the implementation of software tools and systems, which are capable not only to display geospatial data in the Web interface, but also to provide functionality for processing and analysis directly in the browser window. Significant feature of current Web-based geospatial standards is the focusing on server-side data processing. Our study investigates possibilities and general ways of decentralized data processing implementation on the client side in the case of using the Java Web Start technology. The test software tools are developed that implements capability of transmitting the executable program code to the client computer through the Web interface and spatial data processing on the client side.

urHL7: An HL7 parsing and manipulation library

Abstract: With increasing pace, hospitals and other healthcare entities are adopting technology to assist with workflow and data handling. While many benefits can be realized from this, working with disparate legacy and emerging systems can be problematic. Most critical is the handling of information that is transferred between these many systems. Incorrect interpretation of data can lead to problems as “simple” as incorrect billing or as severe as those dealing with human life. Historically, message oriented middleware and the HL7 message format have provided the framework for the necessary information exchange. While this approach is robust, it is also cumbersome requiring many hours of very specific coding effort to solve even simple problems. This once-appropriate approach is inconsistent with our current needs for agility and flexibility in enterprise computing systems. Some tools and libraries have emerged to help address this situation, but each has limitations. In this paper we describe the landscape that necessitates these tools, examine some of the current tools, and offer an alternative that is an open-source library leveraging native Java objects and methods to: parse raw HL7 version 2 message data to internal data structures, provide an API to allow for the efficient and simple access and manipulation of underlying data elements in the HL7 version 2 data, minimize the complexity of standard I/O functions that are generally required when working with HL7 version 2 messages, and create a durable, reusable core library that can be expanded upon with extensions.

Unified compile-time and runtime java annotation processing

Abstract: Java provides two different options for processing source code annotations. One of them is the annotation processing API used in compile time, and the other is the Reflection API used in runtime. Both options provide different API for accessing program metamodel. In this paper, we examine the differences between those representations and we discuss options on how to unify these models along with advantages and disadvantages of this approach. Based on this proposal, we design a unified Java language model and present a prototype tool which can populate a unified model during both compilation and runtime. The paper includes the designed API of this unified language model. To verify our approach, we have performed experiments to show the usability of the unified metamodel.

Design of Information Interaction System Based on Android and JAVA EE architecture

Abstract: Android system is currently the most frequently used smart mobile operating system, lightweight JAVA EE architecture has good stability, extensibility and compatibility, therefore it has been widely applied in the development and design of system. In this paper, information interaction platform based on the communicative community interaction has been designed, using Android intelligent mobile system and JAVA EE architecture, and optimization design was carried out on the information network system by using the least squares algorithm, generally mobile web page has been converted into mobile portable devices using JAVA programming technology. In the end, the development environment and the interface of the system for the information interaction platform has been set up. It is found that system platform can run smoothly through the mobile phone testing of Android4.0 above version, which provides a theoretical reference and technical support for the design of the interactive information database. Introduction The mobile Internet Based on the Android is is one of the most attractive prospects, the largest market potential and the fastest growing industry in recent years. As now the biggest sales of intelligent mobile operating system, Android is at the forefront of the wave of mobile internet now., but also in the forefront of the mobile Internet wave. People in communication community accept new things faster and faster in current society, and they is eager to demand more and more interaction information for others, so it has a broad prospect that provide portable interactive system based on Android for communication community. The abbreviation of lightweight Java EE standard is SSH. Unlike traditional Java EE platform need the support of the EJB server, the application based on lightweight Java EE platform can run in ordinary Web server, and SSH has excellent stability and expansibility and maintainability. In this paper, the information interaction system based on the Android intelligent system and JAVA EE architecture has been designed using the SSH platform of, the main design process is shown in figure 1. The general process of information interaction system has been shown in Figure 1. As shown in figure 1 in this paper, we use Android intelligent mobile system and use the Web server as compatible server., combined with the JAVA EE framework for system development. Using MyEclipse 9.0 application integration environment, the application system database is obtained by integration development at last, on the basis of the database we can complete the development of information interaction system. International Conference on Information Sciences, Machinery, Materials and Energy (ICISMME 2015) © 2015. The authors Published by Atlantis Press 1978 Fig.1 The main design process of information interaction system The information network optimization algorithm design based on the Android and JAVA EE architecture In development and design of android mobile information network system, the network node processing of JAVA EE architecture is one of the most key factors to improve network performance, we use the least squares algorithm to optimize design in the paper. First we assume that the node array of JAVA architecture is ) , )......( , ( ), , ( 3 2 1 1 n n s x s x s x ,then we can get the formula (1). i i i X nx s s λ + + = (1) The node n value can be optimized by least square algorithm, the estimate value can be written as shown in formula (2).

Teaching Object-Oriented Programming: A Comparison Of Java And Objective-C

Abstract: The programming language Java has been for many years the language in which many Web applications as well as large server applications have been developed. More recently, it has also been used in the development of Android applications. It has often been adopted as the primary teaching language in both introductory and advanced programming courses. Due to its use on the iPhone and the iPad, Objective-C is gaining popularity and is now taught in some programming courses. Not as well designed as Java and not as general-purpose as Java, Objective-C is unlikely to supplant it in college courses.

Java Tool Extensions for Supporting Multiple Recommenders and Distributed Bundles

Abstract: A JAR (Java Archive) is typically used to incorporate code and associated resources into one file to distribute Java software. A cryptographically signed JAR file provides assurance about the authorship of the contents of the archive. We use Signed JAR files as part of a recommendation system. In this system different recommenders will evaluate the same software, and they need to sign the exact same JAR file. The user wants to verify that recommendations (i.e., signatures) received independently from multiple parties, e.g., for a software update, pertain to the exact same software. Related problems occur when users try to sign bundles consisting of files maintained on different servers. The tools in the Java Development Kit do not support this kind of application. We propose techniques to enable the signing of distribute bundles and techniques by which recommenders can sign software independently and such that verifiers are enabled to combine the recommendations. There changes to the Java jarsigner tool would avoid special purpose code which duplicates many of the same capabilities of the existing tools.

Analysis of Java programs using Joana and Java SDG API

Abstract: JOANA (Java Object-sensitive Analysis) and Java SDG API are analysis frameworks available for analyzing Java programs for different applications Now a days, the continuous evolution of the customer expectations and requirements has resulted in the increase of size of the software Due to which the difficulties in maintaining software are increasing Both Joana and Java SDG API consist of a variety of analysis techniques based on dependence graph generation and computation of slices of an input program In this paper, we make a comparative analysis study on the effectiveness and efficiency of both these above mentioned analysis frameworks in generating the corresponding intermediate dependence graph and computing slices The analysis is based on the bytecode of the program under consideration The experimental analysis shows that Joana can be extended for various diverse applications

Java/Javascript software for calcium buffer calculations

Abstract: Calcium buffer EGTA Java Javascript Multiple equilibria Java and Javascript software based upon the calculator programs of Fabiato and Fabiato are presented. The programs compute the free metal concentrations resulting from a given buffer composition and/or the composition required to achieve desired free concentrations, both for an arbitrary set of metals and ligands. The prevalence, object-orientation, IDE availability, and platform independence of the Java programming language further the accessibility of these algorithms for use and modification, while the Google Web Toolkit permits “compilation” of Java source code directly into Javascript for fast loading and execution within a desktop- or smartphone-based web browser.

Java 8: It’s a Whole New Java

Abstract: This book is about lambdas (closures) in Java 8. More than that, though, it’s about the new language that Java has become. The revolution was not televised, and it was met with little fanfare, but it has happened. It is possible for you to continue to write the same old Java code in our new Java 8 world, but unless you get onboard with the revolution, you will increasingly discover code that is called “Java,” but which has language, syntax, and customs that are foreign to you.

Migrating from legacy to SoA (Invited Talk)

Abstract: This presentation discusses a strategy for migrating to a service-oriented architecture. The starting point is legacy code in a procedural or object-oriented language. The result is a set of web services that can be accessed in a private or public cloud. The technique used is to cut out selected portions of code and to wrap them behind a service interface. The code itself can be left in the original language. The service interface is in WSDL. The speaker describes how to go about selecting code for reuse and how to extract that code from its current environment. Case studies are given for the languages COBOL and Java. The presentation then goes on to describe how to test the services using a web service testing tool which generates artificial requests from the service interface definition and validates the responses against the assertions provided by the tester.

Tutorial: Concurrency with Alice 3 and Java

Abstract: In this special session, attendees will learn about techniques for teaching concepts of concurrency with Alice 3's latest release of a Java IDE plugin. The new plugin makes use of Java 8's lambda expression to provide a Do together control structure with simpler syntax. Using this technique and Java 8 plugin, students in early-level programming courses can make use of Alice's Do together control structure to create concurrent threads in their Java code.