Showing papers on "Java applet published in 2002"

Patterns of Enterprise Application Architecture

Abstract: Preface. Who This Book Is For. Acknowledgements. Colophon. Introduction. Architecture. Enterprise Applications. Kinds of Enterprise Application. Thinking About Performance. Patterns. The Structure of the Patterns. Limitations of These Patterns. I. THE NARRATIVES. 1. Layering. The Evolution of Layers in Enterprise Applications. The Three Principal Layers. Choosing Where to Run Your Layers. 2. Organizing Domain Logic. Making a Choice. Service Layer. 3. Mapping to Relational Databases. Architectural Patterns. The Behavioral Problem. Reading in Data Structural Mapping Patterns. Mapping Relationships. Inheritance. Building the Mapping. Double Mapping. Using Metadata. Database Connections. Some Miscellaneous Points. Further Reading. 4. Web Presentation. View Patterns. Input Controller Patterns. Further Reading. 5. Concurrency (by Martin Fowler and David Rice). Concurrency Problems. Execution Contexts. Isolation and Immutability. Optimistic and Pessimistic Concurrency Control. Preventing Inconsistent Reads. Deadlocks. Transactions. ACID. Transactional Resources. Reducing Transaction Isolation for Liveness. Business and System Transactions. Patterns for Offline Concurrency Control. Application Server Concurrency. Further Reading. 6. Session State. The Value of Statelessness. Session State. Ways to Store Session State. 7. Distribution Strategies. The Allure of Distributed Objects. Remote and Local Interfaces. Where You Have to Distribute. Working with the Distribution Boundary. Interfaces for Distribution. 8. Putting it all Together. Starting With the Domain Layer. Down to the Data Source. Data Source for Transaction Script. Data Source Table Module (125). Data Source for Domain Model (116). The Presentation Layer. Some Technology-Specific Advice. Java and J2EE. .NET. Stored Procedures. Web Services. Other Layering Schemes. II. THE PATTERNS. 9. Domain Logic Patterns. Transaction Script. How It Works. When to Use It. The Revenue Recognition Problem. Example: Revenue Recognition (Java). Domain Model. How It Works. When to Use It. Further Reading. Example: Revenue Recognition (Java). Table Module. How It Works. When to Use It. Example: Revenue Recognition with a Table Module (C#). Service Layer(by Randy Stafford). How It Works. When to Use It. Further Reading. Example: Revenue Recognition (Java). 10. Data Source Architectural Patterns. Table Data Gateway. How It Works. When to Use It. Further Reading. Example: Person Gateway (C#). Example: Using ADO.NET Data Sets (C#). Row Data Gateway. How It Works. When to Use It. Example: A Person Record (Java). Example: A Data Holder for a Domain Object (Java). Active Record. How It Works. When to Use It. Example: A Simple Person (Java). Data Mapper. How It Works. When to Use It. Example: A Simple Database Mapper (Java). Example: Separating the Finders (Java). Example: Creating an Empty Object (Java). 11. Object-Relational Behavioral Patterns. Unit of Work. How It Works. When to Use It. Example: Unit of Work with Object Registration (Java) (by David Rice). Identity Map. How It Works. When to Use It. Example: Methods for an Identity Map (Java). Lazy Load. How It Works. When to Use It. Example: Lazy Initialization (Java). Example: Virtual Proxy (Java). Example: Using a Value Holder (Java). Example: Using Ghosts (C#). 12. Object-Relational Structural Patterns. Identity Field. How It Works. When to Use It. Further Reading. Example: Integral Key (C#). Example: Using a Key Table (Java). Example: Using a Compound Key (Java). Foreign Key Mapping. How It Works. When to Use It. Example: Single-Valued Reference (Java). Example: Multitable Find (Java). Example: Collection of References (C#). Association Table Mapping. How It Works. When to Use It. Example: Employees and Skills (C#). Example: Using Direct SQL (Java). Example: Using a Single Query for Multiple Employees (Java) (by Matt Foemmel and Martin Fowler). Dependent Mapping. How It Works. When to Use It. Example: Albums and Tracks (Java). Embedded Value. How It Works. When to Use It. Further Reading. Example: Simple Value Object (Java). Serialized LOB. How It Works. When to Use It. Example: Serializing a Department Hierarchy in XML (Java). Single Table Inheritance. How It Works. When to Use It. Example: A Single Table for Players (C#). Loading an Object from the Database. Class Table Inheritance. How It Works. When to Use It. Further Reading. Example: Players and Their Kin (C#). Concrete Table Inheritance. How It Works. When to Use It. Example: Concrete Players (C#). Inheritance Mappers. How It Works. When to Use It. 13. Object-Relational Metadata Mapping Patterns. Metadata Mapping. How It Works. When to Use It. Example: Using Metadata and Reflection (Java). Query Object. How It Works. When to Use It. Further Reading. Example: A Simple Query Object (Java). Repository (by Edward Hieatt and Rob Mee). How It Works. When to Use It. Further Reading. Example: Finding a Person's Dependents (Java). Example: Swapping Repository Strategies (Java). 14. Web Presentation Patterns. Model View Controller. How It Works. When to Use It. Page Controller. How It Works. When to Use It. Example: Simple Display with a Servlet Controller and a JSP View (Java). Example: Using a JSP as a Handler (Java). Example: Page Handler with a Code Behind (C#). Front Controller. How It Works. When to Use It. Further Reading. Example: Simple Display (Java). Template View. How It Works. When to Use It. Example: Using a JSP as a View with a Separate Controller (Java). Example: ASP.NET Server Page (C#). Transform View. How It Works. When to Use It. Example: Simple Transform (Java). Two Step View. How It Works. When to Use It. Example: Two Stage XSLT (XSLT). Example: JSP and Custom Tags (Java). Application Controller. How It Works. When to Use It. Further Reading. Example: State Model Application Controller (Java). 15. Distribution Patterns. Remote Facade. How It Works. When to Use It. Example: Using a Java Session Bean as a Remote Facade (Java). Example: Web Service (C#). Data Transfer Object. How It Works. When to Use It. Further Reading. Example: Transferring Information about Albums (Java). Example: Serializing Using XML (Java). 16. Offline Concurrency Patterns. Optimistic Offline Lock (by David Rice). How It Works. When to Use It. Example: Domain Layer with Data Mappers (165) (Java). Pessimistic Offline Lock (by David Rice). How It Works. When to Use It. Example: Simple Lock Manager (Java). Coarse-Grained Lock (by David Rice and Matt Foemmel). How It Works. When to Use It. Example: Shared Optimistic Offline Lock (416) (Java). Example: Shared Pessimistic Offline Lock (426) (Java). Example: Root Optimistic Offline Lock (416) (Java). Implicit Lock (by David Rice). How It Works. When to Use It. Example: Implicit Pessimistic Offline Lock (426) (Java). 17. Session State Patterns. Client Session State. How It Works. When to Use It. Server Session State. How It Works. When to Use It. Database Session State. How It Works. When to Use It. 18. Base Patterns. Gateway. How It Works. When to Use It. Example: A Gateway to a Proprietary Messaging Service (Java). Mapper. How It Works. When to Use It. Layer Supertype. How It Works. When to Use It. Example: Domain Object (Java). Separated Interface. How It Works. When to Use It. Registry. How It Works. When to Use It. Example: A Singleton Registry (Java). Example: Thread-Safe Registry (Java) (by Matt Foemmel and Martin Fowler). Value Object. How It Works. When to Use It. Money. How It Works. When to Use It. Example: A Money Class (Java) (by Matt Foemmel and Martin Fowler). Special Case. How It Works. When to Use It. Further Reading. Example: A Simple Null Object (C#). Plugin (by David Rice and Matt Foemmel). How It Works. When to Use It. Example: An Id Generator (Java). Service Stub (by David Rice). How It Works. When to Use It. Example: Sales Tax Service (Java). Record Set. How It Works. When to Use It. References Index. 0321127420T10162002

System and method for facilitating user interaction in a browser environment

Abstract: Techniques to support various operations including drag-and-drop and stretch and data manipulation in a browser environment to allow data for an object located in one part of a document (300) to be associated with another object located in another part of the document. In one embodiment, a document includes at least one applet (310a) for at least one display window. Each applet includes at least one browser object (312) representative of an entity for an end application.

Jena: a semantic Web toolkit

Abstract: HP Labs developed the Jena toolkit to make it easier to develop applications that use the semantic Web information model and languages. Jena is a Java application programming interface that is available as an open-source download from www.hpl.hp.com/semweb/jena-top.html.

MDB: the Metalloprotein Database and Browser at The Scripps Research Institute.

Abstract: The Metalloprotein Database and Browser (MDB; http://metallo.scripps.edu) at The Scripps Research Institute is a web-accessible resource for metalloprotein research. It offers the scientific community quantitative information on geometrical parameters of metal-binding sites in protein structures available from the Protein Data Bank (PDB). The MDB also offers analytical tools for the examination of trends or patterns in the indexed metal-binding sites. A user can perform interactive searches, metal-site structure visualization (via a Java applet), and analysis of the quantitative data by accessing the MDB through a web browser without requiring an external application or platform-dependent plugin. The MDB also has a non-interactive interface with which other web sites and network-aware applications can seamlessly incorporate data or statistical analysis results from metal-binding sites. The information contained in the MDB is periodically updated with automated algorithms that find and index metal sites from new protein structures released by the PDB.

J-Orchestra: Automatic Java Application Partitioning

Abstract: J-Orchestra is an automatic partitioning system for Java programs. J-Orchestra takes as input Java applications in bytecode format and transforms them into distributed applications, running on distinct Java Virtual Machines. To accomplish such automatic partitioning, J-Orchestra uses bytecode rewriting to substitute method calls with remote method calls, direct object references with proxy references, etc. Using J-Orchestra does not require great sophistication in distributed system methodology--the user only has to specify the network location of various hardware and software resources and their corresponding application classes. J-Orchestra has significant generality, flexibility, and degree of automation advantages compared to previous work on automatic partitioning. For instance, J-Orchestra can correctly partition almost any pure Java program, allowing any application object to be placed on any machine, regardless of how application objects access each other and Java system objects. This power is due to the novel way that J-Orchestra deals with unmodifiable code (e.g., native code in the Java system classes). Additionally, J-Orchestra offers support for object migration and run-time optimizations, like the lazy creation of distributed objects.We have used J-Orchestra to successfully partition several realistic applications including a command line shell, a ray tracer, and several applications with native dependencies (sound, graphics).

JESSICA2: a distributed Java Virtual Machine with transparent thread migration support

Abstract: A distributed Java Virtual Machine (DJVM) spanning multiple cluster nodes can provide a true parallel execution environment for multi-threaded Java applications. Most existing DJVMs suffer from the slow Java execution in interpretive mode and thus may not be efficient enough for solving computation-intensive problems. We present JESSICA2, a new DJVM running in JIT compilation mode that can execute multi-threaded Java applications transparently on clusters. JESSICA2 provides a single system image (SSI) illusion to Java applications via an embedded global object space (GOS) layer. It implements a cluster-aware Java execution engine that supports transparent Java thread migration for achieving dynamic load balancing. We discuss the issues of supporting transparent Java thread migration in a JIT compilation environment and propose several lightweight solutions. An adaptive migrating-home protocol used in the implementation of the GOS is introduced. The system has been implemented on x86-based Linux clusters and significant performance improvements over the previous JESSICA system have been observed.

System and method for real-time annotation of a co-browsed document

Abstract: A system and method for facilitating annotation of a document co-browsed by multiple attendees of a collaboration session A co-browsed page is served to the attendees by a collaboration server An attendee (eg, the host) annotates the page by highlighting a portion, placing or moving a pointer, scrolling the page within a window, or taking some other action A collaboration applet operating in conjunction with the attendee's browser notes the position of the annotation (and size of annotation if it involves highlighting) and normalizes that position relative to the page The collaboration applet then transmits an annotation event to the collaboration server, with the normalized position The event is forwarded to other attendees, where the annotation is recreated

Detecting Manipulated Remote Call Streams

Abstract: In the Internet, mobile code is ubiquitous and includes such examples as browser plug-ins, Java applets, and document m this paper, we address an important vulnerability in mobile code security that exists in remote execution systems such as Globus, and SETI@Home. These systems schedule user jobs for execution on remote idle machines. However, they sen their important system calls back to the local machine for execution. Hence, an evil process on the remote machine can ma a user’s job to send destructive system calls back to the local machine. We have developed techniques to remotely de manipulation. Before the job is submitted for remote execution, we construct a model of the user’s binary program using static analys binary analysis is applicable to commodity remote execution systems and applications. During remote job execution, the checks all system calls arriving at the local machine. Execution is only allowed to continue while the model remains valid. W with a finite-state machine model that accepts sequences of system calls and then build optimizations into the model to im precision and efficiency. We also propose two program transformations, renaming and null call insertion, that have a sig impact on the precision and efficiency. As a desirable side-effect, these techniques also obfuscate the program, thus making for the adversary to reverse engineer the code. We have implemented a simulated remote execution environment to demon optimizations and transformations of the binary program increase the precision and efficiency. In our test programs, unop models increase run-time by 0.5% or less. At moderate levels of optimization, run-time increases by less than 13% with p gains reaching 74%.

AstexViewer: a visualisation aid for structure-based drug design.

Abstract: AstexViewer is a Java molecular graphics program that can be used for visualisation in many aspects of structure-based drug design. This paper describes its functionality, implementation and examples of its use. The program can run as an Applet in a web browser allowing structures to be displayed without installing additional software. Applications of its use are described for visualisation and as part of a structure based design platform. The software is being made freely available to the community and may be downloaded from http://www.astex-technology.com/AstexViewer.

System and method for real-time co-browsing

Abstract: A system and method for facilitating the collaborative co-browsing of a document or web page. A collaboration server retrieves content of a page on behalf of a collaboration participant or attendee. Each attendee operates or views the content with a browser that is augmented with a collaboration applet. Tags, links, script code and other references that may cause a different page to be accessed or loaded fro the current page are transformed or replaced on the server before the page is distributed to the attendees. In particular, events and redirections that may cause the attendee browser to directly navigate to another page are transformed on the server. Pre-determined rules may be applied to prevent some attendees from viewing certain content (e.g., financial or personal data). A page may be further transformed at a client browser, to redirect a hyperlink to the collaboration server or to trap some other event.

Patterns in Java: A Catalog of Reusable Design Patterns Illustrated with UML

Abstract: From the Publisher: In-depth coverage of forty-seven Java design patterns Since the publication of the first edition in 1998, programmers and developers have been waiting eagerly for an update to this expert guide on how to use Java in conjunction with the timesaving design patterns that have surfaced in the past few years. With the new edition of his bestselling Patterns in Java, Volume 1, Mark Grand brings you up to date with the latest release of Java and many of the important concerns facing Java programmers today. If you are a programmer or developer who wants to take advantage of new patterns, but doesn’t have the time or experience to document them for your organization, this book is for you. As with the first edition, each pattern is documented in UML and, where appropriate, a code example or an example in the core Java API is provided. This comprehensive book gives you: Seven fundamental design patterns Six creational patterns Three partitioning patterns Nine structural patterns Eleven behavioral patterns Eleven concurrency patterns UML documentation of all 47 patterns Practical, hands-on examples of pattern implementation in Java The companion Web site containing all of the Java source code and UML models from the book. Author Biography: MARK GRAND is an Atlanta-based consultant with over twenty-three years of experience in distributed systems, object-oriented design, and Java. He is currently working on an open source framework for gluing components and programs into an application. He is also the author of Patterns in Java, Volume 2 and Java Enterprise Design Patterns (both from Wiley).

Bytecode verification on Java smart cards

Abstract: This article presents a novel approach to the problem of bytecode verification for Java Card applets. By relying on prior off-card bytecode transformations, we simplify the bytecode verifier and reduce its memory requirements to the point where it can be embedded on a smart card, thus increasing significantly the security of post-issuance downloading of applets on Java Cards. This article describes the on-card verification algorithm and the off-card code transformations, and evaluates experimentally their impact on applet code size.

Decompiling Java Bytecode: Problems, Traps and Pitfalls

Abstract: Java virtual machines execute Java bytecode instructions. Since this bytecode is a higher level representation than traditional object code, it is possible to decompile it back to Java source. Many such decompilers have been developed and the conventional wisdom is that decompiling Java bytecode is relatively simple. This may be true when decompiling bytecode produced directly from a specific compiler, most often Sun's javac compiler. In this case it is really a matter of inverting a known compilation strategy. However, there are many problems, traps and pitfalls when decompiling arbitrary verifiable Java bytecode. Such bytecode could be produced by other Java compilers, Java byte-code optimizers or Java bytecode obfuscators. Java bytecode can also be produced by compilers for other languages, including Haskell, Eiffel, ML, Ada and Fortran. These compilers often use very different code generation strategies from javac.This paper outlines the problems and solutions we have found in our development of Dava, a decompiler for arbitrary Java bytecode. We first outline the problems in assigning types to variables and literals, and the problems due to expression evaluation on the Java stack. Then, we look at finding structured control flow with a particular emphasis on issues related to Java exceptions and synchronized blocks. Throughout the paper we provide small examples which are not properly decompiled by commonly used decompilers.

Method and system for conditional installation and execution of services in a secure computing environment

Abstract: A system (100) and method (300) are provided for installing and executing an applet in a secure processor (180). The system (100) and method (300) can receive the applet in non-secure data storage (174). The applet includes a meta-data portion (202) and an executable portion (204). The meta-data portion (202) includes a security meta-data portion, a resource meta-data portion (212), and a meta-data signature portion (216). The system (100) and method (300) determines whether the applet is capable of being executed by the secure processor (180) based at least in part on the security meta-data portion (212) and the resource meta-data portion (214) of the applet, and if the applet can be executed by the secure processor (180), the applet is installed on the secure processor (186).

Web 3d image display system

Abstract: A Web 3D image display system capable of smoothly displaying a 3D image on the Web browser. A computer system in which a 3D image file is downloaded from a server and a 3D image is displayed on the Web browser. The computer system includes a server holding a 3D compressed file which has been edited and generated according to 3D scene information from a VRML file or the like and a 3D applet for displaying a 3D scene and a Web browser for displaying a 3D scene. By the Web browser, a 3D applet is requested to the server and downloaded. The 3D applet is executed and the 3D compressed file is requested. After the file is downloaded and all the information is received, the Web browser alone executes the 3D applet, real time 3D rendering, and motion algorithm, and displays a continuously interactive 3D scene.

The J2Ee Tutorial

Abstract: You're familiar with Java programming, but now it's time for you to take it to the next level and begin creating enterprise applications with the Java 2 Platform, Enterprise Edition (J2EE). The J2EE Tutorial is the hands-on, example-driven guide that offers unparalleled technical guidance into developing and deploying applications on the J2EE platform. Written by the uniquely qualified members of the Java Software team at Sun Microsystems, The J2EE Tutorial uses the same effective interactive approach as the successful Java Tutorial collection. Throughout this book's development, hundreds of suggestions and volumes of feedback from both users and architects were integrated to ensure great writing and truly useful guidance. Inside you'll find a smart mix of example programs---including source code---that are used to illustrate key J2EE concepts. In addition, clear explanations will help you make easy work of the range of technologies collected into the J2EE platform, including: Enterprise JavaBeans, Java Servlets , JavaServer Pages, Java Message Service (JMS), Java Naming and Directory Interface (JNDI), XML, J2EE Connector Architecture, JavaMail, JDBC. When you're ready to create your own great enterprise applications, turn to the unmatched guidance, understanding, and experience you'll find only in The J2EE Tutorial. The accompanying CD-ROM is filled with a wealth of valuable resources, including all three Java Tutorial books, the J2SE 1.3.1 and J2EE 1.3.1 software development kits, the Java BluePrints sample application and book, and Forte for Java Plugin for the J2EE SDK.

Java Server Pages

Abstract: First there were servlets, then there were Java Server Pages (also known as JSPs). Both can serve up data on request, and, in the case of HTTP servlets, both can serve up Web pages on demand. So why have two approaches? The primary problem with servlets is that if you don’t already know Java, it is very difficult to write a servlet!

MySpiders : Evolve Your Own Intelligent Web Crawlers

Abstract: The dynamic nature of the World Wide Web makes it a challenge to find information that is both relevant and recent. Intelligent agents can complement the power of search engines to meet this challenge. We present a Web tool called MySpiders, which implements an evolutionary algorithm managing a population of adaptive crawlers who browse the Web autonomously. Each agent acts as an intelligent client on behalf of the user, driven by a user query and by textual and linkage clues in the crawled pages. Agents autonomously decide which links to follow, which clues to internalize, when to spawn offspring to focus the search near a relevant source, and when to starve. The tool is available to the public as a threaded Java applet. We discuss the development and deployment of such a system.

Java application response time analyzer

Abstract: Systems and methods for monitoring the performance of client-server transactions from the perspective of a client (501). In one embodiment, a JARTA (Java Application Response Time Analyzer) (504) component (which may include JAVAScript) is installed on an end user's browser (501) to collect various response time measurements and certain client system information and transmit this information to a server (502). A JARTA utility on the web server (502) can manage the actions (e.g., insert, modify, and delete) associated with web pages that are ear-marked for JARTA testing at the client browser (501). The JARTA component may include a JAVA(TM) applet that can be downloaded to a client computer (501) along with a web page. In one embodiment, a certain percentage of web transactions to be monitored can be designated using, e.g., a sampling algorithm.

A. framework for integrating the real-time specification for Java and Java's remote method invocation

Abstract: The Distributed Real-Time Specification for Java (DRTSJ) is being developed under Sun's Java Community Process. It is focused on supporting predictable, end-to-end timeliness for sequentially distributed computations (e.g., chains of invocations) in dynamic distributed object systems. This paper reports on an investigation to integrate and extend the existing real-time specification for Java and Java's Remote Method Invocation facility to provide the basis for the DRTSJ.

System and method for providing a java interface to an application view component

Abstract: A Java-based interface can be used to allow a Java client or application to access an application view component. An application view component can provide an interface to an application or enterprise system, using a resource adapter to expose functionality in the enterprise system. A Java-based interface for the resource adapter can allow the Java client to access the application view component. The interface can be a design-time graphical user interface, which can include a set of Java server pages and can be Web-based. The interface can allow a Java client to access the application view component in order to accomplish a task such as creating, defining, deploying, and testing the application view component. Each of these tasks can have their own page in the interface, such as a Java server page.

Interactive Power Electronics Seminar (iPES)-a web-based introductory power electronics course employing Java-applets

Abstract: This paper introduces the Interactive Power Electronics Seminar-iPES-a new software for teaching a basic course on power electronic circuits and systems. iPES is constituted by HTML text with Java-applets for interactive animation, circuit design and simulation and visualization of electromagnetic fields and is comprised of an easy-to-use self-explaining graphical user interface. The software does need just a standard web-browser, i.e. no installations are required. iPES can be accessed via the World Wide Web or from a CD-ROM in a stand-alone PC by students and professionals. Since the Java applets are simple to handle, a student can immediately start working and can fully concentrate on the theory of a problem. Due to the underlying software technology iPES is very flexible and can be used for on-line learning and be easily integrated into an e-learning platform. The aim of this paper is to give an introduction to the iPES-project and to show different areas covered. The e-learning software is available at no cost in English, German, Japanese and Korean. More translations, e.g. into Spanish and French will be available in the future. The web page is continuously updated in four-week intervals.

Method for multi-tasking multiple Java virtual machines in a secure environment

Abstract: The present invention allows construction of a secure, real-time operating system from a portable language such as Java that appears to be a Java virtual machine from a top perspective but provides a secure operating system from a bottom perspective. This allows portable languages, such as Java, to be used for secure embedded multiprocessor environments.

Performance of computer programs while they are running

Abstract: The present invention, in various embodiments, provides techniques for improving performance of programs. In one embodiment, the program is written in the Java language and runs in the Java Runtime Environment (JRE) that includes a Java Virtual Machine (JVM) having a configuration. A control panel having access to the JVM is invoked. Via the control panel, a user observes the execution of the Java program, analyzes the results of the execution, changes the configuration of the JVM, and forces re-optimization of the critical portions of the running program. By repeating the above steps of observing the program execution, analyzing the results, changing the configuration of the Java machine, and forcing re-optimization of the critical portions of the program, the user improves the program's overall performance.

Method and apparatus for routing call agents to website customers based on customer activities

Abstract: A system for allowing call center agents to initiate text chat, audio and/or video communication, as well as collaborative browsing with potential customers visiting web pages includes a customer monitoring applet that monitors the behavior of the customer via the web browser and sends information to a router process, the information including information identifying the customer, the web page location, status of a transaction, etc. The router process uses the information supplied to it from the customer monitoring applet, as well as information on one or more available agent processes to determine which call agent would be appropriate to initiate contact with the potential customer. The router process transmits the information identifying the customer to the selected agent process for presentation to the agent. The agent can monitor the status of the customer, as well as other customers, and send a request to initiate communication, if appropriate. The router process uses a customer status database and an agent status database to determine which agent is appropriate for a particular customer.

Dynamically downloading and executing system services on a wireless device

Abstract: An applet requiring a virtual machine is downloaded to a wireless device. A software platform on the device determines that a virtual machine is used by the applet during execution. Without additional user interaction, the virtual machine is downloaded to the wireless device. This allows those applets requiring a virtual machine to be used with devices that don't have the virtual machine already installed. Further embodiments include the dynamic loading of a system service when an application is being loaded that uses the system service. A unique identifier associated with the system service may be used to determine if determine if the system service is loaded.

Java compile-on-demand service system for accelerating processing speed of java program in data processing system and method thereof

Abstract: A Java compile-on-demand service system and method for accelerating a processing speed of Java program in a data processing system having a relatively low performance is provided. The Java COD service system compiles a Java class file to be executed in a data processing system into a pattern which can be executed more speedily on the data processing system, and then transmits the compiled result, upon a request of the data processing system connected via a network in order to execute the Java program at a relatively faster speed. The system includes Java program providing servers, data processing systems, and a compile-on-demand server for receiving a service request, downloading a requested Java class file, compiling the downloaded Java class file, and transmitting the compiled result.

Improving java software through package structure analysis

Abstract: Packages are an important mechanism to decompose Java programs. However, because packages are defined implicitly, it is not easy to develop a large application with a proper package structure. This article presents a tool that assists the programmer in developing a proper package structure through analysis and visualization. The tool indicates weak areas in package structures and allows human assisted refactoring of the source code based on the analysis. The article also introduces a new metric that is an indicator for the quality of the package architecture.

Introduction to Cryptography with Java Applets

Abstract: Introduction to Cryptography with Java Applets covers the mathematical basis of cryptography and cryptanalysis, like linear diophantine equations, linear congruences, systems of linear congruences, quadratic congruences, and exponential congruences. The chapters present theorems and proofs, and many mathematical examples. Cryptography with Java Applets also covers programming ciphers and cryptanalytic attacks on ciphers. In addition many other types of cryptographic applications, like digest functions, shadows, database encryption, message signing, establishing keys, large integer arithmetic, pseudo-random bit generation, and authentication are included. The author has developed various Java crypto classes to perform these functions, and many programming exercises are assigned to the reader. The reader should be someone with a basic working knowledge of Java, but knowledge of number theory or cryptography is not necessary.