Editor's Note: With this installment of The Open Road, author and Cafe Au Lait founder Elliotte Rusty Harold takes over our series on the ongoing development of Java SE 7. And with the goals and processes of the OpenJDK project having been covered in the first installment, Elliotte jumps right in with this guide to actually building JDK 7. |
One of the java.net-related announcements at this year's JavaOne conference was the Java Research License. The license is intended for those wanting to use software licensed under SCSL (the Sun Community Software License) for research purposes. We invited several java.net bloggers to discuss the license in an email exchange. Here are the highlights of their discussion. |
A collection is a group of related data elements, organized into a single object, with operations provided to manipulate the data. Java technology has always offered support for collections, for example via the Vector and Hashtable classes, but in JDK 1.2, a new framework for collections has been defined and implemented. The old classes can still be used, but the new preferred approach has significant advantages. |
I'm sitting at the Denver JUG meeting and Joshua Bloch and Neal Gafter just finished a talk on "Java Puzzlers". I didn't show up until halfway through - but it was still a great half hour. They had a bunch of slides with problems that had seemingly easy answers. They'd both have a good dialog about their proposed answers - and then asked the crowd what they thought. The problems were mostly due to dumb (but real world mistakes) - the kind of thing you'd slap your fellow programmer for writing. These guys are definitely fun to listen to - next up is Tiger and what's new in 1.5 (I thought it was 5.0?). Boy, it's a full room tonight - I'd bet there's around 120-150 people here. |
I am very happy with the new features of JDK 5.0 and I am quite proud to have had a chance to influence it with my participation in JSR 175 and JSR 201. Like all radical evolutions, not all of the new features will be popular with everyone, but as long as most developers find some of these features useful and that backward compatibility is preserved, I think JDK 5.0 is a very solid step toward more solid Java code. |
More to Come Look for other interesting little snippets I've discovered in my upcoming articles. Editor's Note: This article first appeared in Dr. Kabutz's The Java(tm) Specialists' Newsletter under the title Charting Unknown Waters in JDK 1.4 Part I. To subscribe, send an email to [email protected]. |
Java applications do not have memory management issues, because the garbage collector of the Java Virtual Machine (JVM) takes care of all the storage issues. The garbage collector in the IBM JVM is based on the mark-sweep-compact (MSC) algorithm, where garbage collection (GC) takes place in three phases. At the end of the mark and sweep phases, free space is available, but there is a possibility of heap fragmentation. The compact phase alleviates the fragmentation problem by moving chunks of allocated space towards the lower end of the heap, helping create contiguous free memory at the other end. |
|
JDK 5.0 added major new support for developing concurrent applications, including JVM changes, new low-level synchronization utilities, and higher-level, thread-safe, high-performance concurrency classes such as thread pools, concurrent collections, semaphores, latches, and barriers. Learn how these new classes can help make your code faster, more scalable, more reliable, and easier to maintain. |
If you've been working with the Java platform for some time, you're probably as frustrated as I am by the endless succession of changes to the print API. Merlin brings yet another set of print capabilities and techniques to the Java platform. Dubbed the Java Print Service API, this latest iteration has been working its way through the Java Community Process since 1999. Fortunately, the new API is a positive addition and should represent the final significant change to printing support for some time. |
IBM's wholly owned subsidiary, Taligent, had a great deal of previous experience in Unicode software internationalization. In 1996, Sun contracted with Taligent to design and develop classes for the proper handling of multilingual text for JDK 1.1. Our goals were to provide an architecture that supplied the required functionality, was fully object oriented, could easily be extended to add additional features or to support additional countries, and would scale well across both small and large projects written in Java. There are some aspects of the architecture that we frequently get questions or complaints about, so we'll explain why we made some of the decisions we did. |
Sun's decision to release the source code for JDK 5.0, providing access to the non-public classes in addition to the public ones, gives developers a chance to look even further under the covers of the latest release -- if you don't mind abiding by licensing terms. Without getting into the "should Sun open source the Java platform" discussion, I'll show you how to get the source and discuss the two license options: Sun Community Source License (SCSL) and Java Research License (JRL) . I'll also briefly discuss the early access snapshot release of the 6.0 Mustang binaries and source. |
TextLayout , a class in the JDK 1.2, provides for correct display of text in English, Arabic, Hebrew, and other languages. Furthermore, TextLayout facilitates user interaction with text by providing caret display, hit-testing, selection, and line breaking capabilities. With TextLayout , you will find that working with international text is as easy as working with English text. You will also find that TextLayout is useful for English-only software, since it composes multiple text styles on a line and provides convenient measurement and line breaking. |
In the first installment of this two-part introduction to the new Java Print Service API, you learned how to print directly from the file system and prompt for printer selection with the printer dialog. This week, we'll build on that discussion, adding two more printing capabilities to your repertoire. I'll show you how to introduce event listeners to your print operations, and how to print directly from a screen or component. As we did last time, we'll close with a working example that lets you explore the new print API for yourself. If you are unfamiliar with the new Print Service API, you should read the first installment of this series before you read this one. |
The Swing JViewport class defines the part of an image that is visible at any one time. (Think of viewing the image through a porthole; the scrolling changes the viewing porthole.) The JScrollPane class handles connecting the scrollbars to the viewport. When the image is scrolled, the visible extents of the viewport are changed. The way the new image is displayed on the screen depends on the mode of scrolling being used. The default scroll mode has changed between 1.2.2 and 1.3.0, so the same application may behave differently on the two versions if the scroll mode is not explicitly set. The mode is set using the setScrollMode, as shown here: |
Another reason is because when the JVM manages lock acquisition and release using synchronization, the JVM is able to include locking information when generating thread dumps. These can be invaluable for debugging, as they can identify the source of deadlocks or other unexpected behaviors. The Lock classes are just ordinary classes, and the JVM does not (yet) have any knowledge of which Lock objects are owned by specific threads. Furthermore, synchronization is familiar to nearly every Java developer and works on all versions of the JVM. Until JDK 5.0 becomes the standard, which will probably be at least two years from now, using the Lock classes will mean taking advantage of features not present on every JVM and not familiar to every developer. |
This tutorial introduces generic types, a new feature in JDK 5.0 that lets you define classes with abstract type parameters that you specify at instantiation time. Generics increase the type safety and maintainability of large programs. Follow along with frequent developerWorks contributor and Java? programming expert Brian Goetz, as he explains the motivation for adding generics to the Java language, details the syntax and semantics of generic types, and provides an introduction to using generics in your classes. |
Regular expressions have been around for a long time. They come in very handy for text processing tasks. Some attribute the success of Perl to its superb ability of handling regular expressions. While there have been third-party classes that support regular expressions, with JDK 1.4, Java provides native support via the java.util.regex package. |
The Java 2 Platform Standard Edition Version 1.3 represents a significant advance in terms of functionality. However, it should be remembered that at this stage, JDK 1.3 is still in early beta and it will be many months before these new features become standard. While it's tempting to dive in and use these new classes and methods, remember that few users will have a JDK 1.3 Java Virtual Machine (JVM) installed yet. Nonetheless, it's important to become familiar with these features now, in preparation for the public release of JDK 1.3. |
JDK 1.2 is a major upgrade for the Java platform. It officially introduces Swing, the advanced widget library. It also adds support for CORBA, the standard object-oriented middleware protocol, and it defines a new API for graphics, Java 2D, as well as many, many other enhancements. |
JDK 1.2 presents an API for privileged blocks. Privileged blocks are meant to be small sections of code that have a higher privilege than the code that invoked them. JDK 1.2beta4 changed the API for privileged blocks from previous beta releases. Using this API, the only code that needs to be signed is the code that invokes the AccessController class, and the code that performs the privileged action. All other code can remain unsigned, preventing it from leaving the sandbox on its own. Documentation on the new API can be found at New API for Privileged Blocks. |
The Java Foundation Classes and Swing might be getting all the headlines, but the release of JDK 1.2 contains some important and fundamental features that push Java forward into the next era: distributed object computing. To this end, Sun has enhanced RMI and introduced support for CORBA. (Sun recently announced that it will seek to integrate RMI into CORBA's Internet Inter-ORB Protocol.) |
In Part 1 of this article, we discussed the history of the JDK 1.2 (which is also now being referred to as the key part of Java 2) release and issues of compatibility and support. Now we cover the "why-to-buy." |
The release of Sun?s JDK 1.2 brings with it little, if any, significant changes to the core Java language, but like the Standard Library in C++, the introduction of the Java Foundation Classes (JFC) attempts to stabilize and standardize the language for current and future development. With the JFC and the advances in the general technology supporting the JDK, Sun has made impressive strides toward its "Write once, run anywhere" philosophy. |
The Logging API of JDK 1.4 provides many new features that will help standardize the way Java applications store logging information. Because this API is standard to the Java platform, logging utilities can be used by multiple applications. The JDBC handler presented in this article could easily be incorporated into any project that makes use of JDK 1.4's Logging API. |
SecurityManager's job is to throw security exceptions if an application or applet tries to access something outside of the sandbox without permission. All applets and applications in Java must be granted explicit permissions to access local system resources, apart from read access to the directory and its subdirectories where the program is invoked (or the browser in a typical applet). |