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

A Java commodity grid kit

Abstract: In this paper we report on the features of the Java Commodity Grid Kit. The Java CoG Kit provides middleware for accessing Grid functionality from the Java framework. Java CoG Kit middleware is general enough to design a variety of advanced Grid applications with quite different user requirements. Access to the Grid is established via Globus protocols, allowing the Java CoG Kit to communicate also with the C Globus reference implementation. Thus, the Java CoG Kit provides Grid developers with the ability to utilize the Grid, as well as numerous additional libraries and frameworks developed by the Java community to enable network, Internet, enterprise, and peer-to peer computing. A variety of projects have successfully used the client libraries of the Java CoG Kit to access Grids driven by the C Globus software. In this paper we also report on the efforts to develop server side Java CoG Kit components. As part of this research we have implemented a prototype pure Java resource management system that enables one to run Globus jobs on platforms on which a Java virtual machine is supported, including Windows NT machines.

Building Web Services with Java: Making Sense of XML, SOAP, WSDL, and UDDI

Abstract: From the Publisher: Building Web Services with SOAP, XML, and UDDI assumes proficiency with Java and with distributed computing tools. Throughout the book, examples will be presented using Java and the Apache SOAP platform, although a set of sidebars will address .NET development, which Microsoft developers will use to deploy Web services. The book uses progressive disclosure to present an increasingly complex project as it moves through its development cycle. The final section of the book presents linking the completed project with other systems built in J2EE and .NET.

Java and the Java Virtual Machine

Abstract: method declarations

Java and the Java Virtual Machine: Definition, Verification, Validation with Cdrom

Abstract: 1. Introduction.- 1.1 The goals of the book.- 1.2 The contents of the book.- 1.3 Decomposing Java and the JVM.- 1.4 Sources and literature.- 2. Abstract State Machines.- 2.1 ASMs in a nutshell.- 2.2 Mathematical definition of ASMs.- 2.3 Notational conventions.- I. Java.- 3. The imperative core JavaI of Java.- 3.1 Static semantics of JavaI.- 3.2 Transition rules for JavaI.- 4. The procedural extension JavaC of JavaI.- 4.1 Static semantics of JavaC.- 4.2 Transition rules for JavaC.- 5. The object-oriented extension $${\text{Jav}}{{\text{a}}_\mathcal{O}}$$ of JavaC.- 5.1 Static semantics of $${\text{Jav}}{{\text{a}}_\mathcal{O}}$$.- 5.2 Transition rules for $${\text{Jav}}{{\text{a}}_\mathcal{O}}$$.- 6. The exception-handling extension Java? of $${\text{Jav}}{{\text{a}}_\mathcal{O}}$$.- 6.1 Static semantics of Java?.- 6.2 Transition rules for Java?.- 7. The concurrent extension JavaT of Java?.- 7.1 Static semantics of JavaT.- 7.2 Transition rules for JavaT.- 7.3 Thread invariants.- 8. Java is type safe.- 8.1 Structural properties of Java runs.- 8.2 Unreachable statements.- 8.3 Rules of definite assignment.- 8.4 Java is type safe.- II. Compilation of Java: The Trustful JVM.- 9. The JVMI submachine.- 9.1 Dynamic semantics of the JVMI.- 9.2 Compilation of JavaI.- 10. The procedural extension JVMC of JVMI.- 10.1 Dynamic semantics of the JVMC.- 10.2 Compilation of JavaC.- 11. The object-oriented extension $${\text{JV}}{{\text{M}}_\mathcal{O}}$$ of JVMC.- 11.1 Dynamic semantics of the $${\text{JV}}{{\text{M}}_\mathcal{O}}$$.- 11.2 Compilation of $${\text{Jav}}{{\text{a}}_\mathcal{O}}$$.- 12. The exception-handling extension JVM? of $${\text{JV}}{{\text{M}}_\mathcal{O}}$$.- 12.1 Dynamic semantics of the JVM?.- 12.2 Compilation of Java?.- 13. Executing the JVMN.- 14. Correctness of the compiler.- 14.1 The correctness statement.- 14.2 The correctness proof.- III. Bytecode Verification: The Secure JVM.- 15. The defensive virtual machine.- 15.1 Construction of the defensive JVM.- 15.2 Checking JVMI.- 15.3 Checking JVMC.- 15.4 Checking $${\text{JV}}{{\text{M}}_\mathcal{O}}$$.- 15.5 Checking JVM?.- 15.6 Checking JVMN.- 15.7 Checks are monotonic.- 16. Bytecode type assignments.- 16.1 Problems of bytecode verification.- 16.2 Successors of bytecode instructions.- 16.3 Type assignments without subroutine call stacks.- 16.4 Soundness of bytecode type assignments.- 16.5 Certifying compilation.- 17. The diligent virtual machine.- 17.1 Principal bytecode type assignments.- 17.2 Verifying JVMI.- 17.3 Verifying JVMC.- 17.4 Verifying $${\text{JV}}{{\text{M}}_\mathcal{O}}$$.- 17.5 Verifying JVM?.- 17.6 Verifying JVMN.- 18. The dynamic virtual machine.- 18.1 Initiating and defining loaders.- 18.2 Loading classes.- 18.3 Dynamic semantics of the JVMD.- A. Executable Models.- A.1 Overview.- A.2 Java.- A.3 Compiler.- A.4 Java Virtual Machine.- B. Java.- B.1 Rules.- B.2 Arrays.- C. JVM.- C.1 Trustful execution.- C.2 Defensive execution.- C.3 Diligent execution.- C.4 Check functions.- C.5 Successor functions.- C.6 Constraints.- C.7 Arrays.- C.8 Abstract versus real instructions.- D. Compiler.- D.1 Compilation functions.- D.2 maxOpd.- D.3 Arrays.- References.- List of Figures.- List of Tables.

An architectural evaluation of Java TPC-W

Abstract: The use of the Java programming language for implementing server-side application logic is increasingly in popularity yet there is very little known about the architectural requirements of this emerging commercial workload. We present a detailed characterization of the Transaction Processing Council's TPC-W web benchmark, implemented in Java. The TPC-W benchmark is designed to exercise the web server and transaction processing system of a typical e-commerce web site. We have implemented TPC-W as a collection of Java servlets, and present an architectural study detailing the memory system and branch predictor behavior of the workload. We also evaluate the effectiveness of a coarse-grained multithreaded processor at increasing system throughput using TPC-W and other commercial workloads. We measure system throughput improvements from 8% to 41% for a two context processor, and 12% to 60% for a four context uniprocessor over a single-threaded uniprocessor despite decreased branch prediction accuracy and cache hit rates.

Formalizing the safety of Java, the Java virtual machine, and Java card

Abstract: We review the existing literature on Java safety, emphasizing formal approaches, and the impact of Java safety on small footprint devices such as smartcards. The conclusion is that although a lot of good work has been done, a more concerted effort is needed to build a coherent set of machine-readable formal models of the whole of Java and its implementation. This is a formidable task but we believe it is essential to build trust in Java safety, and thence to achieve ITSEC level 6 or Common Criteria level 7 certification for Java programs.

WebCard: a java card web server

Abstract: Webcard is a Java application that implements a TCP/IP stack and HTTP server and runs on a Schlumberger Cyberflex Access smartcard. In this report, we describe the architecture and implementation of Web-card and the constraints and assumptions that influenced its design. Complete sources for the application and its supporting environment are available.

The hyperion system: compiling multithreaded java bytecode for distributed execution

Abstract: Our work combines Java compilation to native code with a runtime library that executes Java threads in a distributed memory environment. This allows a Java programmer to view a cluster of processors as executing a single JAVA virtual machine. The separate processors are simply resources for executing Java threads with true parallelism, and the run-time system provides the illusion of a shared memory on top of the private memories of the processors. The environment we present is available on top of several UNIX systems and can use a large variety of communication interfaces thanks to the high portability of its run time system. To evaluate our approach, we compare serial C, serial Java, and multithreaded Java implementations of a branch and-bound solution to the minimal-cost map-coloring problem. All measurements have been carried out on two platforms using two different communication interfaces: SISCI/SCI and MPI BIP/Myrinet.

Object class for facilitating conversion between Java and XML

Abstract: A base object class is defined for conversion between Java and XML. The base object class may include a first method for converting from Java to XML. The base object class may also include a second method for converting from XML to Java. Object classes may then be defined that extend the base object class and that facilitate conversion between Java and XML.

Java servlet programming, second edition

Abstract: Servlets are an exciting and important technology that ties Java to the Web, allowing programmers to write Java programs that create dynamic web content. Java Servlet Programming covers everything Java developers need to know to write effective servlets. It explains the servlet lifecycle, showing how to use servlets to maintain state information effortlessly. It also describes how to serve dynamic web content, including both HTML pages and multimedia data, and explores more advanced topics like integrated session tracking, efficient database connectivity using JDBC, applet-servlet communicaton, interservlet communication, and internationalization. Readers can use the book's numerous real-world examples as the basis for their own servlets. The second edition has been completely updated to cover the new features of Version 2.2 of the Java Servlet API. It introduces chapters on servlet security and advanced communication, and also introduces several popular tools for easier integration of servlet technology with dynamic web pages. These tools include JavaServer Pages (JSP), Tea, XMLC, and the Element Construction Set. In addition to complete coverage of 2.2 specification, Java Servlet programming, 2nd Edition, also contains coverage of the new 2.3 final draft specification.

Mechanism for converting between JAVA classes and XML

Abstract: A method, applications programming interfaces (API), and mechanism for converting between JAVA classes and XML. In a file containing JAVA data representations, each JAVA class having elements to be converted to an XML representation is annotated in a manner enabling appropriate conversion processing by an API generating therefrom an XML file. The annotation enables instances of Java class objects to be converted to an XML representation and XML representations to be converted to Java class objects.

Professional Java Security

Abstract: From the Publisher: As Java emerges as the standard platform for Internet programming, the ability to securely move its code around is imperative for application security in large-scale e-commerce and e-business sites - many of which have suffered a recent spate of hacker attacks. Security is one of the key features of the Java language architecture, giving its users confidence in downloading code across networks. Professional Java Security presents everything that a Java programmer needs to know about secure application design and programming. It begins with simple examples and descriptions and builds to a comprehensive cookbook of solutions. Topics covered include SSL, cryptography, authentication, and access control.

Java 3D API Jump-Start

Abstract: From the Book: Welcome to Java 3D API Jump-Start. This book was designed to enable Java programmers to jump directly into the exciting and powerful world of 3D. Written by professional Java 3D developers, this book covers everything you need to know to get up and running with Sun Microsystems Java 3D application programming interface (API) in no time flat. About This Book Java 3D API Jump-Start was written for Java programmers by Java programmers. Assuming that you're already comfortable with the basics of Java development, this book walks you start-to-finish through the most important and useful aspects of programming with the Java 3D API. To this end, Java 3D API Jump-Start is organized into the following six chapters: Chapter 1, "Java 3D Overview" Chapter 2, "Scene Graph Basics" Chapter 3, "Creating and Loading Geometry" Chapter 4, "Appearances" Chapter 5, "Environment Nodes" Chapter 6, "Tools: Transforms, Viewing, and Picking" The first two chapters form an introduction to Java 3D. Chapter 1 gives examples of Java 3D applications and describes the basic features; Chapter 2 describes the basic structure of Java 3D programs. Chapter 3, 4 and 5 describe the three basic "building blocks" of Java 3D programs. Chapter 6 covers three tools that most Java 3D programs use. Upon completing each chapter, you'll have gained valuable knowledge and hands-on experience related to a specific area of Java 3D capabilities and features, enabling you to explore that topic in more detail on your own as you see fit. By the time you finish all six chapters you'll be experienced with the most important aspects of Java 3D necessary to create your very own interactive 3D applications. Web3D Series Java 3D Jump-Start is part of a new "Web3D" series of books produced by Prentice Hall, and dedicated to 3D and the Internet. To get your hands on additional resources related to Java 3D Jump-Start (such as the freely available Java 3D Explorer application used extensively throughout this book), or to learn more about related 3D technologies, visit the Web3DBooks.com Web site at web3dbooks.com/

Method for running existing java beans in an enterprise java bean environment

Abstract: This invention is a method and system for running application code originally developed as simple Java Beans, in an Enterprise Java Bean (EJB) environment, without modifying the original application code. This is accomplished by running one or more original Java beans in an EJB environment based on control from an external program, using at least the steps of defining a single generic EJB and installing the single generic EJB in an EJB container; generating EJB support code for each of the one or more original Java beans, and executing the EJB support code to drive the generic EJB to perform the functions of the one or more original Java beans in an EJB environment.

Component Development for the Java¿ Platform

Abstract: Java is an object-oriented language, but it is also a component-oriented platform Java's class-loading model and rich type information make it possible to build flexible and reusable binary components Component Development for the JAVA Platform reveals both the potential and pitfalls of developing components using the Java platform

Core Web Programming

Abstract: Introduction. Acknowledgments. I. THE HYPERTEXT MARKUP LANGUAGE. 1. Designing Web Pages with HTML 4.0. 2. Block-Level Elements in HTML 4.0. 3. Text-Level Elements in HTML 4.0. 4. Frames. 5. Cascading Style Sheets. II. JAVA PROGRAMMING. 6. Getting Started with Java. 7. Object-Oriented Programming in Java. 8. Basic Java Syntax. 9. Applets and Basic Graphics. 10. Java 2D: Graphics in Java 2. 11. Handling Mouse and Keyboard Events. 12. Layout Managers. 13. AWT Components. 14. Basic Swing. 15. Advanced Swing. 16. Concurrent Programming with Java Threads. 17. Network Programming. III. SERVER-SIDE PROGRAMMING. 18. HTML Forms. 19. Server-Side Java Servlets. 20. Javaserver Pages. 21. Using Applets as Front Ends to Server-Side Programs. 22. JDBC. 23. XML Processing with Java. IV. JAVASCRIPT. 24. JavaScript: Adding Dynamic Content to Web Pages. 25. JavaScript Quick Reference. Index.

Method of bridging between .Net and Java

Abstract: The invention is a method for allowing Java objects to communicate with .Net Remoting objects, with a first step of receiving metadata information from a .Net Remoting server on a Java client. Then, Java proxies are generated from said metadata information, using a Java development tool, with the Java proxies generated by a one-to-one mapping of .Net classes to Java classes. Finally, the Java proxies are implemented on the Java client, with the method provided solely in Java. Therefore, the Java client does not require any .Net components. The method can also be used to allow .Net Remoting objects to communicate with Java objects in a similar manner.

Java Programming with CORBA : Advanced Techniques for Building Distributed Applications

Abstract: The leading guide for Java developers who build business applications with CORBA Acknowledged experts present advanced techniques and real-world examples for building both simple and complex programs using Java with CORBA. The authors begin with a quick overview of CORBA, Java, object request brokers (ORBs), and EJB components, then quickly move on to show how to use them to build complete Java applications. This new volume features in-depth code examples, as well as expanded coverage of cutting-edge topics, including Portable Object Adaptor (POA), Remote Method Invocation (RMI) over IIOP, and EJB.

Java & XML

Abstract: Java and XML, 3rd Edition, shows you how to cut through all the hype about XML and put it to work. It teaches you how to use the APIs, tools, and tricks of XML to build real-world applications. The result is a new approach to managing information that touches everything from configuration files to web sites.After two chapters on XML basics, including XPath, XSL, DTDs, and XML Schema, the rest of the book focuses on using XML from your Java applications. This third edition of Java and XML covers all major Java XML processing libraries, including full coverage of the SAX, DOM, StAX, JDOM, and dom4j APIs as well as the latest version of the Java API for XML Processing (JAXP) and Java Architecture for XML Binding (JAXB). The chapters on web technology have been entirely rewritten to focus on the today's most relevant topics: syndicating content with RSS and creating Web 2.0 applications. You'll learn how to create, read, and modify RSS feeds for syndicated content and use XML to power the next generation of websites with Ajax and Adobe Flash.Topics include:The basics of XML, including DTDs, namespaces, XML Schema, XPath, and TransformationsThe SAX API, including all handlers, filters, and writersThe DOM API, including DOM Level 2, Level 3, and the DOM HTML moduleThe JDOM API, including the core and a look at XPath supportThe StAX API, including StAX factories, producing documents and XMLPullData Binding with JAXB, using the new JAXB 2.0 annotationsWeb syndication and podcasting with RSSXML on the Presentation Layer, paying attention to Ajax and Flash applicationsIf you are developing with Java and need to use XML, or think that you will be in the future; if you're involved in the new peer-to-peer movement, messaging, or web services; or if you're developing software for electronic commerce, Java and XML will be an indispensable companion.

Beginning JSP Web Development

Abstract: From the Publisher: The emergence of Java APIs for server-side development has led to a rapid and growing acceptance of Java in the enterprise. As a result, web developers are tasked with creating Java web applications that are informative and interactive. Java Server Pages (JSP) is a recent extension (currently at v1.0) to the Java platform that promises to become the standard tool for intranet and web application development. Java Server Pages allows developers to easily create dynamic, interactive web pages by embedding scripts directly into HTML and XML. These scripts make use of Java bean components. By separating presentation code from the generation of dynamic content, JSP also allows web designers to change the presentation of applications with minimal Java programming knowledge. Java Server Pages extend the functionality of web servers by performing server-side tasks such as HTML form processing, database queries, and report generation. Using Java Server Pages, developers can quickly create powerful intranet and web applications that incorporate enterprise resources such as databases, networked servers and distributed objects. JSP also offers numerous advantages over existing CGI scripting techniques, including portability, reusability, session tracking, performance, and ease of development.

Development of manifest for java embedded server bundle

Abstract: An apparatus and method for facilitating development of Java Embedded Server bundles which includes a module containing a set of development tools used in the creation of Java Embedded Server bundles. The module may include a code template tool having sample code segments; a Java Embedded Server manifest generator tool that creates Java Embedded Server manifest files for Java Embedded Server bundles; a Java Embedded Server jar packager tool that packages Java Embedded Server bundles; and a web page link tool having links to Java Embedded Server-related web pages.

A Web-based collaborative workspace using Java 3D

Abstract: The paper presents a framework for building Web-based collaborative workspaces using the latest Java technologies-Java 3D, JavaServer Page (JSP), and Java Servlet. This Web-based approach allows designers, engineers and production managers to share a common workspace that can be used for design review, production monitoring, remote control, and troubleshooting, based on a set of interactive Java 3D models that represent the physical world with common interests. Following a brief overview of the related research work, the paper discusses the Java 3D concept from its scene graph structure to behavior control, and explains our approach to building Web-based collaborative workspaces using Java 3D. The proposed framework uses the popular client-server architecture and view-control-model design pattern with a secured session control. Control logic and the interfaces, which interact with the real world, are handled by an application server through servlets. The benefits enabled by the framework include reduced network traffic, increased flexibility of remote monitoring, interactive control, Web-based synchronous collaboration and quick response. It also shows significant potential for various Web-based real-time and distributed applications.

A Java API for advanced faults management

Abstract: The paper proposes an alternative for modeling managed resources using Java and telecommunication network management standards. It emphasizes functions related to fault management, namely: diagnostic testing and performance monitoring. Based on Java management extension (JMX/sup TM/), specific extensions are proposed to facilitate diagnostic testing and performance measurements implementation. The new API also called Java fault management extension (JFMX) consists of managed objects that model real resources being tested or monitored and support objects defined for the need of diagnostic testing and performance measurements. The paper discusses four Java implementations of a 3-tier client/server scenario focusing on the "SystemUnderTest" package of the new API to instrument a minimalist managed system scenario. These implementations are respectively built on top of the following Java based communication infrastructures: JMX/JFMX, RMI, CORBA/Java, and Voyager/sup TM/. The paper extends the Voyager implementation with JMX/JFMX and uses their dynamic and advanced features to provide a highly efficient solution. The later implementation also uses the mobile agent paradigm to overcome well-known limitations of the RPC based implementations.

Developing Java Enterprise Applications

Abstract: From the Publisher: An in-depth, ground-floor introduction to the long-awaited Java Enterprise APIs. As Java rolls out its eagerly anticipated, eight-component battery of Java Enterprise APIs, this book is the ideal introduction for programmers and developers looking to quickly apply the technology's vast capabilities to real-world corporate programming. The authors discuss how to use the different APIs together and with other technologies such as CORBA, COM, Servlets, and Agents. The book also features invaluable information on building Servlet search engines, getting the most out of Java Server Pages, using Enterprise JavaBeans and JDBC to create N-Tier applications, and choosing the appropriate middleware to suit your particular needs. CD-ROM contains re-usable programs in Java and sample software.

On the Visualization of Java Programs

Abstract: In this paper we present a graph drawing framework that can be used to automatically draw UML class diagrams and a compiler that extracts the needed information from Java source code. Both components can be combined to a visualization tool for Java programs.

Creating Java to Native Code Interfaces with Janet

Abstract: Java is growing in appropriateness and usability for high performance computing. With this increasing adoption, issues relating to combining Java with existing codes in other languages become more important. The Java Native Interface (JNI) API is portable but too inconvenient to be used directly owing to its low-level API. This paper presents Janet -- a highly expressive Java language extension and preprocessing tool that enables convenient integration of native code with Java programs. The Janet methodology overcomes some of the limitations of JNI and generates Java programs that execute with little or no degradation despite the flexibility and generality of the interface.

Wireless Java programming with Java 2 Micro Edition

Abstract: Introduction. I. GETTING STARTED. 1. Introduction to Wireless Application Development. 2. Java for Wireless Devices. 3. Java Wireless Programming Basics. 4. Packaging and Deploying Java Wireless Applications. II. DEVELOPING WIRELESS APPLICATIONS USING JAVA. 5. Central Components of the UI for Wireless Devices. 6. Using High-Level APIs in UI Development. 7. Using Low-Level APIs in UI Development. 8. Persistent Storage. 9. Basic Network Programming in J2ME MIDP. 10. Using XML in Wireless Applications. 11. A Complete Example: MotoShop. 12. Data Synchronization for Wireless Applications. III. APPENDIXES. A: CLDC Class Libraries. B: MIDP Class Libraries. C: Resource Links. D: NTT DoCoMo's Java for i-Mode. Index.

JaMake: A Java Compiler Environment

Abstract: A language of choice for general-purpose programming, Java is quickly becoming popular in more specialized areas, such as scientific computing. However, even though the compilation technologies have significantly improved Java execution, performance is still the main obstacle to the use of Java for scientific applications. Although good Java Virtual Machine implementations are approaching the performance of Fortran on similarly-coded applications, significant performance problems remain because of the power of the object-oriented programming paradigm. Our experiments show that full use of polymorphic, objectoriented programming can result in performance penalties of up to two orders of magnitude. To address this performance difficulty, the authors have developed the JaMake Java transformation system, which uses advanced program analysis and transformation techniques to allow programmers to create extensible and maintainable programs using objectoriented design, while generating Java programs whose performance approaches that of hand-optimized, Fortran-style code. Experiments on our collection of object-oriented scientific programs have shown that transformation by JaMake can yield speed-ups of a factor of ten or more, bringing the performance of these object-oriented programs to within 75% of hand-optimized, Fortran-style code.

Java Programming with CORBA, Third Edition

Abstract: From the Publisher: The leading guide for Java developers who build business applications with CORBA Acknowledged experts present advanced techniques and real-world examples for building both simple and complex programs using Java with CORBA. The authors begin with a quick overview of CORBA, Java, object request brokers (ORBs), and EJB components, then quickly move on to show how to use them to build complete Java applications. This new volume features in-depth code examples, as well as expanded coverage of cutting-edge topics, including Portable Object Adaptor (POA), Remote Method Invocation (RMI) over IIOP, and EJB.