Yes. Any product conforming to the J2EE 1.3 or later specifications can be used to run this benchmark. CTS certification ensures that the application server being tested is a J2EE technology-based application server and not a benchmark-special application server that is crafted specifically for SPECjAppServer2004. The CTS certification is validated by Sun Microsystems, Inc.

The Java 2 SDK, Enterprise Edition 1.4 (J2EE 1.4 SDK) is a complete package for developing and deploying J2EE 1.4 applications. The J2EE 1.4 SDK contains the Sun Java System Application Server Platform Edition 8, the J2SE 1.4.2 SDK, J2EE 1.4 platform API documentation, and a slew of samples to help developers learn about the J2EE platform and technologies and prototype J2EE applications. The J2EE 1.4 SDK is for both development and deployment.

In addition to the hardware for the system under test (SUT), one or more client machines are required, as well as the network equipment to connect the clients to the SUT. The number and size of client machines required by the benchmark will depend on the injection rate to be applied to the workload.

In addition to the operating system and the Java Virtual Machine (JVM), SPECjAppServer2004 requires a J2EE 1.3-compatible application server, a relational database server, and a JDBC driver.

J2EE applications that are written to the J2EE 1.3 specification will run in a J2EE 1.4 implementation. Backwards compatibility is a requirement of the specification.

April 26, 2004. See the press release at http://www.sun.com/smi/Press/sunflash/2004-04/sunflash.20040426.1.xml.

The J2EE 1.4 features complete Web services support through the new JAX-RPC 1.1 API, which supports service endpoints based on Servlets and enterprise beans. JAX-RPC 1.1 provides interoperability with Web services based on the WSDL and SOAP protocols. The J2EE 1.4 platform also supports the Web Services for J2EE specification (JSR 921), which defines deployment requirements for Web services and utilizes the JAX-RPC programming model. In addition to numerous Web services APIs, J2EE 1.

Refactoring J2EE components to delegate functionality to other objects that don't have to be run in a J2EE container will improve the design and testability of the software. Cactus is an open source JUnit extension that can be used to test J2EE components in their natural environment.

The J2EE 1.4 specification is final and you can use the J2EE 1.4 SDK to deploy applications today. However, for improved reliability,scability, and performance, it is recommended that you deploy your applications on J2EE 1.4 commercial implementations that will be available early in 2004. If you want to deploy your application before 2004, and reliability,scability, and performance are critical, you should consider using a high performance application server that supports J2EE v1.

JSP: It is possible to use AspectJ to affect code in JSPs by precompiling them into Java sources and compiling these with ajc. This can be used, e.g., to customize displays by turning on and off custom JSP taglibs. The mapping from a given jsp source to java package and class name is not standardized, which means doing this imposes dependencies on specific container versions. EJB: AspectJ supports a wide variety of aspects for EJBs.

There are numerous choices of tools available for developing Java and J2EE applications. You can download the Open Source NetBeans IDE for free at http://netbeans.org. Many of the J2EE compatible vendors offer tools that support any J2EE compatible application server.

SPECjAppServer2002 requires a J2EE 1.3 compatible server as well as a database server. See section 2.2 in the SPECjAppServer2002 Run and Reporting Rules for details on all the products. Also, a Java Runtime Environment (JRE) version 1.3 or later must be installed on the client machines.

The general command lines required for executing a program are given on the code description pages, along with pointers to additional documentation for the codes.

one objective of the site is to track software advances, competition between codes is welcomed. However, in the interests of fairness, if you wish to have your results posted, you must Run a model that is identical in all respects to the benchmark model. This includes, but is not limited to, element formulation, the number of integration points, time step scaling, material models, and domain decomposition (including the specification of contact surfaces).

As noted, Ethereal is licensed under the GNU General Public License. The GPL imposes conditions on your use of GPL'ed code in your own products; you cannot, for example, make a "derived work" from Ethereal, by making modifications to it, and then sell the resulting derived work and not allow recipients to give away the resulting work.

Yes, but we didn't do that so far. (When developing J2EE applications, you often generate your classes from a model. Why not generate the test skeletons from that model as well?) How do you test EJBs anyway? There are several ways to do it, none is as widely spread as the JUnit framework itself, so we don't support them. Here is a list of things to do: Write your own templates. (They are specific to your way of testing. We can't provide a general solution.) Write your own TestingStrategy.

Minimus is very price conscious, and we want to offer our customers the best deals possible on our products. If we get a good deal from a supplier, we’ll pass it along to our customers. We always have items on sale in our sale aisle on the site, and we often post coupons to our site's blog (online journal).

There is no single benchmark that is appropriate for all transactions. An effective trader will review their activity against a number of different measures to better understand the impact of trading on overall investment strategy and performance. In addition traders acting for different portfolio managers different funds will need to take account of their particular trading objectives and concerns.

The benchmark emulates an automobile dealership, manufacturing, supply chain management (SCM) and order/inventory system. For additional details see the SPECjAppServer2004 Design Document.

In our initial tests we have seen good scalability with three 4-CPU systems (two systems for the J2EE application server and one system for the database server). SPEC did not explicitly restrict scalability in the benchmark.

For the 100x100 based Fortran version, you need to supply a timing function called SECOND. SECOND is an elapse timer function that will be called from Fortran and is expected to return the running CPU time in seconds. In the program two called to SECOND are made and the difference taken to gather the time.

The matrices are generated using a pseudo-random number generator. The matrices are designed to force partial pivoting to be performed in Gaussian Elimination.

The documentation of ANT 1.5 says, that the source option of the ANT task is not used with custom Doclets. (If you set -source 1.4 you make javadoc aware of the assert statement.) JUnitDoclet does not require this information, but javadoc itself does (not just the Standard Doclet as the ANT folks guessed). Please include -source 1.4 as part of additionalparam.

No, ColdFusion Standard comes with an integrated J2EE server so no external server is needed, and ColdFusion Enterprise comes with a full license of JRun that you may use as your J2EE server. However, if you do have a J2EE server (like Sun ONE, IBM WebSphere, or BEA WebLogic) then you may want to deploy ColdFusion on top of it.

No. Although the tutorial used to rely on the J2EE SDK, we converted it to work on the Sun ONE platform. You'll find it much easier to develop J2EE applications and Web services with the Sun ONE software.

A J2EE licensee has signed a commercial distribution license for J2EE. That means the licensee has the compatibility tests and has made a commitment to compatibility. It does not mean the licensees products are necessarily compatible yet. Look for the J2EE brand which signifies that the specific branded product has passed the Compatibility Test Suite (CTS) and is compatible.