Oracle has submitted JSR-329: Portlet 2.0 Bridge for JavaServerTM Faces 1.2 Specification to the Java Community Process (JCP). According to the JSR,
The Java Portlet 2.0 Bridge for JavaServer Faces 1.2 Specification defines the required behavior of a control environment designed to run in a JSR 286 portlet and JSF 1.2 runtime. Its control behavior allows a JSF application/view to be accessed as a Java portlet.
Because the portlet bridge lies between the portlet container and the Faces runtime, its behavior and function depends on the semantics each expresses and supports. Differing versions of either the Portlet specification or the Faces specification requires a distinct bridge specification and implementation to fully express all available function. Though JSR 301, in defining the Portlet 1.0 Bridge for JavaServer Faces 1.2, provides a solid base for a Portlet 2.0 bridge the following new features in portlet 2.0 require a distinguished specification:
- ability to serve a resource directly from a portlet
- ability to send and receive events
- ability to define and operate on public render parameters
- ability to wrap portlet requests and response objects
- ability to use dispatch.forward.
Comments are due by February 9.
Sun has announced its results for the second quarter of its fiscal year (ended in December) and they're pretty dismal. They lost $209 million on a GAAP basis or $0.28 per share. Revenues was $3.220 billion, a 10.9 percent drop from the second quarter of fiscal 2008, though up 7.7 percent from the previous quarter. They still have three billion in the bank, which could last them a few years.
The Jakarta Apache Project has released Cactus 1.8.1, a simple framework for unit testing server-side Java code such as servlets, Enterprise JavaBeans, tag libraries, etc. Version 1.8.1 adds a Maven2 plugin to cactify your WAR and EAR files, as well as a sample application showing how to test EJB3 projects.
Google has released the finished version final draft review of JSR-284 Resource Consumption Management API along with a refreshingly open (Apache License 2.0) reference implementation and compatibility kit. According to the spec,
The
javax.rcmpackage supports resource management for Java applications. Resource management is necessary for load balancing in systems, monitoring and accounting of resources, ensuring graceful degradation in the event of resource shortages, and for thwarting denial of service attacks.The resource management API allows programmers to define resources as well as resource management policies that control usage of these resources at execution by resource consumers.
A resource management policy can restrict the number of resources consumed by an application or throttle the rate of consumption. Further, a policy can specify actions to take following consumption in order to implement monitoring and accounting, and also define reservations for an application that guarantee resource availability at execution.
A resource consumer is a programmable entity whose resource usage needs to be controled. A thread is always a valid resource consumer, but implementations of this JSR may define other types of resource consumers. For instance, an implementation may consider the JVM itself to be a valid resource consumer, thus allowing resource management for the whole JVM.
Implementations of the JSR are also free to define new types of platform resources, as the JSR is extensible in this respect. Thus, in addition to well-known resources such as the CPU time, heap memory, disk space, network resources, etc., the API can support resources such as the number of JDBC connections, the rate of successful transactions, the number of requests in progress, etc. Consult the compliance section of this document to see what resources are required by compliant implementations of the JSR 284.
The motivation and justification of some design choices of this JSR are given in this technical report. Note however that this technical report is not part of this specification.
Kent Beck has released JUnitMax. "JUnit Max is an Eclipse plug-in that helps programmers stay focused on coding by running tests intelligently and reporting results unobtrusively. Every time you save a Java file, Max will run your tests and report errors like compile errors. In addition, Max runs the tests most likely to fail first, so you only have to pay close attention to test results for a second (literally) before getting back to coding, even if you have a long-running test suite." The licensing model is one I haven't seen before: $2/month. "If you stop paying, please stop using it."
I've posted the third beta of XOM 1.2, my free-as-in-speech (LGPL) library for processing XML with Java. Compared to the 1.0-->1.1 transition, this is a very minor upgrade. There are just a couple of additional methods, a few bug fixes, and maybe a small optimization or two. All code written to the 1.1 or 1.0 APIs should run unchanged with 1.2. This beta upgrades jaxen to 1.1.2 and optimizes UnicodeUtil, which should be somewhat easier to compile now. If no one notices any major problems in this release, I'll probably declare it 1.2 final in a couple of weeks.
Paul R. Holser has released JOpt Simple 3.0, an open source
"Java library for parsing command line options, such as those you might pass to an invocation of javac.
As closely as possible, JOpt Simple attempts to honor the command line option syntaxes of POSIX getopt() and GNU getopt_long()."
Version 3 requires Java 5 or later.
JOpt Simple is published under the Academic Free License.
Teodor Danciu has released JasperReports 3.1.3, 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. Version 3.1.3 can use TrueType fonts without installing them into the system and adds XML-based chart theme implementations.
IBM's developerWorks has published my latest article, Java's new math, Part 2: Floating point numbers. Sometimes you're so familiar with a class you stop paying attention to it. If you could write the documentation for java.lang.Foo, and Eclipse will helpfully autocomplete the functions for you, why would you ever need to read its Javadoc? Such was my experience with java.lang.Math, a class I thought I knew really, really well. Imagine my surprise, then, when I recently happened to be reading its Javadoc for possibly the first time in half a decade and realized that the class had almost doubled in size with 20 new methods I'd never heard of. Obviously it was time to take another look.
Java 5 added 10 new methods to java.lang.Math
and Java 6 added another 10. Part 2 focuses on the functions that make sense only when you realize that they're designed for operating on floating-point numbers instead of abstract real numbers.
Ascom Deutschland GmbH has submitted JSR-328: Change Management API to the Java Community Process (JCP). According to the JSR,
Change Management (CM) ensures that changes are recorded, evaluated, approved, authorized, prioritized, planned, tested, implemented, documented and reviewed in a controlled manner. The purpose of the Change Management process is to ensure that standardized methods are used for the efficient and prompt handling of all changes; that all changes are recorded in the Configuration Management System and that overall business risk is optimized. Change management delivers, to the business, reduced errors in new or changed services and faster, more accurate implementation of changes; it allows restricted funds and resources to be focused on those changes to achieve greatest benefit to the business. This JSR proposes an API Specification for Change Management systems to operate request for changes following the IT Infrastructure Library (ITIL) "Change Management" recommendations and principles (as described in Chapter 8: Change Management, of the "Service Support" document).
The data model for this API is defined around the Request For Change (RFC) entity. The main interface focuses on creating, retrieving, updating, approving and removing RFC. This JSR is defined and developed on top the OSS Common API (JSR 144). It will use or extends the Core business Entities (CBE) following the OSS Design Guidelines and format (documentation, specification, Reference Implementation and TCK bundle format).
Comments are due by January 20.
On a side note, it feels like new submissions ot the JCP have really slowed down of late. This is the first one since October. That's probably a good thing.
The Big Faceless Organization has released the Big Faceless PDF Library 2.11.1. This seems to mostly be a small bug fix release. (Consequently you may well not wish to upgrade to this version. Personally I want software to do what I tell it to do, not what someone else tells it to do.) The library costs $850 (more if you want support).
David Gilbert has released JFreeChart 1.0.12. "This release adds support for minor tick marks and mapping datasets to more than one axis." JFreeChart is free software under the terms of the GNU Lesser General Public Licence (LGPL), and requires Java version 1.3.1 or later.
The Apache James Project has released Apache Mailet 2.4. "The Mailet API is a mature standard for enterprise mail agents....A Mailet implementing this API can be reused in a variety of containers including Apache James (http://james.apache.org/server). 2.4 is the first independent release: previous versions of the API have been bundled as part of Apache James."
Sun has posted the public review draft of JSR-303 Bean Validation. This enables one to define constraints that can be applied to method arguments via annotations. However it's limited, and requires JavaBeans method-naming conventions to be followed. This would be better addressed by language-level support for preconditions and class invariants. Liek generics and the various closure proposals, it's a half-measure that's too crippled by backwards compatibility to really achieve its goals. Sometimes, when you can't do something the right way, it's better not to do it at all. Whether Bean Validation is one of those times, I'm not yet sure; but I'm beginning to suspect it is.
In the unlikely event anyone needs yet another way to listen to me blather, I now have a Twitter feed.