Showing papers on "Java applet published in 1996"

The Java Programming Language

Abstract: From the Publisher: Co-authored by the creator of the Java technology and an experienced object-oriented developer, The Java (TM)Programming Language, Second Edition, is the definitive resource for all serious Java programmers. This book will give you a solid foundation in Java programming language strategies and techniques. It features a concise introduction to the language; detailed descriptions of Java's commands, constructs, and libraries; and numerous real-world examples that show you how to exploit the language's power, portability, and flexibility. You will find in-depth and progressively advanced coverage of classes and objects, interfaces, exception-handling, threads and multitasking, and packages. In addition, the book describes the Java core library packages, including I/O, standard utilities, language types, and system classes. Thoroughly revised from start to finish, this second edition fully integrate, is the definitive resource for all serious Java programmers. This book will give you a solid foundation in Java programming language strategies and techniques. It features a concise introduction to the language; detailed descriptions of Java's commands, constructs, and libraries; and numerous real-world examples that show you how to exploit the language's power, portability, and flexibility. You will find in-depth and progressively advanced coverage of classes and objects, interfaces, exception-handling, threads and multitasking, and packages. In addition, the book describes the Java core library packages, including I/O, standard utilities, language types, and system classes. Thoroughly revised from start to finish, this second edition fully integrates Java 1.1 into both text and examples. This edition includes the changes introduced in Java 1.1, such as nested classes (including anonymous classes), threading issues, character-based streams, object-serialization, documentation comments, new utility classes, plus internationalization and localization. The book lets you in on the rationale behind Java's design, direct from the language's creator, as well as the tradeoffs involved in using specific features. With these insights, you will have the understanding you need to begin developing Java applications and applets.

Internet-enabled portfolio manager system and method

Abstract: A portfolio management system (PMS) is disclosed that allows users to manage, create, edit, debug and compile software portfolios that can include several different types of components, or projects. For example, projects can be Java applets, standalone executable programs, image files, Java class libraries or remote Java applets. The software portfolios and/or their constituent projects can be stored on the system hosting the portfolio management system or on any remote system that can be accessed via the Internet using standard Internet communications protocols, such as FTP or HTTP. The PMS includes portfolio files, each of which includes links to the projects that compose a portfolio and project files that set out the attributes of one project. The PMS also provides portfolio methods that allow users to create, choose, import and remove entire portfolios and project methods that allow users to create, import, choose, edit, remove, run, copy and paste projects. The contents of a particular portfolio or project file determines how the PMS implements the aforementioned methods. For example, if a user wants to import a portfolio from a remote system, the PMS invokes an integrated Web browser, which downloads the desired portfolio onto the local system. The PMS also allows users to publish portfolios and projects on the Internet to be used by others within certain limits set by the publisher. For example, the publisher can restrict copying of source programs while allowing copying of executables.

Java in a Nutshell

Abstract: The sixth edition of Java in a Nutshell helps experienced Java programmers get the most out of Java 7 and 8, but its also a learning path for new developers. With examples rewritten to take full advantage of modern Java APIs and development best practices, this fully updated book brings you up to date and gets you ready to develop Java applications for the future.Learn how lambda expressions make your programs shorter, and easier to write and understandExplore Nashorn, the brand new implementation of Javascript on the Java Virtual MachineStart using the new I/O APIs to make your code cleaner, shorter, and saferUnderstand Javas concurrency model and learn how to write multithreaded code with confidence

Collaborative web browser

Abstract: A pilot computer can control the Web browser of at least one passenger computer. The user of the passenger computer is instructed to log onto a control site, which downloads an active control, such as an applet, to the passenger computer. An active control is also provided to the pilot computer. If the pilot computer desires to present a particular Web page to both the pilot computer and the passenger computer for, e.g., discussing the page during a conference call, the pilot computer transmits the appropriate URL to the control site, which then retrieves the Web page. Next, the control site sanitizes the page by disabling its hyperlinks, and then the control site causes the passenger computer's active control to download the sanitized page. Also, the control site filters the page such that the hyperlinks are not disabled, but are rather encoded to point back to the control site, and this filtered page is downloaded to the pilot computer. The pilot computer can then "click" on a hyperlink, causing the control site to decode the hyperlink, retrieve the appropriate Web page, and instruct the passenger computer's active control to download the page after sanitizing the page.

Java security: from HotJava to Netscape and beyond

Abstract: The introduction of Java applets has taken the World Wide Web by storm. Information servers can customize the presentation of their content with server-supplied code which executes inside the Web browser. We examine the Java language and both the HotJava and Netscape browsers which support it, and find a significant number of flaws which compromise their security. These flaws arise for several reasons, including implementation errors, unintended interactions between browser features, differences between the Java language and bytecode semantics, and weaknesses in the design of the language and the bytecode format. On a deeper level, these flaws arise because of weaknesses in the design methodology used in creating Java and the browsers. In addition to the flaws, we discuss the underlying tension between the openness desired by Web application writers and the security needs of their users, and we suggest how both might be accommodated.

Java and the shift to net-centric computing

Abstract: Java is an object-oriented programming language with a syntax similar to C and C++, only simpler. Because Java is an interpreted language, the typical C or C++ compile-link-load-test-debug cycle is reduced. Java development environments actually let the entire software-development life cycle take place within a Web browser. The author discusses some basic and advanced features of Java, including garbage collection, multithreading and application programming interfaces.

Java bytecode to native code translation: the caffeine prototype and preliminary results

Abstract: The Java bytecode language is emerging as a software distribution standard. With major vendors committed to porting the Java run-time environment to their platforms, programs in Java bytecode are expected to run without modification on multiple platforms. These first generation run-time environments rely on an interpreter to bridge the gap between the bytecode instructions and the native hardware. This interpreter approach is sufficient for specialized applications such as Internet browsers where application performance is often limited by network delays rather than processor speed. It is, however, not sufficient for executing general applications distributed in Java bytecode. This paper presents our initial prototyping experience with Caffeine, an optimizing translator from Java bytecode to native machine code. We discuss the major technical issues involved in stack to register mapping, run-time memory structure mapping, and exception handlers. Encouraging initial results based on our X86 port are presented.

Java: The Complete Reference

Abstract: The Definitive Java Programming Guide Fully updated for Java SE 8, Java: The Complete Reference, Ninth Edition explains how to develop, compile, debug, and run Java programs. Bestselling programming author Herb Schildt covers the entire Java language, including its syntax, keywords, and fundamental programming principles, as well as significant portions of the Java API library. JavaBeans, servlets, applets, and Swing are examined and real-world examples demonstrate Java in action. New Java SE 8 features such as lambda expressions, the stream library, and the default interface method are discussed in detail. This Oracle Press resource also offers a solid introduction to JavaFX. Coverage includes: Data types, variables, arrays, and operators Control statements Classes, objects, and methods Method overloading and overriding Inheritance Interfaces and packages Exception handling Multithreaded programming Enumerations, autoboxing, and annotations The I/O classes Generics Lambda expressions String handling The Collections Framework Networking Event handling AWT and Swing The Concurrent API The Stream API Regular expressions JavaFX JavaBeans Applets and servlets Much, much more

Supporting multi-user, multi-applet workspaces in CBE

Abstract: Our experience with Internet-based scientific collaboratories indicates that they need to be user-extensible, allow users to add tools and objects dynamically to shared workspaces, permit users to move work dynamically between private and shared workspaces, and be easily accessible over a network. We present the software architecture of an environment, called CBE, for building collaboratories to meet such needs. CBE provides user-extensibility by allowing a collaborator to be constructed as a coordinated collection of group-swam applets. To support dynamic reconfiguration of shared workspaces and to allow access over the Internet, CBE uses the metaphor of rooms as the high-level grouping mechanism for applets and users. Rooms may contain applets, users, and arbitrary data objects. Rooms can be used for both asynchronous and synchronous collaboration because their state persists across synchronous sessions. Room participants may have different roles in a room (such as administrator, member and observer), with appropriate access rights. A prototype of the model has been implemented in Java and can be run from a Java-enabled Web browser.

Filling HTML forms simultaneously: CoWeb—architecture and functionality

Abstract: CoWeb is a system to support simultaneous work in the World Wide Web. CoWeb enables two or more users at remote locations to work with the same HTML document. For example, input fields can be filled collaboratively, and pointers and stretching rectangles can be used to highlight particular parts of images. An additional chatting channel can be used to talk about the document. CoWeb transforms the individual elements of the HTML language into Java applets, so that any existing HTML document can be used via CoWeb. All additional functionality for simultaneous cooperation is integrated through applets, i.e. by reading WWW documents. Thus, no modification of the document, the server or the WWW client is necessary — as long as the latter is Java-compatible.

The Java Tutorial: Object-Oriented Programming for the Internet

Abstract: From the Publisher: Follow you own path to expertise with this self-guided tour for the Java programming language. Written by two members of the JavaSoft team at Sun, the book employs a hands-on interactive approach to teaching Java basics, object-oriented concepts, applet programming and everything else you need to know to become a proficient Java programmer. Through plentiful examples and skill-building exercises, The Java Tutorial introduces you to fundamental concepts and applications. Designed so that you can customize your own path through the specific information you need to learn, the book explains the nuts and bolts of the language, applet construction, and the core Java classes. You will also learn about more advanced topics such as creating a user interface with Java, threads programming, working with Java's networking and security capabilities, and adding non-Java libraries to Java applications. The accompanying CD-ROM contains the tutorial and all its code samples, the Java Developers Kit (JDK), and code for all the winning applets in the Java International Programming Contest as well as developer tools from MetroWerks, SunSoft, Symantec, and others.

ParaWeb: towards world-wide supercomputing

Abstract: In this paper, we describe the design of a system, called ParaWeb, for utilizing Internet or intra-net computing resources in a seamless fashion. The goal is to allow users to execute serial programs on faster compute servers or parallel programs on a variety of possibly heterogeneous hosts. ParaWeb provides extensions to the Java programming environment (through a parallel class library) and the Java runtime system that allow programmers to develop new Java applications with parallelism in mind, or to execute existing Java applications written using Java's multithreading facilities in parallel. Some experimental results from our prototype implementation are used to demonstrate the potential of this approach.

Core Java

Abstract: The first two lessons of Core Java LiveLessons quickly review the history of Java and show you, step by step, how to install the software development environment. In lesson 3, you will learn how to do in Java what you already know in another programming language: write branches and loops, and work with numbers, strings, and arrays. Lesson 4 covers object-oriented programming. Java is thoroughly object-oriented, and the lesson shows you how to use built-in classes and how to build your own. Lessons 5 and 6 cover inheritance and interfaces as well as the lambda expressions, a powerful new feature of Java SE 8. Lesson 7 shows you what to do when your programs do the wrong thing. The lesson covers exception handling, logging, and debugging. In lesson 8, you will learn how to write generic code that works for many different data types. Lesson 9 puts those skills to work, when we examine the multitude of Java collections that allow you to organize your data in many ways. he final three lessons introduce the fundamentals of user interface programming in Java.

DartFlow: A Workflow Management System on the Web using Transportable Agents

Abstract: Workflow management systems help streamline business processes and increase productivity. This paper describes the design and implementation of the DartFlow workflow management system. DartFlow uses Web-browser embedded Java applets as its front end and transportable agents as the backbone. While Java applets provide a safe and platform independent GUI, the use of transportable agents makes DartFlow highly flexible and scalable. This paper describes the design and implementation of DartFlow, as well as a workflow application that exploits DartFlow''s agent-based design.

Development system with methods for just-in-time compilation of programs

Abstract: A development system having a client which employs a virtual machine for executing programs written in the Java programming language is described. The client executes a "compiled" (i.e., bytecode or pseudo-compiled) Java program, which has been created by compiling a Java source code program or script with a Java compiler. The pseudo-compiled program comprises the bytecode emitted by the compiler. The development system further includes a just-in-time compiler which natively compiles each pseudo-compiled method of a Java program on a "just-in-time" basis--that is, compiles each method as it is actually used into native machine code for a target microprocessor. Methods which are unused are left uncompiled (i.e., left as bytecode). During program execution, when a method call is made from interpreted code, the system employs an "invoker" slot of the callee. When a method call is made from compiled code, the system employs a "compiled code" slot of the callee. As the addresses for the slots themselves remain unchanged, a method which has been compiled need not be recompiled when a callee method it invokes is itself compiled. In this manner, a method (caller) calling another method (callee) need not know whether it is calling is an interpreted method or a compiled method.

CEBus Network Access via the World-Wide-Web

Abstract: Several methods of providing access to CEBus networks using the World Wide Web are described. Details of a working demonstration system are given. The system software incorporates CGI-Bin scripts and Java applets to support remote access to CEBus networks. To illustrate the potential of this technology an application to allow remote trouble-shooting and fault diagnosis on a CEBus network is described.

HTML: The Definitive Guide

Abstract: HTML is changing so fast it's almost impossible to keep up with developments. How do you know what's real, and how do you use it? The third edition of HTML: The Definitive Guide brings it all together for you. It is the most comprehensive book available on HTML today. It covers Netscape Navigator 4.5, Internet Explorer 4.0, HTML, JavaScript, Style sheets, Layers, and all of the features supported by the popular Web browsers. Learning HTML is like learning any new language, computer or human. Most students first immerse themselves in examples. Studying others is a natural way to learn, making learning easy and fun. Imitation can take you only so far, though. It's as easy to learn bad habits through imitation as it is to acquire good ones. The better way to become HTML-fluent is through a comprehensive reference that covers the language syntax, semantics, and variations in detail and that helps you distinguish between good and bad usage. HTML: The Definitive Guide, 3rd Edition helps you both ways: the authors cover every element of HTML in detail, explaining how each element works and how it interacts with other elements. Many hints about HTML style help you write documents ranging from simple online documentation to complex marketing and sales presentations. With hundreds of examples, the book gives you models for writing your own effective Web pages and for mastering advanced features, like style sheets and frames. HTML: The Definitive Guide, 3rd Edition shows you how to: Use style sheets and layers to control a document's appearance Create tables, from simple to complex Use frames to coordinate sets of documents Design and build interactive forms and dynamic documents Insert images, sound files, video, Java applets, and JavaScript programs Create documents that look good on a variety of browsers Use new features to support multiple languages A handy quick reference card listing HTML tags is included.

Teach Yourself Java in 21 Days

Abstract: From the Publisher: Introducing the first, best, and most detailed guide to developing applications with the hot new Java language from Sun Microsystems. Provides detailed coverage of the hottest new technology on the World Wide Web Shows readers how to develop applications using the Java language Includes coverage of browsing Java applications with Netscape and other popular Web browsers

The Design of Distributed Hyperlinked Programming Documentation

Abstract: HotJava is a World-Wide Web browser that adds dynamic behavior to hypertext access by supporting the downloading and execution of architecture-neutral, interactive applets from inside a Web page. HotJava is written in Java, a new object-oriented language and environment developed at Sun Microsystems.

Java-based query driven simulation environment

Abstract: The concept of Web-based simulation can be finally realized using Java. We have used Java to create a powerful simulation modeling library which is based on the process interaction paradigm. Java threads make it easy for us to implement each process (or active entity) as a thread. Our library, JSIM, supports both simulation and animation thus rendering the model developer's job easier. An important component of our approach is that we integrate our Java Simulator with a Database Management System (DBMS). The conceptual basis for this integration is an environment based on Query Driven Simulation, which allows simulation analysts to study the performance of systems simply by querying a database. Simulation inputs and outputs are stored in databases, and simulation models can be launched as a part of query processing. This integration also resolves a security restriction problem which Java imposes. Most browsers (e.g., Netscape Navigator) restrict Java applets from writing into a file which may be necessary to make simulation results available to the user. Our approach bypasses this problem by writing into a database. Databases are much less of a security concern since they already have substantial authorization mechanisms.

Process for running applets over non-IP networks

Abstract: A method and apparatus for allowing applets to be executed natively over a non-IP network. The method and apparatus provide an applet loader that initiates the applet download, services the class faults that are encountered and allows calls to non-IP APIs without compromising the security mechanisms of Java running on TCP/IP. This allows applets to be run without web browsers or web servers.

Persistent executable object system and method

Abstract: Method and apparatus for making applets persistent are provided. A persistent applet operating on a client system may be saved along with its complete state to a remote server. When desired, the client system may retrieve the persistent applet with its previous state.

Pickling State in the Java System.

Abstract: The JavarMlsystem (hereafter referred to simply as \"Java\") inherently supports the transmission of stateless computation in the form of object classes. In this paper we address the related task of capturing the state of a Java object in a serialized form for the purposes of transmission or storage, to be used later in reconstituting an equivalent object. This is accomplished by a mechanism known as pickling [Binel et al. 1987; Binell et al. 1994; Herlihy & Liskov 19821. Pickling is the process of creating a serialized representation of objects. Pickling defines the serialized form to include meta information that identifies the type of each object and the relationships between objects within a stream. Values and types are serialized with enough information to insure that the equivalent typed object and the objects to which it refers can be recreated. Unpickling is the complementary process of recreating objects from the serialized representation. Pickling and unpickling extract from the Java Virtual machine, at runtime, any meta information needed to pickle the fields of objects. Class specific methods are only required to customize the pickling process. l. Java and other Java-based names and logos are trademarks of Sun Microsystems, Inc., and refer to Sun's family of Java-branded products and services@ 1997 The USEND( Association, Computing Systems, Vol. 9 . No. 4 . Fall 1996 291

Discrete-event simulation on the World Wide Web using Java

Abstract: This paper introduces Simkit, a small set of Java classes for creating discrete event simulation models. Simkit may be used to either implement stand-alone models or Web page applets. Exploiting network capabilities of Java, the lingua franca of the World Wide Web (WWW), Simkit models can easily be implemented as applets and executed in a Web browser. Java's graphical capabilities enable the rapid development of intuitive user interfaces. Java's use of in terpreted bytecodes, while imposing a performance penalty, enable development of platform-independent models. The language's inherent internet-awareness make other possibilities, such as distributed simulation, much easier to implement.

Distributed database access in a corporate environment using Java

Abstract: Most of the Java applets on the Web today are developed primarily for visualization and 3D interactive animation. Serious doubts have been raised about the feasibility of using Java in the domain of enterprise applications. Compared with the conventional CGI-based approach for developing database applications, Java-based approach provides a high degree of flexibility, scalability, portability and robustness. Through the use of HORB, a software tool based on the concept of Object Request Broker, Java client and server objects can be created easily and accessed transparently. A methodology using Java and HORB for developing database applications is proposed, with the objective to establish a robust Web infrastructure in a corporate environment.

Java, the Web, and software development

Abstract: The author discusses how the World Wide Web and Java mark the death of fatware and the birth of dynamic computing built on rented components. The real paradigm shift will be the replacement of purchased software packages with transaction-oriented rental of Java applets attached to Web pages. In the move to a full-scale Internet based application development environment, developers are grappling with seven key issues: how to integrate e-mail, FTP, and HTML; the absolute need for security; the dearth of high-end visual tools; configuration management and version control; support for a flexible, sophisticated user interface; a common development environment; and performance, which has several components. Each of these issues are discussed by the author.

Method and apparatus for dynamic derivatives desktops

Abstract: An apparatus for dynamic derivatives desktops and methods of operating the same result in a dynamic derivatives desktop server for a CORBA (Common Object Request Broker Architecture) operating system that processes analytic requests without compromising the analytics of the analysis. The dynamic derivatives desktop server comprises an ORB (Object Request Broker) interface which receives an analytic request from the CORBA operating system. A Java applet coupled to the ORB interface having analytics which processes the analytic request to provide analytic results to the ORB interface.

Programming the Internet in Ada 95

Abstract: A new paradigm for computing is emerging based on the Internet and the World Wide Web, accompanied by a new standard programming platform based on the Java(tm) technology recently announced by Sun Microsystems [4]. The Java technology includes the definition for a platform-independent byte code representation for small applications called applets, which allows Java-enabled Web browsers to download and execute these Java applets using a byte code interpreter. Although the Java byte-code representation was designed specifically for the new Java language, it turns out that the underlying semantic models of Ada 95 and Java are sufficiently similar that a very direct mapping from Ada 95 to Java byte codes is possible. We at Intermetrics are in the process of adapting our Ada 95 compiler front end to generate Java byte codes directly, thereby allowing the development of Java-compatible applets in Ada 95. This paper explains our approach, and provides details on the mapping from Ada 95 features to Java byte codes, as well as the mapping from certain Java features to Ada 95. We have found the combination of the Ada 95 and Java technologies to be very natural and powerful, providing the best characteristics of both technologies, with essentially no loss in functionality.

Java in a nutshell: a desktop quick reference for Java programmers

Abstract: This is a complete reference guide to Java, the programming language from Sun Microsystems. This comprehensive volume contains descriptions of all of the Java classes and their related calls and an introduction to important Java concepts. It shows programmers how to write a simple Java applet and puts Java into perspective by summarizing the differences between Java and C and by explaining the object-oriented programming constructs in Java.