Nathan Fiedler has posted an alpha of JSwat 3.0, a graphical, stand-alone Java debugger built on top of the Java Platform Debugger Architecture. Features include breakpoints, source code viewing, single-stepping, watching variables, viewing stack frames, and printing variables. Version 3.0 can read source code from JAR and zip files, adds new breakpoint types, can debug non java languages running on the JVM, and can debug remote applications. JSwat is published under the GPL.
Websina has released BugZero 4.1.3, a $1299 payware (+$300 for maintenance) Web-based bug tracking system that supports multiple projects, group-based access, automatic bug assignment, file attachment, email notification, and metric reports. Bug Zero is written in Java and can run on top of various backend databases including MySQL. 4.1.3 fixes bugs.
The Omni Group has posted the fourth beta of OmniGraffle 4, a general purpose Mac OS X diagramming tool and my UML editor of choice. New features in 4.0 include Bezier curves, SVG export, and improved import and export to/from PICT and Visio. OmniGraffle ranges from $79.95 to $149.95.
Sun has posted the public review draft specification of Java Specification Request (JSR) 220, Enterprise JavaBeans 3.0 in the Java Community Process (JCP).
The EJB 3.0 release of the Enterprise JavaBeans architecture provides a new, simplified API for the enterprise application developer. This API is targeted at ease of development and is a simplification of the APIs defined by earlier versions of the EJB specification. The existing EJB 2.1 APIs remain available for use in applications that require them and components written to those APIs may be used in conjunction with components written to the new EJB 3.0 APIs....
The purpose of the EJB 3.0 release is to improve the EJB architecture by reducing its complexity from the enterprise application developer�s point of view. EJB 3.0 is focused on the following goals:
- Definition of the Java language metadata annotations that can be used to annotate EJB applications. These metadata annotations are targeted at simplifying the developer�s task, at reducing the number of program artifacts the developer is required to provide, and at eliminating the need for the developer to provide an EJB deployment descriptor.
- Specification of programmatic defaults, including for metadata, to reduce the need for the developer to specify common, expected behaviors and requirements on the EJB container. A �configuration by exception� approach is taken whenever possible.
- Encapsulation of environmental dependencies and JNDI access through the use of annotations, dependency injection mechanisms, and simple lookup mechanisms.
- Simplification of the enterprise bean types.
- Elimination of the requirement for EJB component interfaces for session beans. The required business interface for a session bean can be a plain Java interface rather than an EJBObject, EJBLocalObject, or java.rmi.Remote interface.
- Elimination of the requirement for home interfaces for session beans.
- Simplification of entity bean persistence. Support for light-weight domain modeling, including inheritance and polymorphism.
- Elimination of all required interfaces for entities written to the new persistence API [2].
- Specification of Java language metadata annotations for object/relational mapping for entities.
- Enhancements to EJB QL to provide greater usability. Addition of projection, explicit inner and outer join operations, bulk update and delete, subqueries, and group-by. Addition of a dynamic query capability and support for native SQL queries.
- Reduction of the requirements for usage of checked exceptions.
- Elimination of the requirement for the implementation of callback interfaces.
- Improved ability for testing outside the container.
Comments are due by August 15.
Ericsson and Siemens have submitted JSR-281: IMS Services API to the Java Community Process (JCP). According to the JSR, the IMS Services API:
is intended to enable application programmers to easily write applications that can integrate with the IP Multimedia Subsystem (IMS). The specification will expose IMS functionality through high-level APIs in an integrated and consistent way. The API hides IMS implementation details to the maximum extent.The API abstracts the underlying technology and at the same time provides the developers with maximum flexibility. This approach secures conformance to IMS related standards and at the same time gives developers possibility to focus on the functionality of the services and not on the IMS technology implementation details. In this way IMS domain will be revealed to the broad J2ME developer community and will encourage faster adoption of the IMS services provided by the wireless networks.
At least three types of functionality will be supported by the API : high-level IMS functionality , Push to Talk over Cellular (PoC) services and Group List Management (GLM) services. The IMS part of the API defines a set of high-level functions enabling J2ME applications to access IMS services, e.g.:
- Support for IMS registration
- Support for co-location of multiple IMS Services
- Use of IMS service sessions (based on SIP sessions)
- Use of media connections
- Use of presence and group list management functionality
- High level support for SDP according to RFC 2327
The PoC part of the API is a high-level abstraction of the complex features provided by the PoC service, thus allowing for application programmers to write applications that make use of these features without having to deal with underlying details. The API allows for initiation, management and termination of PoC sessions with individual participants as well as pre-defined groups of participants. Furthermore it can be used to dynamically modify multiple PoC sessions in terms of adding or removing participants. The API provides support for control of talk bursts and operation of multiple simultaneous PoC sessions. The API facilitates integration of PoC functionality in arbitrary applications (e.g. multi-player games). The GLM part of the API is a high level abstraction to handle group, access and contact lists for arbitrary applications in an easy and straight forward way.
The IMS Services API allows application developers for mobile devices to easily utilize the IMS functionality without requiring knowledge of the underlying SIP and IMS implementation details. By direct support of the service bundling concept, the API supports one of the strengths of the IMS. The IMS Services API facilitates application developers to avoid violations of SIP and IMS conventions. In particular, the authentication mechanism used, is completely hidden from the application. As the user of the API does not have to be involved, the security risks associated with application level handling of authentication tokens is minimized.
Comments are due by April 8.
The Apache Commons Group has posted Betwixt 0.7, an open source Java class library that
provides an XML introspection mechanism for mapping beans to XML in a flexible way. It is implemented using an XMLIntrospector and XMLBeanInfo classes which are similar to the standard Introspector and BeanInfo from the Java Beans specification.
Betwixt provides a way of turning beans into XML as well as automatically generating digester rules in a way that can be customized on a per type manner in the same way that the BeanInfo mechanism can be used to customize the default introspection on a java object.
Betwixt 0.7 is a feature release. A number of new strategies have been introduced to add flexibility. Improvements have been made to binding and introspection including improved support for polymophism. Improvements have been made to the dot betwixt file format including support for multiple specifications within the same file. For full details see the tasks documentation.
Betwixt 0.7 is binary compatible with 0.6 but a number of changes have been made to some semantics. It is believed that the impact of these changes should be minimal.
The Jakarta Apache Project has released Reusable Dialog Components (RDC) Taglib 1.0, an open source "framework for creating JSP taglibs that aid in rapid development of voice and multimodal applications." Java Server Pages 2.0 is required.
Sun announced its quarterly financial results yesterday. Revenue was $2.98 billion in its fiscal fourth quarter, a 4.3 percent drop from the same quarter last year. Net income was $121 million (4 cents a share) a steep drop from $783 million (23 cents a share) last year. However the fourth quarter last year included the $1.6 billion Microsoft settlement. This year's quarter includes a nonrecurring $190 million tax benefit.
The Jakarta Apache Project has released version 5.5.10 of the Tomcat open source servlet container and official reference implementation of the Java Servlet API 2.4 and Java Server Pages (JSP) 2.0. This release is considered to be an alpha. New features in this release include Apache Portable Runtime (APR)-based HTTP/1.1 and AJP/1.3 protocol handlers with SSL support, an experimental NIO-Socket channel for the AJP/1.3 connector, improved support for Java 5, and clustering support at the Engine and Host levels.
Martian Software has released
JSAP 2.0a, a free-as-in-speech (LGPL) library
for validating commandline arguments and converting
those arguments into other types such as
Dates, URLs, and Colors.
jZonic has released jLo 1.1, an open source logging framework for Java that supports multiple log-configurations. It allows users to switch targets on or off independently of each other, rather than by threshold. Version 1.1 adds support for logging into a SQL database. jLo is published under the LGPL.
ej-technologies has released Install4j 3.2, a $698 payware cross platform tool for building native installers and application launchers for Java applications. New features in 3.2 include LZMA compression and Mac OS X disk image support.
The Big Faceless Organization has released the Big Faceless PDF Library 2.4.3, a $700 payware (more if you want support) Java class library for creating PDF documents. The $1300 Extended Edition adds the AcroForms support, digital signatures, and the ability to import and edit and existing PDF documents. Version 2.4.3 adds suport for for XFA forms, Acrobat 7 encryption, PDF417, and QR Code barcodes. Java 1.2 or later is required.
More NetBeans bogosity today. I discovered that Eclipse wouldn't support a local CVS repository, so I decided to give NetBeans one more try. However, the download requires me to accept a non-open-source license that severely restricts what I'm allowed to do. I've heard Sun claim that Netbeans is open source, but that doesn't seem to be true. Among other things the license states, "You may not create, modify, or change the behavior of, or authorize your licensees to create, modify, or change the behavior of, classes, interfaces, or subpackages that are in any way identified as 'java', 'javax', 'sun' or similar convention as specified by Sun in any naming convention designation." and I "agree to defend and indemnify Sun and its licensors from and against any damages, costs, liabilities, settlement amounts and/or expenses (including attorneys' fees) incurred in connection with any claim, lawsuit or action by any third party that arises or results from the use or distribution of any and all Programs and/or Software." Has anyone published a version of NetBeans that is open source. or is Sun just flat out lying about this?
A little fun for Saturday. New trailers have been posted for Serenity and V for Vendetta. Watch them with Amateur. I found the political situation in V for Vendetta implausible when I read the comic books twenty years ago. Sadly I no longer feel that way.
The first release candidate of Mantis 1.0, a free-as-in-speech (GPL) bug tracking system based on PHP and MySQL, has been posted.
Sleepycat Software has released Berkeley DB Java edition 2.0.54. Berkeley DB JE is an open source, non-relational embedded database written in Java. The data is exposed through "a Java Collections-style interface, as well as a programmatic interface similar to the Berkeley DB API." This is a bug fix release.
Andrei Kouznetsov has released Unified I/O 2.5, an open source (BSD license) class library that "allows random access to any data or stream (even over HTTP), and gives a clear difference between read only and read/write access." Version 2.5 can create streams from random access files and vice versa.
Teodor Danciu has released JasperReports 1.0, an open source (LGPL) Java library for generating reports from XML templates and customizable data sources (including JDBC). The output can be displayed on the screen, printed, or written to XML or PDF files.
Sun's posted the second public review draft specification of Java Specification Request (JSR) 121, Application Isolation API in the Java Community Process (JCP). According to the FAQ list:
The JSR-121 Java Application Isolation API adds multiple application support to the Java Virtual Machine. Each application, called an "Isolate" by the API, is given the illusion of running in its own isolated virtual machine: each application gets its own system properties, its own classpath, its own static class state, etc. Isolates can be cleanly terminated. Pure Java mechanisms for application life cycle control and communication are also provided. The API is flexible enough that VMs can implement it using the underlying OS process facilities, or the VM can isolate all the separate applications within a single process.
Nokia and Sun have submitted JSR-279: Service Connection API for Java ME to the Java Community Process (JCP). According to the JSR: >
This JSR proposes a general-purpose high-level Service Connection API for JavaTM ME for mobile devices. The API is intended to support writing mobile clients for identity-based Web services, service-oriented architectures (SOA), and other similar network service application models involving service discovery, authentication and identity. Existing Web services APIs tend to focus on support for low-level protocols, such as SOAP and Web Services Security. However, high-value Web services for mobile devices may be quite complex, requiring identity- based discovery and authentication, multiple service providers, and invocation of device-hosted services. These may require extensive protocol exchanges, complex state machines and other logic. To provide portability and interoperability such applications need to be based on frameworks that specify how multiple protocols and services can work together in a standard way. An example of such a standard framework that is currently being deployed is the Liberty Identity Based Web Services Framework (IDWSF), specified by the Liberty Alliance. Other frameworks with similar goals are also being specified and deployed, including for example the not yet standardized WS* specification suite or UPnP. The supported model is general enough that it could also be extended to non-Web services frameworks.
While it is theoretically possible to write such a framework-based application using only low-level Web services protocol APIs, the programming required would be very complex and would require implementing high-level protocols and other logic already well-specified by the framework. It makes much more sense to provide developers with a standard API to wrap framework behavior so that they can concentrate on service and application specific logic only.
The proposed JSR will specify a high-level Service Connection API for JavaTM ME that supports a simple GCF-like model for application interaction with services. The API will also cover the configuration needed to bootstrap interaction with service frameworks.
Reading between the lines, what this says is that SOAP/WSDL/etc. are still too complicated even when they hide the XML behind APIs like JAX-RPC so they need yet another layer separating the average developer from the XML. While I don't deny that SOAP, WSDL, etc. are quite complex, maybe the problem is not the APIs? Maybe the problem is that the underlying specs are too complex and too poorly designed and no API is ever going to be able to hide that fundamental complexity? Maybe the solution should be to stop building systems on top of such baroque, rigid and brittle foundations and instead build on top of simple, flexible systems like HTTP that bend instead of breaking? Just a thought. :-) Comments are due by August 1.
The GNU Project has released version 0.17 of GNU Classpath, an incomplete free implementation of the core Java class libraries. According to the announcement, "The GNU Classpath developer snapshot releases are not directly aimed at the end user but are meant to be integrated into larger development platforms. For example the GCC (gcj) and Kaffe projects will use the developer snapshots as a base for future versions. This is mainly a bug fix release for issues found with eclipse 3.1 and Free Swing applications just after our 0.16 release. But it also includes some exciting new features." Improvements in this release include "XML DOM, XPATH and XSL fixes. Free Swing is much more responsive. JInternalFram, JTree, JMenu, JTable, JButton and JFileChooser fixes. FileChannel lock and force implementations added. The logging FileHandler now rotates files. Clean locking and namespace for gtkpeer library. System call interrupts and timeouts are now handled correctly for net and nio. Corba bug fixes. Lots of documentation updates. The VM Integration Guide now comes with a full section on the VM/Classpath hooks. GNU Classpath Examples now includes a Tree World demo." Since this is a clean room project, it doesn't always line up exactly with any particular Java version; but it's roughly at the level of Java 1.4 with a few missing pieces and a few pieces pulled in from 1.5. GNU Classpath is published under the GPL with library exception.
As you may rememer, about a month ago I alluded to a "company that's pissed me off lately by asking for another $29.95 more for a product I'd already paid for, just to support the new release of their own operating system"; and I promised to do something about it. Now I have. I'm pleased to announce QuickTime Amateur, an open source clone of Apple's QuickTime Player that is uncrippled and free as in speech and beer. Currently this has only been tested, designed, and run on the Mac, though a Windows port is on the TODO list.
Currently Amateur is rather rough, and not all the functionality is there yet. Saving, in particular, needs a lot of work. However if you just want to play your movies in full screen mode without paying $30, it's good enough to do that now. Various other Pro functionality such as printing, editing, and copying and pasting movies is also enabled. If you just want to use it you should download the disk image.
There's lot of work still to be done. I've added more than two dozen tasks of varying degrees of difficulty in the issue list. I will eventually work my way through these, but that could take a while. If anyone wants to help out, please do. Your assistance is much appreciated. Making Save As work properly is the most immediate need. I know how to save a movie. What I haven't yet figured out how to do is remember where the movie was put, so that future saves will put it in that file rather than the file that was originally opened.
In hindsight, basing this project QuickTime for Java+Swing may have been a mistake. There are some things I can't seem to do in QTJ I probably could do in straight QuickTime+Cocoa+Objective C. However, I'm, committed now. Possibly I'll have to write some glue code to connect back to the native APIs over JNI or the Cocoa-Java bridge rather than going through QTJ. This remains to be seen. The program is functional now, though; and could improve quickly. If nothing else, the source base should serve as a really nice collection of examples of how you do much pretty much anything in QuickTime for Java. Comments and suggestions are appreciated. If you find bugs or have ideas for features that go beyond what QuickTime Player provides, please enter them in the issue tracker. Thanks!
Not specifically Java news, but I'm too pleased by this not to mention it. The Mozilla Project has posted the second alpha of Thunderbird 1.1. Despite the usual warnings ("This release is intended for testers ONLY, to get some early exposure on some of the new features under development for Thunderbird 1.1. It will contain bugs! If you are an end user using Thunderbird 1.0, please stay with 1.0. Thanks!") in my limited testing on Mac OS X, this release is far more stable and reliable than 1.0. A lot of little niggling bugs that had been biting me for the last six months or so have been fixed. I don't see any real new features here, but overall the application runs faster, feels smoother, and just works better. In particular, I should finally be able to import and reorganize all my old Eudora mailboxes. Some AppleScripts that broke when I upgraded to Tiger are also working again, though overall AppleScript support is weak compared to Eudora. Also I still miss the templates support in Eudora. (Yes, I know Thundebird has templates. No, they aren't usable in any realistic way.) Possibly you might want to wait for another beta or two if you use POP and store your mailboxes locally, but IMAP users who are a little more resistant to corruption should think about upgrading. At least on Mac OS X 10.4, this is a major improvement.
Michael Clark has posted JMemProf 0.8, an open source (LGPL), live Java memory profiler suitable for deployment in Web containers such as JBoss and Tomcat. JMemProf can retrieve memory profile information from a running application. This is a bug fix release that adds support for Java 1.5 on Linux.
A data point of some interest: I graded a recent applet homework for my Intro to Java course on Safari 2.0 using Java 1.4.2 (not the recent update). 4 of the 20 assignments managed to crash my browser at least once. If Apple wants to debug their VM, they could do worse than ask a bunch of undergraduates to write some applets. I suspect the students tend to do things no experienced programmer would be likely to do, and hence uncover bugs that would normally be missed. Remember, any web page or applet that can crash the browser is a potential denial of service attack that indicates a bug in the browser, even if the applet is itself buggy.
Of course, Apple is hardly the only vendor with this problem. Last semester one of my students crafted an applet that succeeded in immediately powering down any Windows box that tried to run it, as if somebody had flipped the power switch or unplugged the box. My Mac was unaffected. None of these students have been looking for such problems. They've all stumbled across them by accident. Java may be hardened against expert attacks, but it's got a ways to go before it can stand up to undergraduates.
Nathan Fiedler has released version 2.37 of JSwat, a graphical, stand-alone Java debugger built on top of the Java Platform Debugger Architecture. Features include breakpoints, source code viewing, single-stepping, watching variables, viewing stack frames, and printing variables. Version 2.37 fixes bugs. JSwat is published under the GPL.
Gaudenz Alder has released JGraph 5.6.1, a free-as-in-speech (Mozilla Public License/LGPL) graph component for Swing that requires Java 1.4 or later. JGraph is accompanied by Graphpad, an open-source diagram editor for Swing that offers Automatic Layout, Printing, Zoom, and much more. It is available in English, German and French. Version 5.6.1 fixes bugs.
Sun and IBM have released the final version of Java Specification Request (JSR) 105, XML Digital Signature APIs. "The purpose of this JSR is to define a standard Java™ API for generating and validating XML signatures." A reference implementation is included with the Java Web Services Developer Pack 1.6. All that's available in the spec is JavaDoc for the javax.xml.crypto package. The lack of any real examples is disturbing. Designing APIs without attemtping to write sample code and tutorials generally leads to APIs that are too hard to use, too hard to understand, have significant gaps in coverage, and spend excessive effort on parts nobody needs. When working on XOM, I don't consider anything complete until there's sample code and documentation, beyond merely the API documentation. The library developer's view of an API is all too often too focused on a class's internals and not focused enough on what the library looks like to a client of the library. Writing tutorials and sample programs forces you to switch perspectives and results in cleaner, saner, simpler APIs.
Sun's posted the public draft review of JSR-244, Java 2 Platform, Enterprise Edition 5.0 to the Java Community Process (JCP). Comments are due by August 8.
Sun has posted the early draft review of JSR-269, Pluggable Annotation Processing API to the Java Community Process (JCP). The spec at this point is pure JavaDoc, and I really wish they'd just put it up on a web site instead of making it a downloadable zip file. According to the JSR,
J2SE 1.5 added a new Java language mechanism "annotations" that allows annotation types to be used to annotate classes, fields, and methods. These annotations are typically processed either by build-time tools or by run-time libraries to achieve new semantic effects. In order to support annotation processing at build-time, this JSR will define APIs to allow annotation processors to be created using a standard pluggable API. This will simplify the task of creating annotation processors and will also allow automation of the discovery of appropriate annotation processors for a given source file.
The specification will include at least two sections, a section of API modeling the Java programming language and a distinct section for declaring annotation processors and controlling how they are run. Since annotations are placed on program elements, an annotation processing framework needs to reflect program structure. Annotation processors will be able to specify what annotations they process and multiple processors will be able to run cooperatively.
The processors and program structure API can be accessed at build-time; i.e. this functionality supplements core reflection support for reading annotations.
Comments are due by August 1.
The GNU Project has released version 4.0.1 of GCC, the GNU Compiler Collection. GCC contains frontends for C, C++, Objective C, Chill, Fortran, Ada, and Java as well as libraries for these languages. GCC's Java is a clean room implementation that doesn't use any Sun code, so it doesn't always exactly match Sun release versions, but this is roughly at the Java 1.4 level with some omissions. Verson 4.0.1 primarily fixes regressions in GCC 4.0.0 relative to previous releases.
Apple has posted a beta of Java 1.4.2 release 2 on the Apple Developer Connection (registration and Mac OS X 10.4 required). This beta will overwrite the existing Java 1.4.x installation, and is not easily uninstallable so be careful. This beta fixes a couple of dozen assorted bugs.
Oracle has submitted JSR 276, Design-Time Metadata for JavaServer Faces Components, to the Java Community Process. According to the JSR,
Design-time tools require both grammar and metadata information for Java Server Faces (JSF) components in order to provide a polished design-time experience. Grammar information, such as the set of available components and what properties exist on those components, is used by tools to guide the user towards valid editing operations. While grammar information can help the tool support the basic operations for creating and manipulating components, metadata can be used to enhance the design-time experience in a variety of ways. Design-time metadata is perfect for simple customizations like changing what name or icon a tool displays for a component, but it can also be used to arrange components or attributes into categories, or even provide information on common design patterns associated with a component.
Although the faces-config.xml language allows a component author to express a great deal of information about their components and renderers, it only has standard syntax for expressing a very minimal set of design-time metadata. In order to provide a polished design-time experience, tool vendors need more information. In the absence of a standard, tool vendors have started to invent proprietary mechanisms for supplying additional design-time metadata for JSF components. Unfortunately, that makes the job of the component author very difficult, if they plan to integrate with multiple tools. In addition, developers that use JSF technology have expressed their frustration and concern with not being able to choose their JSF tool independently from the component library that best meets their needs.
The hope is that through this JSR, the Java community can work together to define a standard solution to this problem. The Expert Group will consist of a representative set of tool vendors and component authors, and the feedback of the community will be actively solicited. The goal is to produce a specification that defines:
- A tool-agnostic set of design-time metadata items (with fixed names and types) that provide information about JSF components, properties, attributes, facets, or renderers that is commonly needed at design-time.
- A standard syntax or mechanism that component authors can use to provide the design-time metadata.
- An extension mechanism that allows tool vendors to safely define additional tool-specific metadata items.
- (Possible) A method for packaging design time artifacts alongside JSF component libraries.
The resulting specification is intended to be compatible with both JSR 127 and JSR 252 without imposing any restrictions on JSF component authors.
In order to ensure that the design-time metadata can be consumed by a wide variety of existing and future JSF tools, it is anticipated that this JSR will not require tool vendors to implement any specific APIs. However, the extension mechanism mentioned above could be utilized to define additional metadata items that are tied to a specific API. For example, additional metadata items could be defined for associating the rich contextual property editors and customizers that are being developed in the Design-Time API for JavaBeans (JSR 273) with JSF components. The extension mechanism gives tool vendors the ability to change and innovate while still benefiting from a shared set of common metadata items and a standard mechanism for providing metadata.
Ralph Jocham has posted version 0.98 of JCSC (Java Coding Standard Checker), a configurable tool for checking Java source code for adherence to standard conding conventions such as naming conventions, code structure, class size, and line length. Version 0.98 adds support for Java 5.. Also, the rules editor can now be launched via Java Web Start. JCSC is published under the GPL. Java 1.3 or later is required.
Websina has released BugZero 4.1.2, a $1299 payware (+$300 for maintenance) Web-based bug tracking system that supports multiple projects, group-based access, automatic bug assignment, file attachment, email notification, and metric reports. Bug Zero is written in Java and can run on top of various backend databases including MySQL. 4.1.2 fixes bugs and improves logging and configurability.
Nathan Fiedler has released version 2.36 of JSwat, a graphical, stand-alone Java debugger built on top of the Java Platform Debugger Architecture. Features include breakpoints, source code viewing, single-stepping, watching variables, viewing stack frames, and printing variables. Version 2.36 better supports JSP and other non-Java languages. JSwat is published under the GPL.
Etienne Gagnon has released version 1.12 of SableVM, a Java bytecode interpreter (that is, a virtual machine) written in C. "SableVM requires an ANSI/ISO C compiler (but preferably GCC) and a POSIX platform. It requires a strong memory model (sequential consistency) on multiprocessor systems." SableVM is available for GNU/Linux, Solaris, and FreeBSD. Besides bug fixes, changes in 1.12 include:
- A SableVM SDK which provides a JAVA_HOME-like environment
consisting of:
- SableVM for 'java'
- jikes for 'javac'
- gjdoc for 'javadoc'
- fastjar for 'jar'
- cp-tools for 'javah', 'javap', and others.
- libffi and libpopt are now bundled with SableVM sources (Hmm, maybe I can now build this on Mac OS X)
- Fixed write barriers for generational garbage collector.
- Imported GNU Classpath 0.16 release (plus later fixes).
- Improved AIX support.
- Improved Cygwin support (not yet supported by SableVM SDK).
SableVM is published under the GNU Lesser General Public License (LGPL).
Samsung has submitted JSR 278, Resource Management Framework, to the Java Community Process. According to the JSR,
Traditionally, Java platforms that run in a single operating system process do not provide explicit management of resources since it is taken care of by the operating system?s intrinsic features. The only resource management facility provided by the virtual machine is the Garbage Collector which is solely responsible of managing memory for all Java objects (regardless of which application they belong to) within a virtual machine. The main limitation of the garbage collector is its inability to handle native resources such as files, sockets, and native memory allocated by JNI native methods. Furthermore, reachability of Java objects may not be sufficient for determining whether an object is indeed "alive" or not, since an object may be reachable through a shared collection of objects (or repository) and yet be bound to a particular application whose lifecycle determines the liveness of the object.
However, several containment frameworks such as Xlet engines typically run in a single virtual machine within a single operating system process and provide an environment that can initiate, run, and terminate multiple applications. When these containment frameworks are embedded in systems requiring high availability, they necessitate explicit management of resources in order to provide a robust and long running environment.
The core of this API is an interface called ResourceManager which defines an interface that all resource managers must provide. The functionality provided by ResourceManager is the ability to force the reclamation of all resources bound to a specific application execution environment. Also, resource managers (classes implementing the ResourceManager interface) may be dynamically added to the framework. This provides extensibility which allows new profiles to be added to the Java platform and still benefit from the integrated resource management framework.
The extensibility feature of this API is the most important factor for proposing this API in the standard JCP process. Any existing or newly profiles that utilizes this API will benefit from its functionality and reversely, any Java platform that supports this API will be able to provide robustness as long as any plug-in profiles support this API.
This API assumes (or may include) the definition of application execution environment, which provides a unique isolated computing environment within a virtual machine that is particular to each application. The Application Isolation API Specification (JSR-121) is particularly well-fit to serve this purpose. It clearly states that resource control is not within its scope.
This API particularly targets J2ME platforms that run in a single process environment. Hence, multi-process virtual machines (mostly in J2SE or J2EE platforms and even in some J2ME platforms) may not benefit from providing this API.
Resource Management Framework (RMF) API will be an optional package for the J2ME configurations CDC. This framework will focus on the ability to control the usage of resources among different applications within a single Java Virtual Machine. RMF will have a resource manager for each resource such as file, thread, socket, image, etc. These resource managers will be kept alive as long as the Java VM is running. All the resources which are bound to a specific application execution environment will be freed by the resource managers upon termination of the environment. The resource managers should be bookkeeping all the resources. The unit of management for the RMF API is an application execution environment. The abstraction introduced by the Application Isolation API (JSR 121) best serves this feature.
Comments are due by July 11.
As expected a few people wrote in to tell me they're using NetBeans. Several of them said Netbeans works very well for them on Windows and my problems must be Mac related, which sort of misses the point. What so upsets Sun about Eclipse (besides the name) is not that it's an IDE that competes with NetBeans. There are plenty of those. The concern is that Eclipse is a complete development platform that makes large parts of Java irrelevant. It effectively takes control of Java away from Sun and puts it in IBM's hands. In other words, it's not Eclipse that worries Sun. It's the SWT and the RCP.
Thus what's really of interest is not the comparison between the IDEs. It's the comparison between the development platforms. That's why Sun is suddenly pushing Netbeans so hard after abandoning and ignoring IDE after IDE for the last ten years. (Java Workshop anyone?) Sun doesn't need to produce an IDE for Java. They're quite happy for Oracle and Borland and others to serve that market. But they desperately need to prevent developers from defecting to the SWT. That means they have to produce a Swing-based, cross-platform IDE that can compete with Eclipse. So far they haven't done that. Eclipse, built on top of the SWT, runs just fine on the Mac. It's certainly not perfect, but it's good enough. NetBeans isn't. If NetBeans can only run acceptably on Windows, then Sun has failed; and their failure proves that Swing is not a viable cross-platform development environment. IBM wins.
Bernhard Fastenrath has posted GetOpt 0.97, a free (GPL)
Java
library that parses command line options such as -d, --help and -version.
The command line options and responses can be stored in XML.
Version 0.97 fixes bugs, especially involving the
built-in web server.
Java 1.4.2 or later is required.
I've posted the second beta release of
XOM 1.1, my free-as-in-speech (LGPL)
dual streaming/tree-based API for processing XML with Java.
Version 1.1 maintains backwards compatibility with XOM 1.0 while adding a number of important new features including XPath queries, document subset canonicalization, exclusive XML canonicalization,
external XSLT parameters, and xml:id support.
The API is now considered to be reasonably stable, and probably won't change before 1.1 final.
Beta 2 is primarily a bug fix release.
Numerous bugs have been fixed in XPath. In
addition a couple of other random issues have been fixed including
namespace handling in SAX conversion and attribute parentage in
copied elements.
This release probably introduces a lot of bugs in serialization with
Unicode Normalization Form C (NFC), though as yet I haven't proved that. Addressing this will be a major focus for beta 3. If anyone has test cases that demonstrate incorrect handling of NFC, I'd appreciate it if you'd send those my way.
Beta 2 also make some optimizations that should slightly decrease
the memory footprint.
XOM requires Java 1.2 or later and is published under the LGPL.
The GNU Project has released version 0.16 of GNU Classpath, an incomplete free implementation of the core Java class libraries. According to the announcement, "The GNU Classpath developer snapshot releases are not directly aimed at the end user but are meant to be integrated into larger development platforms. For example the GCC (gcj) and Kaffe projects will use the developer snapshots as a base for future versions. This is the first release of GNU Classpath since our Harmony collaboration with the Apache group." Improvements in this release include "AWT GtkScrollBar and GtkImage improvements. All image operations are now working correctly. Graphics2D has been upgraded to use Cairo 0.5.x. Free Swing updates for 1.5 top-level compatibility. JTree interface completed. JFileChooser has been implemented. Completed implementations of BoxLayout, GrayFilter and SplitPane. Upgraded the Corba features to 1.3 and included new CORBA 2.3 features. Start of generic JDWP framework. And lots of bug fixes based on real world application usage." Since this is a clean room project, it doesn't always line up exactly with any particular Java version; but it's roughly at the level of Java 1.4 with a few missing pieces and a few pieces pulled in from 1.5. GNU Classpath is published under the GPL with library exception.