Project Goals

We hope to demonstrate that it is possible to provide in one language all of the following desirable features.

	C	Java	Python	OCaml	Welly
Rapid development	No	No	Yes	Yes	Yes
Safe for large programs	No	Yes	No	Yes	Yes
Easy for beginners	No	Yes	Yes	No	Yes
Resource efficient	Yes	No	No	Yes	Soon
Platform Integration	Yes	No	Yes	Yes	Soon
C-like syntax and types	Yes	Yes	No	No	Yes

In more detail...

Rapid Development

• Welly provides a REPL for learning, for prototyping, for debugging, and for general inspection of the program's internal state.
• Welly avoids or automates all build steps, so as to minimise the time between typing in code and seeing the results.
• Welly encourages code reuse, through metaprogramming.

Safe for Large Programs

• Welly uses static checks to detect errors as early as possible, before the program starts running.
• Welly is designed from the ground up to avoid the errors that are historically most common.
• Welly is a fully specified, write-once-run-anywhere system.

Easy for Beginners

• Welly is a simple language, free of historical or ill-conceived cruft that confuses beginners for no benefit.
• Welly is a non-mathematical language that deals in concrete concepts.
• Welly has a garbage collector, so you can spend less effort on memory management, and more on what you care about.

Resource Efficient

• Welly is a (just-in-time) compiled language, that automatically makes use of both static and dynamic information to optimise the performance-critical parts of the program.
• Welly encourages compact data structures, to minimise the cache footprint of the program.
• Welly exposes low-level decisions to the programmer in cases that cannot be optimised automatically by the compiler.

Platform Integration

• Welly is open-source and vendor-neutral, so there is no political obstacle to integrating Welly with the platform of your choice.
• Welly allows access to all of its internal layers, right down to assembly language, if you need it.
• Welly can produce stand-alone executables.

C-like Syntax and Types

• Welly syntax uses curly braces around code, round brackets around function arguments, and square brackets around lists. It uses the standard arithmetic operators, such as +, /, &, << and ? :. It uses standard control-flow constructs such as if, for, while, switch, break and continue, and try and catch.
• Welly semantics is imperative. Welly keeps the concepts of "statement" and "expression" separate.
• Welly uses standard primitive datatypes, like integers (8-bit, 16-bit, 32-bit and 64-bit), floats (32-bit and 64-bit), references (64-bit pointers), and compact structures and arrays. All the operations behave as you would expect.

Non-goals

To focus on what we're trying to prove, we've sacrificed things that many other projects treat as goals, including:

• Using existing code (other than by porting it);
• Making money, attracting users, or being "successful";
• Expertly fitting a niche role;
• Protecting our jobs or our intellectual property.

Sub-goals

Simplify the tool chain.

Who needs a "compiler" tool? Only the computer should care. Welly includes a JIT compiler that adapts to the behaviour of your program. Code that is only run once is optimised for size and start-up time, whereas the performance-critical inner loops are optimised for speed and memory efficiency.

Who needs a "make" tool? Who needs a preprocessor tool? Such tools are just programming languages, and they're typically not very good. Welly is more than capable of building its own programs.

[TODO: Write more, including the following items.]

• Provide proper structs. Especially, provide arrays of structs, and functions to/from structs.
• Provide proper (tagged) unions. If Java needed enumerations (it did), it also needs unions.
• Don't make any basic mistakes (see later).