This is the kind of assumption, like having zeroed memory by default, that could be built into a language. Indeed, it might be nice to only be allowed to assign a nil pointer explicitly:

However, I keep being really really uncomfortable when a language does things that are going to subvert the instincts of a good c++ or Java programmer.

I miss the Object Pascal with statement, dreadfully so when I first moved to C++.

I'm not sure there's a readable alternative, maybe some of these meet your fancy:

with unless nil gRS.runner.UI: CurrentLogger = LogTo with nil-safe gRS.runner.UI: CurrentLogger = LogTo with guaranteed gRS.runner.UI: CurrentLogger = LogTo safely with gRS.runner.UI: CurrentLogger = LogTo

Safer Code Through Clarity

I will probably blog again on this topic because it's dear to my heart and deserves more detail.

People avoid errors of tired misinterpretation when code is easy to read.

As you can see from the above examples, this means trying things in nit-picking detail.

Of CEDSimply and Overweening Ambition

I came to Christopher Diggins' blog and Heron project because for a few years I've been dissatisfied with existing programming languages and how well they allow me and many others to communicate to a computer and other programmers.

CEDSimply is currently a theoretical project in establishing a clear vision for a language, it may end up as:

a set of idioms for using an existing programming language,
a DSL (Domain-Specific Language) or
as an interpreter and c++ Code Generator.

I have realised it might be a tiny bit ambitious to aim at developing the entire language and environment alone so it is going to have to be an open source project. Maybe I'll at least establish a BDFL-like reputation, rather than getting rich :-)

I've spent a lot of time in the Macintosh world working in the code generation space: writing code generators that target c++ frameworks such as Think Class Library (for Prototyper) and enhancing AppMaker from Bowers Development.

From publishing a Windows code generator and PowerPlant framework portability kit for AppMaker, I've now moved on to acquiring the product (Spec Bowers has retired to run cabins).

AppMaker has a JSP-like template environment for code generation, using its own OO language. This, Python and years of trying to write highly-usable C++ API's (OOFILE) were the seeds of my thinking in CEDSimply, watered with dabblings in Forth and Scheme.

Awful Puns

CEDSimply is pronounced "said simply"

yes it's a kind of pun on Smalltalk

it's also a pun/jibe at another famous old language - you can't say it clearly with a lisp.

CED started out as an acronym for Connecting Events and Data, then it became Contexts, Events and Data

or maybe it now means many other things, some of which start with Community.

Anyway, I think it's a great pun!

package nulltesting; import static java.lang.System.*; public class Test { static class Wrapper { // the thing that has a field that could be null final String wrapped; Wrapper( final String value ) { wrapped = value; } } static abstract class Thunk< T > { // common class used many times T eval( final T defVal ) { try { final T temp = f(); return temp == null ? defVal : temp; } catch ( NullPointerException e ) { return defVal; } } abstract T f(); } static final Wrapper defVal = new Wrapper( "No" ); // default for wrappers that don't exist static String exists( final Wrapper wrapper ) { // a wrapper exists method, other overloaded methods for other wrapper types return new Thunk< String >() { public String f() { return wrapper.wrapped; } }.eval( defVal.wrapped ); } public static void main( final String[] notUsed) { final Wrapper ok = new Wrapper( "Yes" ); final Wrapper null1 = new Wrapper( null ); final Wrapper null2 = null; out.println( "ok exists? " + exists( ok ) ); // prints Yes out.println( "null1 exists? " + exists( null1 ) ); // prints No out.println( "null2 exists? " + exists( null2 ) ); // prints No } }

protected static final void closeDBResource(Object resource) {
if (resource==null)
return;
try {
if (resource instanceof ResultSet) {
((ResultSet) resource).close();
} else if (resource instanceof Statement) {
((Statement) resource).close();
} else if (resource instanceof Connection) {
((Connection) resource).close();
} else {
throw new IllegalArgumentException("Invalid resource class: " + resource.getClass().getName());
}
}
catch (SQLException e) {
staticLog.info( "Exception in closeDBResource(): " + e);
}
}

static boolean String.isEmpty( String s) {
return s == null || s.length() == 0;
}
static boolean String.hasData( String s) {
return s != null && s.length() != 0;
}
static String String.notNull( String s) {
return s == null ? "" : s;
}

static boolean Object.equals( Object o1, Object o2) {
return (o1 == null && o2 == null) || o1.equals(o2);
}

static boolean Collection.isEmpty( Collection c) {
return c == null || c.isEmpty();
}

static List List.notNull( List l) {
// less generic, but most often needed
return l == null ? new ArrayList() : l;
}