| Data Store Entry |
Created | Actions |
|
The Baby Name Wizard's NameVoyager
|
2/22/2005 7:30 PM
nick
|
Detail View
New Window
Move/Edit
Full Text
|
|
Groovy - Home:
Groovy is a new agile
dynamic language for the JVM combining lots of great features from
languages like Python, Ruby and Smalltalk and making them available to
the Java developers using a Java-like syntax.
Groovy
is designed to help you get things done on the Java platform in a
quicker, more concise and fun way - bringing the power of Python and
Ruby inside the Java platform.
Groovy
can be used as an alternative compiler to javac to generate standard
Java bytecode to be used by any Java project or it can be used
dynamically as an alternative language such as for scripting Java
objects, templating or writing unit test cases.
Bunny Comments:
rnorris: Groovy makes me a little nervous just because it's really hard to design a programming language.
rnorris: Why would you choose this instead of something like Jython?
rnorris: (that exact question is probably answered on the grooby website somewhere)
lvaughn: http://groovy.codehaus.org/faq.html
rnorris: yeah yeah
|
8/31/2004 2:01 PM
nick
(Modified 8/31/2004 4:02 PM)
|
Detail View
New Window
Move/Edit
|
|
Java 2 Platform, Standard Edition (J2SE Platform), version 1.4.2:
AggressiveHeap - Server Performance Option
The -XX:+AggresiveHeap option inspects the machine resources (size of memory
and number of processors) and attempts to set various parameters to be optimal
for long-running, memory allocation-intensive jobs. It was originally intended
for machines with large amounts of memory and a large number of CPUs, but in the
J2SE platform, version 1.4.1 and later it has shown itself to be useful even on
four processor machines. The physical memory on the machines must be at least
256MB before AggresiveHeap can be used. The size of the initial heap is
calculated based on the size of the physical memory and attempts to make maximal
use of the physical memory for the heap (i.e., the algorithm attempts to use
half of available memory, or all of possible memory less 160mb, whatever is the
lesser of the two).
There are several optimizations and changes in parameter values with
AggressiveHeap in J2SE platform version 1.4.2 that were added in an effort to
make the option more useful for general server use. AggressiveHeap is
recommended for server applications requiring high performance and scalability
and can greatly ease performance tuning efforts. With Sun's emphasis on low-cost
enterprise computing, we renewed our commitment to performance on Sun's latest
offerings. Illustration 1 shows the performance gains as measured on
SPECjbb?2000 while using AggressiveHeap on J2SE platform version 1.4.1 and J2SE
version 1.4.2. Although SPARC was already highly optimized in J2SE version 1.4.1
with AggressiveHeap, we made further improvements of nearly 20% in J2SE version
1.4.2.
Illustration 1: J2SE platform version
1.4.2 Performance as shown with SPECjbb2000
|
7/31/2003 1:31 PM
lvaughn
|
Detail View
New Window
Move/Edit
Full Text
|
|
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
public class BootstrapRunner {
/**
* Assuming BoostrapRunner.class is in this directory and all your other classes are in
* jarfiles or directories under ./lib, you launch your app as shown below.
*
* java -classpath . BootstrapRunner my.MainClass ./lib
*
* You can put everything in lib if BootstrapRunner is the only classfile ... otherwise
* the other classes will get loaded by the system classloader, which could cause problems
* because classes in the system classloader callstack can't see stuff in the jarfiles.
*/
public static void main(String[] args) {
try {
PatchClassLoader pcl = new PatchClassLoader(new File(args[1]), BootstrapRunner.class.getClassLoader());
Class cla = pcl.loadClass(args[0]);
Method main = cla.getMethod("main", new Class[] { String[].class });
main.invoke(null, new Object[] { args } );
} catch (Throwable t) {
t.printStackTrace();
}
}
}
class PatchClassLoader extends URLClassLoader {
public PatchClassLoader(File patchDir, ClassLoader parent) {
super(expand(patchDir), parent);
}
private static URL[] expand(File patchDir) {
try {
File[] files = patchDir.getCanonicalFile().listFiles();
if (files != null) {
URL[] urls = new URL[files.length];
for (int i = 0; i < files.length; i++)
urls[i] = files[i].toURL();
return urls;
} else {
return new URL[] {};
}
} catch (IOException ioe) {
throw new Error("Never happens, heh heh.");
}
}
}
|
4/11/2003 5:17 PM
rob
(Modified 4/11/2003 7:14 PM)
|
Detail View
New Window
Move/Edit
|
|
Excelsior Home Page:
This is a native compiler for Java that seems to be like gcj but it has the potential to not totally suck. It can compile a Java app into a double-clickable .exe with no external dependencies. Kind of cool. - rob
nick(4/4/03 9:00 PM CST): Have you tried it, and does it live up to its claims?
|
4/4/2003 1:41 PM
rob
(Modified 4/4/2003 10:00 PM)
|
Detail View
New Window
Move/Edit
|
|
Java Web Services Developer Pack 1.1:
The Java Web Services Developer Pack (Java WSDP) has evolved into an integrated
toolkit for developing, building, testing, and deploying Web Services, as well
as Web and XML-based applications.
Ok is it just me, or is XML totally out of control? I mean, the Java Web Services Tutorial is 928 pages long! - rob
|
4/4/2003 1:16 PM
rob
|
Detail View
New Window
Move/Edit
|
|
Finally Learn Javadoc:
rob_c_norris: i finally sat down and learned how to use javadoc correctly
rob_c_norris: and it's really very good
nicktornow: I believe you
nicktornow: is there much to read?
nicktornow: I never really learned the details
nicktornow: but the little I know is all good it seems
rob_c_norris: reference page is http://java.sun.com/j2se/1.4/docs/tooldocs/windows/javadoc.html
rob_c_norris: tutorial is http://java.sun.com/j2se/javadoc/writingdoccomments/index.html
nicktornow: shit the scroll bar thumb is small
rob_c_norris: and (this is best) http://java.sun.com/j2se/javadoc/writingapispecs/index.html
nicktornow: ok, I will try to read it
rob_c_norris: the last one explains what kind of stuff you should think about when writing an API spec
rob_c_norris: in javadoc
rob_c_norris: it's just nice when you discover that people have actually given anything a little bit of thought
|
3/28/2003 11:46 AM
rob
|
Detail View
New Window
Move/Edit
|
Opening Microsoft File Formats to Java [Jan. 22, 2003]:
POI (Poor Obfuscation Implementation, the name that seemed to describe the
format best) is a high-quality application that can read and write Excel and
other MS-format files right from inside of your Java application.
|
1/24/2003 9:43 PM
nick
|
Detail View
New Window
Move/Edit
|
New Multi-language Development Environment:
Support for Mixed Language Development
The Sun ONE Studio 7 IDE enables developers to leverage existing resources
into services on demand. Rather than rewriting existing C++ applications to
create Web services, the IDE uses the Native Connector Tool technology expose
C++ code as Java classes and automatically generate the Java Native Interface
(JNI) bindings. Existing applications don't need to be rewritten in the Java
language because developers are enabled to "wrapper" C++ code and data and
publish it as a Web service. This functionality helps to bridge the gap between
an existing code base and Web services--thus preserving past IT investments.
ntornow(1/6/03 1:19 PM CST): Evidence that Sun may start more seriously considering the problems of Java performance.
|
1/6/2003 3:18 PM
nick
(Modified 1/6/2003 3:19 PM)
|
Detail View
New Window
Move/Edit
|
util.concurrent Release 1.3.1.:
This package provides standardized, efficient versions of utility classes
commonly encountered in concurrent Java programming. This code consists of
implementations of ideas that have been around for ages, and is merely intended
to save you the trouble of coding them.
|
12/11/2002 4:13 PM
nick
|
Detail View
New Window
Move/Edit
|
Summary of "JavaSpaces Specification":
JavaSpaces vs Databases
not relational or object database
not to be used primarily as data repository
only understand entries by type and serialized fields
no general queries, only "exact match" or "don't care" (wildcards)
does not provide nearly-transparent persistent/transient layer
works only on copies of entries
used for simple persistent storage; situated somewhere between a file system
and a database
Spec is here
|
11/21/2002 6:32 PM
nick
(Modified 11/21/2002 7:21 PM)
|
Detail View
New Window
Move/Edit
|
From http://xml.apache.org/fop/index.html:
FOP (Formatting Objects Processor) is the world's first print
formatter driven by XSL formatting objects and the world's first output
independent formatter. It is a Java application that reads a formatting object
tree and then renders the resulting pages to a specified output. Output formats currently supported are PDF, PCL, PS,
SVG, XML (area tree representation), Print, AWT, MIF and TXT. The primary output
target is PDF.
|
10/19/2002 11:59 AM
nick
|
Detail View
New Window
Move/Edit
|
From http://www.javaworld.com/javaworld/jw-09-2002/jw-0927-xmlglossary.html?:
XML glossary: XML acronyms for Java developers
|
10/11/2002 4:20 PM
nick
(Modified 10/11/2002 6:05 PM)
|
Detail View
New Window
Move/Edit
|
From http://www.ddj.com/documents/s=7532/ddj0209o/0209o.htm:
The biggest bone that the Java people have to pick with C# is not that the
columnist Robert Cringely thinks it will run faster than Java, nor that it comes
from Microsoft, nor even that it is a Java knock off. The real problem, about
which very little is said, is that C# is a fixed-up knock off of the Java
language: better scalars, proper properties, sensible facilities for event
handling, a thought-out syntax for method overrides. Javans have been confronted
by their own mortality.
|
9/27/2002 3:15 AM
nick
|
Detail View
New Window
Move/Edit
|
From http://www.onjava.com/pub/a/onjava/excerpt/JavaRMI_10/index.html?page=6:
The following two-part strategy is often quite nice:
Make all your classes implement Serializable.
After that, make some of them, the ones you send often and for which
serialization is dramatically inefficient, implement
Externalizableinstead.
This gets you most of the convenience of serialization and lets you use
Externalizableto optimize when appropriate.
|
9/17/2002 7:40 PM
nick
(Modified 9/18/2002 12:35 PM)
|
Detail View
New Window
Move/Edit
|
From http://java.sun.com/docs/books/jls/second_edition/html/conversions.doc.html#189955:
Java can lose precision without compile-time or run-time error:
Despite the fact that loss of precision may occur, widening conversions among primitive types never result in a run-time
exception (?11).
Here is an example of a widening conversion that loses precision:
class Test {
public static void main(String[] args) {
int big = 1234567890;
float approx = big;
System.out.println(big - (int)approx);
}
}
which prints:
-46
thus indicating that information was lost during the conversion from type int to type float because values of type float are
not precise to nine significant digits.
|
9/16/2002 12:17 AM
jcohen
|
Detail View
New Window
Move/Edit
|
From http://java.sun.com/docs/books/jls/index.html:
THE JAVA LANGUAGE SPECIFICATION
|
9/13/2002 5:46 PM
nick
(Modified 9/13/2002 7:58 PM)
|
Detail View
New Window
Move/Edit
|
Running this program yields a runtime exception.
Jason, this is another case where your advanced static checking could find the problem at compile time. Though you'd want to have a
nice detailed error message saying exactly what is wrong.
From Rob:
import java.io.PrintStream;
public class Test {
public Test() {
final PrintStream out = System.out;
new Foo() {
void bar() {
out.println("hi");
}
};
}
public static void main(String[] args) {
new Test();
}
}
abstract class Foo {
Foo() {
bar();
}
abstract void bar();
}
|
9/5/2002 4:01 PM
nick
|
Detail View
New Window
Move/Edit
|
From http://www.jboss.org/:
JBoss is an Open Source, standards-compliant, application server implemented in
100% Pure Java and distributed for free. With 150,000+ downloads per month,
JBoss is THE most downloaded web-app server in the world based on the J2EE
specification.
|
8/23/2002 1:59 AM
nick
|
Detail View
New Window
Move/Edit
|
From http://gcc.gnu.org/java/:
GCJ is a portable, optimizing, ahead-of-time compiler for the Java Programming
Language. It can compile:
Java source code directly to native machine code,
Java source code to Java bytecode (class files),
and Java bytecode to native machine code. Compiled applications
are linked with the GCJ runtime, libgcj, which provides the core
class libraries, a garbage collector, and a bytecode interpreter.
libgcj can dynamically load and interpret class files, resulting in
mixed compiled/interpreted applications.
|
8/18/2002 6:07 PM
nick
|
Detail View
New Window
Move/Edit
|
View Store: java