The Java Apache Project has released the Java Apache Mail Enterprise Server (JAMES) 2.3.0. It's a 100% pure Java Mail Server which introduces Mailets. The idea is to do for email what servlets do for the Web. You can use maillets to automatically process and reply to email messages using the full power of Java. James is published under the Apache 2.0 license.
Sun has released NetBeans 5.5. According to the web site, "NetBeans 5.5 generates JAX-WS 2.0 artifacts for Java SE 6 and Java EE 5 projects. We included Java Persistence support and support for Enterprise Java Beans 3. Additionally, there is a preview of the new Subversion support module available on the 5.5 Beta Update Center"
Bare Bones Software has released version 8.5.1 of BBEdit, my preferred text editor on the Mac, and what I'm using to type these very words. New features include support for support for Ruby, SQL, and YAML; code folding; HTML Format, Translate and Tidy; and autosave. BBEdit is $199 payware. 8.5.1 is a bug fix release. Mac OS X 10.3.9 or later is required.
Dmitry Markman
has released webkit4java,
a "simple Java web browser based on Apple's WebKit API and
CocoaComponent technology."
Mac OS X 10.3 and Java 1.4.1 or later are required.
webkit4java is published under a BSD license.
C.N. Medappa has released JRex,
a Java component that embeds the
Mozilla Gecko rendering engine
within a Java app.
Mantis 1.0.6, a free-as-in-speech (GPL) bug tracking system based on PHP and MySQL, has been released. This is a bug fix release.
The Jakarta Apache Project has posted the first alpha of Tomcat 6.0 open source servlet container and official reference implementation of the Java Servlet API and Java Server Pages (JSP) from JEE 5.
Sun has submitted JSR-308, Annotations on Java Types, to the Java Community Process. According to the JSR,
We propose an extension to Java's annotation system that permits annotations to appear on any use of a type, not just on class/method/field/variable declarations, as is the case in Java SE 6. Such a generalization removes arbitrary limitations of Java's annotation system, and it enables new uses of annotations.
This JSR specifies the syntax of extended Java annotations, but it makes no commitment as to their semantics. As with Java's existing annotations, the semantics is dependent on annotation processors (compiler plug-ins), and not every annotation is necessarily sensible in every location where it is syntactically permitted to appear. This proposal is compatible with existing annotations, such as those specified in JSR 250, "Common Annotations for the Java Platform", and JSR 305, "Annotations for Software Defect Detection".
This proposal does not change the compile-time, load-time, or run-time semantics of Java. It does not change the abilities of Java annotation processors. The proposal merely makes annotations more general --- and thus more useful for their current purposes, and also usable for new purposes that are compatible with the original vision for annotations.
The new Java syntax allows annotations in the following locations. (The specific annotation names, such as @NonNull, are examples only; this document does not propose any annotations, merely specifying where they can appear in Java code.)
- method receivers:
public int size() @Readonly { ... }- generic type arguments:
Map<@NonNull String, @NonEmpty List<@Readonly Document>> files;- arrays:
Document[@Readonly] docs1;
Document[][@Readonly] docs2 = new Document[2][@Readonly 12];
(docs1 is an unmodifiable one-dimensional array of mutable Documents. docs2 is a mutable array whose elements are unmodifiable one-dimensional arrays of mutable Documents.)- typecasts:
myString = (@NonNull String)myObject;- type tests:
boolean isNonNull = myString instanceof @NonNull String;- object creation:
new @NonEmpty @Readonly List(myNonEmptyStringSet)- type parameter bounds:
class Folder { ... }- class inheritance:
class UnmodifiableList implements @Readonly List<@Readonly T> { ... }- throws clauses:
void monitorTemperature() throws @Critical TemperatureException { ... }Java annotations (including the extended annotations) must be stored in the class file for two reasons. First, they may be part of the interface of a class and, if so, must be available to the compiler (really, to the type-checking plug-in) when compiling clients of the class. Second, since class files may originate from any source, the information may be useful in other contexts, such as compile-time verification.
This JSR proposes conventions for storing the new annotations, as well as for storing local variable annotations, which are permitted in Java syntax but currently discarded by the compiler. Class files already store annotations in the form of ``attributes''. JVMs ignore unknown attributes. For backward compatibility, we use new attributes for storing the type annotations. In other words, our proposal merely reserves the names of a few attributes and specifies their layout. Our proposal does not alter the way that existing annotations on classes, methods, method parameters, and fields are stored in the class file. Class files generated from programs that use no new annotations will be identical to those generated by a standard Java SE 6 (that is, pre-extended-annotations) compiler.
This JSR introduces two new attributes: RuntimeVisibleTypeAnnotations and RuntimeInvisibleTypeAnnotations. These attributes are structurally identical to the existing RuntimeVisibleAnnotations and RuntimeInvisibleAnnotations attributes described above with one exception: rather than an array of annotation elements, RuntimeVisibleTypeAnnotations and RuntimeInvisibleTypeAnnotations contain an array of extendedannotation elements. An extendedannotation element is like an annotation element, but it adds a target_type field and a reference_info field.
The specification will also attempt to provide a simple approach for writing annotations with array-valued elements.
Comments are due by October 30.
Mark Hale has posted version 0.94 of JSci, a class library containing many useful mathematical and scientific functions such as complex arithmetic. This release moves the matrix and vector classes into separate sub-packages, adds bisection and Newton-Raphson methods to NumericalMath, adds a a histogram graph, and adds an instruments package.
TechnoBuff has released JRequire 2.0, a $650 payware
requirement coverage tool based on JUnit.
Once reuirements are written in Eclipse and manually mapped to unit tests, JRequire will tell you which tests match which requirements.
I don't know. Sounds like a lot of effort for relatively benefit for me.
This feels like it belongs in the heavyweight world of UML, big-name processes, and pointy-haired bosses, rather than the agile world I prefer.
JetBrains has released BuildDesk a $199 payware tool for generating Ant scripts from IDEA projects. It will also generate
native installers and launchers for Mac OS X and Windows, and obfuscate JAR files.
.
Sun has released JSR-231 Java Bindings for OpenGL to the JCP. This describes the Java bindings to a native OpenGL 3D graphics library.
Sun has also released the completed JSR-239 Java Bindings for OpenGL ES. This "API enables access to a low level 3D graphics library through a standard Java interface. OpenGL® is the de facto standard 3D libraries on the desktop, and with the matching OpenGL® ES specification for embedded devices, it is rapidly becoming the de facto standard for a platform independent, low level 3D API in the embedded market. Developers can leverage their knowledge of programming in OpenGL® to program rich 3D content for handheld and other embedded devices."
Paul R. Holser has released JOpt Simple 2.2, 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()."
JOpt Simple is published under the Academic Free License.
Sean C. Sullivan has posted the second alpha of Barbecue 1.5,
an open-source (BSD license) for creating
"barcodes for printing and display in Java applications. A number of barcode formats are supported and many more can be added via the flexible barcode API. Barcodes can be output to three different image formats (PNG, GIF, JPEG), used as a Swing component, or written out as SVG."
Sebastiano Vigna has released version 5.0.5 of fastUtil,
a collection of type-specific Java maps and sets with a small memory footprint
and faster access and insertion. The classes implement their standard counterpart interfaces such as java.util.Map
and can be plugged into existing code. However, they also contain type-specific methods. For instance, the CharList class has not only the usual add(Object o) method but also an add(char c) method.
This is a bug fix release.
fastUtil is published under the GNU Lesser General Public License (LGPL).
Charles Oliver Nutter, Thomas Enebo, and Ola Bini have released JRuby 0.9.1, a "1.8.4 compatible Ruby interpreter written in 100% pure Java." It also supports the Bean Scripting Framework. This release fixes bugs, speeds up performance, and can better handle Rails.
JRuby is distributed under three licenses CPL, GPL, LGPL. That's just way too confusing. There's zero-need to dual license under both the LGPL and GPL since the LGPL explicitly allows code to be forked into a pure GPL product.
Oracle has released JDeveloper 10.1.3.1.0 (Build 3984), a free-beer IDE for Java. This release adds various SOA development tools including a BPEL designer and an ESB designer.
The Apache Portal Project has posted the second beta of Pluto 1.1, the open source reference implementation of the Java Portlet Specification. According to the web page,
Portlets are designed to run in the context of a portal. They are written to the Portlet API which are similar to the Servlet API.
In contrast to servlets, portlets may not do things like sending redirects or errors to browsers directly, forwarding requests or writing arbitrary markup to the output stream to assure that they don?t distract the portal web application which uses them. Another difference compared to servlets is that portlets rely on portal specific infrastructure functions such as access to user profile information, standard interface for storing/retrieving persistent settings, getting client information, etc. Generally, portlets are administrated more dynamically than servlets typically are.
A portlet container provides a runtime environment for portlets implemented according to the Portlet API. In this environment portlets can be instantiated, used and finally destroyed. The portlet container is not a stand-alone container like the servlet container; instead it is implemented as a thin layer on top of the servlet container and reuses the functionality provided by the servlet container.
Pluto serves as portlet container that implements the Portlet API and offers developers a working example platform from which they can test their portlets. However, it's cumbersome to execute and test the portlet container without a driver, in this case, the portal. Pluto's simple portal component is built only on the portlet container's and the JSR 168's requirements.
According to Craig Doremus, version 1.1 "is a major refactoring of Pluto 1.0.1 to allow for easier integration of Pluto's portlet container into a portal and easier configuration of the Pluto portal driver, a bare-bones portal included with Pluto. This release fixes a number of bugs in Pluto 1.1 including ones that prevented standard portlet modes and window states from functioning properly. We've also updated the binary release to deploy Pluto into Tomcat 5.5.17."
TopMind Systems has released
jLynx 1.2, an open source library for Object / Relational mapping that "lets you persist POJOs and Maps very easily, plus it keeps SQL code and connection configuration in XML. Simple database transactions (i.e. CRUD operations) involving a single POJO require no XML mapping or SQL.
jLynx generates JavaBean objects based on your database schema. For example if you have 24 tables and views in your database, jLynx will create 24 objects with properties that map to the field names in each table. The jLynx Generator creates the objects and compiles them. You can also use the generated source instead if you prefer to customize the objects." jLynx is published under a BSD license.
JBoss has released Hibernate 3.2, an open source (LGPL) object relational mapping system for Java. "Hibernate lets you develop persistent classes following common Java idiom - including association, inheritance, polymorphism, composition and the Java collections framework. The Hibernate Query Language, designed as a 'minimal' object-oriented extension to SQL, provides an elegant bridge between the object and relational worlds. Hibernate also allows you to express queries using native SQL or Java-based Criteria and Example queries." Version 3.2 adds support for the Java Persistence API from JEE 5.
Enterprise Distributed Technologies has released edtFTPj/Pro 1.3.0, a $299 payware FTP library for Java that supports FTP over SSL. Version 1.3.0 adds a new manual and fixes bugs.
Sun has posted the early draft review of JSR-277, Java Module System to the Java Community Process (JCP). According to the draft,
Java Archives (JARs) are widely used as both the distribution format and the execution format for Java applications. The JAR file format dates back to the mid-1990s, and it has not scaled particularly well in either of these roles. JAR files are hard to distribute, hard to version, and hard to reference in general.
Distributing a simple Java application is considered to be a complicated task by many developers because it often involves creating a native installer to package multiple JAR files into a distribution unit, and it sometimes involves converting the application into a Java applet or JNLP (Java Network Launching Protocol) application for web-based deployment. The versioning support in the JAR file format is for expressing dependencies on Java extensions (a.k.a optional packages), but not the version of the JAR file itself. There is also no reliable mechanism for expressing, resolving, and enforcing the dependency of one JAR file upon another. Referencing a JAR file, moreover, involves specifying it in the classpath. Since the path of a JAR file may change during deployment, developers are forced to fix up all the references to the deployed JAR files as part of the deployment process.
Developers also find it quite difficult to deploy installed Java extensions because they can easily run into issues like versioning conflict and namespace collision. Java extensions can currently only be installed into a specific Java Runtime Environment (JRE); it is basically impossible to arrange for an installed extension to be shared across multiple JRE installations. The overall goal of the Java Module System is to define a solution that addresses the above issues.
The Java Module System defines an architecture with the following components:
- A distribution format (i.e., a Java module) and its metadata as a unit of delivery for packaging collections of Java classes and related resources. The metadata contains information about the module, classes and resources within the module, and its dependencies upon other modules. The metadata also includes list of exports to restrict classes and resources from being exposed outside the module unintentionally.
- A versioning scheme that defines how a module declares its own version as well its versioned dependencies upon other modules.
- A repository for storing, discovering, and retrieving modules with versioning and isolation support.
- Runtime support in the application launcher and the class loaders for discovering, loading, and integrity checking of modules.
The Java Module System is compatible with Java SE 7 or later.
Comments are due by November 13.
Sun has posted the proposed final draft of JSR-268
Java Smart Card I/O API
to the Java Community Process (JCP). This defines the javax.smartcard package.
Sun has posted the proposed final draft of JSR-269, Pluggable Annotation Processing API to the JCP. The spec 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 Apache Project has posted the third beta of version 1.7 of Ant, the popular XML based, open source build tool for Java.
Ant 1.7 introduces a resource framework. Some of the core ant tasks such as <copy/> are now able to process not only file system resources but also zip entries, tar entries, paths, ... Resource collections group resources, and can be further combined with operators such as union and intersection. This can be extended by custom resources and custom tasks using resources.
Ant 1.7 starts outsourcing of optional tasks to Antlibs. The .NET antlib in preparation will replace the .NET optional tasks which ship in Ant. Support for the version control system Subversion will be only provided as an antlib to be released shortly.
Ant 1.7 fixes also a large number of bugs.
Ant 1.7 has no support for Java6 features, but first tests on Java6 did not fail.
Beta 3 mostly fixes bugs.
The Apache Ant Project has also posted the first beta of AntUnit 1.0, an Ant library that "contains tasks to test Ant tasks using Ant instead of JUnit."
JPOX 1.1.3, an open source implementation of Java Data Objects (JDO) 2.0, has been released. that provides transparent persistence to Java objects. It supports most major SQL databases and can be queried using either JDOQL or SQL. 1.1.3 simplifies user-defined type mappings and supports same-named subclass fields in the superclass table. It's published under the Apache 2.0 License.
Ben Litchfield has posted PDFBox 0.7.3, an open source (BSD license) Java library for manipulating PDF documents and extracting contents from existing PDF documents. This release fixes bugs.
Nathan Fiedler has released version 3.13 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 3.13 makes assorted small interface and functionality improvements. JSwat is now published under the Sun Public License. (It was previously published under the GPL.)
JPOX 1.1.3, an open source implementation of Java Data Objects (JDO) 2.0, has been released. that provides transparent persistence to Java objects. It supports most major SQL databases and can be queried using either JDOQL or SQL. This release makes several small changes and assorted bug fixes. It's published under the Apache 2.0 License.
The Big Faceless Organization has released the Big Faceless PDF Library 2.7.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.7.3 improves font handling for non-ASCII characters.
Jayasoft has released Ivy 1.4, a free Java based dependency manager, that features
transitive dependencies, Ant integration, Maven compatibility,
and continuous integration. New features in this
release include SSH, SFTP, and WebDAV repositories.
Numerous bugs have also been fixed.
Simon Kågström has released
Cibyl 4, a free-as-in-speech (GPL) "programming environment that allows compiled C programs to execute on J2ME-capable phones. Cibyl uses GCC to compile the C programs to MIPS binaries, and these are then recompiled into Java bytecode. The programs are not parsed during runtime, and Cibyl is therefore well-performing. With Cibyl, games written in C can be ported to J2ME without switching language. The environment is tied to the GNU compiler tools (GCC and binutils) and only tested on Linux so far although it should work in other environments as well."
Achim Westermann has released JChart2D 2.1, a thread-safe, libré (LGPL) Swing widget for drawing x-y plots. new features in this release include viewports, run-time configuration by popup menus for traces and charts, and flexible rendering of traces by discs, polylines, and filled polygons. Version 2.1 adds bidirectional zoom, configurable error bars, and anti-aliasing.
Ben Litchfield has posted PDFBox 0.7.3, an open source (BSD license) Java library for manipulating PDF documents and extracting contents from existing PDF documents. This release fixes bugs.
ej-technologies has released version 4.0 of exe4j, a $99 payware tool for integrating Java programs into Windows with your own process name, task-bar grouping, native splash screens, and so forth. New features in 4.0 include:
- Long path names on Windows
- Display splash screen before JAR files are unpacked
- Configurable execution level for Windows Vista
- Can generate 64-bit executables that work with 64-bit JREs
ej-technologies has released Install4j 4.0, a $1698 payware cross platform tool for building native installers and application launchers for Java applications. New features in 4.0 include configurable form screens, multi-language installers, console installers, network installers, and support for 64-bit Windows and Vista.
TRIEMAX Software has released Jalopy 1.7, a $40 payware source code formatter for Java It includes Plug-ins for Ant, Eclipse/WSAD, IDEA, JBuilder, JDeveloper, jEdit and NetBeans/Sun ONE Studio, but can also be used as a stand-alone tool. Version 1.7 adds support for Maven 2 and Eclipse 3.2, nested profiles, and various other small features and options. Java 1.3 or later is required.
ej-technologies GmbH has released version 4.2.2 of JProfiler, a $698 payware profiler based on the Java virtual machine profiling interface (JVMPI that can report on CPU usage, memory size, threads, and "VM telemetry" (whatever that is). This is a bug fix release.
Sun has posted the proposed final draft of JSR-202 JavaTM Class File Specification Update. According to the draft, "The main difference is the introduction of a new verification scheme based on type checking rather than type inference. This scheme has inherent advantages in performance (both space (on the order of 90% savings) and time (approximately 2x)) over the previous approach. It is also simpler and more robust, and helps pave the way for future evolution of the platform."
The Apache DB Project has released Apache Derby 10.2.1.6, an open source SQL database written in pure Java that supports JDBC. 10.2 adds the GRANT, REVOKE, SHOW TABLES and DESCRIBE SQL commands. It also now supports online backup and can invoke stored procedures from a trigger.
The Jakarta Apache Project has released the Bean Scripting Framework (BSF) 2.4.
BSF is an open source class library that "provides scripting language support within Java applications, and access to Java objects and methods from scripting languages. BSF allows one to write JSPs in languages other than Java while providing access to the Java class library. In addition, BSF permits any Java application to be implemented in part (or dynamically extended) by a language that is embedded within it. This is achieved by providing an API that permits calling scripting language engines from within Java, as well as an object registry that exposes Java objects to these scripting language engines."
Alan Ezust has uploaded the seventh pre-release of jEdit 4.3, an open source programmer's editor written in Java with extensive plug-in support and my preferred text editor on Windows and Unix. Besides bug fixes, this pre-release adds various new API methods.
Bill Pugh of the University of Maryland has released FindBugs 1.1.1, an automated open source tool for finding potential bugs in Java code. This is mostly a bug fix and optimization release, but it does add one new detector for SE_BAD_FIELD_INNER_CLASS.
Lorenzo Bettini has released GNU Source-highlight 2.5, a GPL'd tool for reading Java, C/C++, Prolog, Perl, PHP3, Flex, ChangeLog, JavaScript, LUA, CAML, SML, Log, C#, XML, and Python code and translating them into syntax highlighted HTML and XHTML. This release adds support for cls, dtx, and sty LaTeX files as well as Tcl, SQL, and BibTeX. Binaries are available for Unix, and it should compile on Windows with the appropriate libraries.
The Jakarta Apache Project has released Commons Lang 2.2, an open surce collection of "helper utilities for the java.lang API, notably String manipulation methods, basic numerical methods, object reflection, creation and serialization, and System properties. Additionally it contains an inheritable enum type, an exception structure that supports multiple types of nested-Exceptions, basic enhancements to java.util.Date and a series of utlities dedicated to help with building methods, such as hashCode, toString and equals." Classes include:
CharRangeCharSetCharSetUtilsCompareToBuilderEnumEnum.EntryEnumUtilsEqualsBuilderExceptionUtilsHashCodeBuilderNestableNestableDelegateNestableErrorNestableExceptionNestableRuntimeExceptionNumberRangeNumberUtilsObjectUtilsObjectUtils.NullRandomStringUtilsSerializationExceptionSerializationUtilsStandardToStringStyleStringUtilsSystemUtilsToStringBuilderToStringStyleToStringStyle.DefaultToStringStyleToStringStyle.MultiLineToStringStyleToStringStyle.NoFieldNameToStringStyleToStringStyle.SimpleToStringStyleValuedEnumArrayUtilsBitFieldBooleanUtilsCharRange (previously package scoped)ClassUtilsStringEscapeUtilsWordUtilsIllegalClassExceptionIncompleteArgumentExceptionNotImplementedExceptionNullArgumentExceptionSerializationExceptionUnhandledExceptionValidateIntRangeLongRangeRangeDoubleRangeJVMRandomNumberRangeFloatRangeNumberUtilsFractionRandomUtilsDateFormatUtilsFastDateFormatDateUtilsStopWatch
Besides bug fixes, the main new addition in this release is
a new text package that adds
CompositeFormat,
StrBuilder,
StrLookup,
StrMatcher,
StrSubstitutor, and
StrTokenizer classes.
There's a lot of good stuff here. Everyone should check it out, at least for the ideas even if you don't want to use the library.
Larry Ogrodnek
has released Sparklines for Java 1.0.
"Sparklines are 'intense, simple, wordlike graphics.' They are detailed in Edward Tufte's latest book, Beautiful Evidence and also in his message board."
Sparklines for Java contains Java and JSTL libraries for drawing sparklines.
Tom Copeland has released PMD 3.8, an open source tool for automatically checking Java code for various classes of bugs. Version 3.8 fixes bugs and adds four new rules: BrokenNullCheck, AvoidRethrowingException, UnnecessaryWrapperObjectCreation, and UselessStringValueOf.
As is my custom, I tested these new rules out on XOM. UnnecessaryWrapperObjectCreation and UselessStringValueOf were triggered once each.
The UnnecessaryWrapperObjectCreation was really a false positive, since the rule it's based on only applies in Java 1.4 and later, and XOM tries to be compatible with Java 1.2. UselessStringValueOf was accurate, though I'm not sure how important it was.
It certainly wasn't a bug; maybe a small code cleanup or a tiny performance hit.
AvoidRethrowingException was triggered seven times, and every
one was a false positive.
Health Market Science, Inc. has released Jackcess 1.1.7, an open source (LGPL) Java library for reading and writing Microsoft Access 2000 (not 2003) files. This release adds support for compressed' indexes, overflow row reading, and multi-page long values.
JetBrains has released IntelliJ IDEA 6.0. New features in 6.0 include:
- EJB 3.0
- Struts
- GWT
- Enhanced Swing GUI designer
- Code coverage
- JUnit 4
- Instant messaging
IDEA is $499 payware. Upgrades from previous version are $299.
JetBrains has also released TeamCity 1.0, an "IDE independent, integrated team environment targeted for .NET and Java software developers and their managers. It automates and coordinates key collaborative processes to eliminate manual systems and delays, providing tight integration with multiple build and test tools, real-time unit test frequency, server-side inspections and code coverage analysis." TeamCity is $399 payware, and is bundled with IDEA 6.0, at least for the time being.
The Legion of the Bouncy Castle has released version 1.34
of the Bouncy Castle Java Cryptography API, an open source,
clean-room implementation of the Java Cryptography Extension (JCE).
It supports X.509 certificates, PKCS12, S/MIME, CMS, PKCS7, and lots of other juicy acronyms. It also includes its own light-weight crypto API that works in Java 1.0 and later, and does not depend on the JCE.
According to Jon Eaves:
This release contains a very, very important security update against RSA. Please make sure you read the details on the website, and upgrade if it affects you.
If you are using RSA with a public exponent of three you must upgrade to this release if you want to avoid recent forgery attacks that have been described against specific implementations of the RSA signature algorithm.
In addition to the above fix, this release also adds use of the SHA2 family to ECDSA for signatures and certificate generation. The range of KDF functions has been increased and an endianess issue with KDF2 has been fixed. Uses of toUpperCase in the library are now locale independent and fixes have also been applied to the OpenPGP and SMIME libraries.
Download it while it's still legal.
Christopher Deckers has released SWTSwing 3.2.0004, "a port of the SWT graphical toolkit to Swing." It's published under the Eclipse Public License. It seems fairly rough right now, but it's an interesting idea. According to Deckers, "This release is an important milestone, because it allows to run most of the Eclipse 3.2 Java SDK." That "most" worries me. It's not uncommon that the first 80% of funcitonality takes 80% of the work, and the next 20% takes the other 80% of the work. :-)
Oracle has released Berkeley DB Java edition 3.1.0. 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." New features in this release include an EJB-style API Direct Persistence Layer based on Java annotations.
IBM's developerWorks has published my latest article, Fuzz testing. This article introduces a technique for hardening applications against unexpected input. Implemented well, fuzz testing dramatically reduces the chance your application will crash in production. It is also a critical technique for security conscious programmers. If you don't use these techniques, crackers will. If you've never heard the term "fuzz testing" before, you need to read this article.