🚀 go-pugleaf

SUBJECT
  ad/soft/TheDeveloper - A Java alternative

DESCRIPTION
  The Developer - A New Object-Oriented Language And IDE

BODY

The Developer - A New Object-Oriented Language And
	Interactive Integrated Development Environment

Hi.  We have a technology which we've been sitting on for a number of years
which we believe could be of great benefit to a large number of people.
Since we have not really had the time to productize the technology to
the point where we had really liked it to be before release, we haven't
made the tool available to the general public before now.  However,
recently we have made some effort to fully document the features of the
system and to in general increase its overall utility and robustness.  We
feel it is now to the point where we feel comfortable offering this version
on a preliminary basis for review.

This message is intended primarily to gauge the level of interest in our
language system.  We are actively seeking partners who might be interested
in collaborating with us in the further development of our technology.
So, this is not really an ad so much as a request for feedback.  We are
not interested in making tons of money off of this announcement, we are
simply interested in finding out the level of interest in the world
having access to this tool (we have been using it in-house for some time
now).

We are not at present set up to do justice to full support of this language,
however we feel that recent events, particularly the release of the
Java language system which happens to share a number of properties with our
own, encourages us to make the system available now, so people can decide
for themselves the advantages or disadvantages of the system, and we can get
a sense for what direction to take the technology.

BENEFITS

The Developer represents a complex web of carefully-chosen tradeoffs
between ease-of-use, simplicity, performance, and interactivity.  Our
intention was to create a breakthrough system which allowed developers to
create high-performance, real-time applications with all of the power and
speed of C++, while retaining most of the interactive application
development style and simplicity of a language like Smalltalk.  We
sometimes like to think of our system as analogous to a word processor
for code; it allows the programmer to creatively modify his/her code
while maintaining the correctness of the overall program, even to the
point of allowing radical restructuring of a group of classes.  This
goal is achieved without sacrificing real-time performance through a
series of carefully-chosen techniques.

What sets our design apart from other systems is the collection of
we think clever tradeoffs we have made.  These design decisions have
been carefully chosen to create the best possible balance between the
various factors which go into the typical software development project.
There are, of course, always features we would like to continue to add.

RAPID APPLICATION DEVELOPMENT

Most programming systems require the programmer to sit and wait a lot of
the time.  Wait for the program to compile, wait for it to link, wait to
check for syntax errors.  Our system is designed to make writing code as
easy as using a word processor and checking syntax as quick as running a
spell checker.  The integrated development environment includes a built
in compiler which runs at very high speed.  As a result, the system can
instantly check the syntax of any method.  The power gained by an
integrated compiler and code browser is enormous; you can do all sorts of
things very quickly.  For example, we have for years had the ability to
rapidly look up the definition of a method simply by clicking on its use
in a piece of source code and hitting a key.  Or, for example, instead
of using search and replace when you change the name of a method or
variable, you can just use the integrated compiler to instantly find
and highlight every use of the method or variable which needs to be
changed (actually this is better than search and replace, because it
checks the semantic use of the object to ensure that it is actually
the right method or variable you want to change).

What's more, we feel that it is very important to be able to interactively
modify the application while it is running.  Most existing development
environments force you to wait for a compile and link every time you
want to make even the tiniest change.  This can result in long debugging
cycles, particularly when you are trying to track down a complex bug
which depends on a complex series of events.  Using our system, however,
you can track down bugs rapidly and easily, interactively, while the
program is running.  You can add and remove debugging output which lets
you interactively trace the execution of your program to varying degrees
of detail.  This is a very powerful tool to find bugs which would be
difficult to track down using a traditional debugger, which only allows
you to step through execution one line at a time.  You can modify
methods and even to a limited extent add new variables.

CODE GENERATION

Our system supports a mixture of compiled and interpreted execution (see
below).  This is a unique feature which we have not seen in other
systems.  The built-in interpreter allows the system to achieve run-
time code modification, whereas the ability to compile any method
at will allows the programmer to selectively optimize certain functionality
for speed, without sacrificing code readability.  Unlike other languages
which require the programmer to change languages (i.e., writing
high-speed code in C or C++), we allow the programmer to write all
of his/her code in one language, and choose optimization in an independent
and transparent manner.  As a result, applications can be created
interactively yet will run at full speed, since time-critical methods
can be compiled as needed.

PERFORMANCE

One area we did not want to sacrifice was performance; overall performance
had to be quite consistent and high-speed, as we have been using the system
for everything from AI research to commercial game development.  Code
executes at C or C++ speeds when needed.  For performance consistency we
have adopted the C++ approach of manual garbage collection in cleanup
methods analogous to destructors.  To aid in finding leaks, we have built
tools which greatly aid in the partially automatic detection and
correction of the bugs which cause memory leaks.  We have found in
practice that programs written using our system can run at 90%-95% the
speed of an equivalent C++ program even when a large number of methods
remain interpreted.  And, of course, it is always possible to achieve
100% C++ speeds, if that is crucial, by using the compiled code generator
for every method.

PORTABILITY

The language and class libraries included with the system are designed
for portability.  We have created a portable user-interface library which
has a very straightforward architecture and has been successfully
implemented over both Windows 95/NT and the Macintosh OS (although at
present we are only actively using the Win32 version of the library).
The library is, again, rather similar to AWT in Java, however we
created it independently of AWT several years ago.

To aid in portability, when you want to compile a method the system
will automatically generate ANSI C.  Again, this saves the programmer
having to write C or C++ methods manually to speed up program execution.
Since the language generated is C, the system can be used to develop
code for any operating system.  Even the interpreter is written inside
the system, and thus is implemented as portable C functions.  At
present, we are using the system actively only to develop code for
Win32, although we have in the past used it to develop Macintosh
applications, and the most recent version of the system runs only
under Windows 95 or NT (although, again, we have in the past run the
system on the Macintosh).  You can of course use the system to cross-
develop applications for other operating systems quite easily.  Porting
the system to Unix should be relatively straightforward, however, again,
we have not had use for that and thus far have not done it.

We also have a C++ code generation mode, which allows the system to
create an entirely compiled C++ program which is very readable.  The
purpose of this is to export code to clients who want human-readable
and human-modifiable code in a standard language (e.g., C++).  The
resulting code can be compiled with a standard C++ compiler and run
at full C++ speeds.  However, if modifications are made to the generated
C++ code, to back-integrate them into the Developer source requires
manually reading the changes using a diff tool and integrating them
in (this is a trivial task in general, however.)

LANGUAGE DESIGN

The language is a sort of simplified version of C++, with a number of
features taken out and several features added.  In this sense it shares
a design sensibility with Java (the chief difference being that our
system was designed primarily for stand-alone application development
and we did not choose to use garbage collection).  We have eliminated
a number of confusing or complex 'features' of C++, and instead
went for a more Smalltalk-like level of simplicity and economy of
design.

The language currently supports single-inheritance and the use of
protocols (a design choice we made a long time ago, before we had even
heard of Java).  In addition, we support C++-style early and inline
binding, for speed.  We have eliminated a number of "ugly" syntactic
elements of C++ and streamlined the overall look of the language.

The compiler automatically checks for use of uninitialized variables, even
pointer variables, and will enforce the initialization of new objects.
However, you have full control over how and when objects are initialized,
and if needed you can defer initialization until later (memory allocation
and object initialization/cleanup are normally coupled, but can be
decoupled if desired by the programmer).  This allows the programmer to
achieve higher performance by more manually managing memory if needed.

Although the language allows pointers, unlike Java, the syntax in
general discourages their use.  We allow the programmer to define
methods even for primitive classes (for example, even integers can
have methods defined for them).  As a result, the need for ugly
C-style pointer manipulation code is greatly reduced.

AVAILABILITY

The language is available now, however we would like to gather some feedback
as to the level of interest on the Net in our system before we decide
on the best method of distribution.  Please email mitsu@openmind.com
or doug@openmind.com if you would like more information about the system,
if you are interested in obtaining an evaluation copy, or if you would
like to talk with us about working with us to develop the code.  We
have documentation available in Word, RTF, or PostScript format.  If there
is sufficient interest we will determine a scheme for releasing the system
and a support structure, as well as posting detailed information about
the system to the Web.

We are very interested in companies that would like to work with us to
further develop the technology.  We are also considering applying the
technology to creating a Java IDE which has similar design characteristics
to our own IDE.  Companies interested in this project should also contact
us, since we do not know whether it is worth spending the time on that
project as well, but it would be relatively trivial for us to create
such an environment using our development tool.

The great thing about this tool, really, is that programming becomes fun
and easy again.  It's the way you want things to be, really; instead of
spending weeks working on something that should take days, you spend days
working on something that should take days.  (We're working on the
technology which lets you take minutes to do something that should take
days, but haven't quite reached that level yet :).  It's the microwave
oven of development environments.  Not a silver bullet, but a bullet of
some kind at least.

Please, email us or phone us with your comments and thoughts

-------------------------------

Mitsuharu (Mitsu) Hadeishi
General Partner
Open Mind Research
mitsu@openmind.com

William (Doug) Cutrell
General Partner
Open Mind Research
doug@openmind.com

Phone:  (310) 327-7820  (leave a message and someone will be paged to
	return your call as soon as possible)

--
To submit, mail postings to java@relog.ch (please read the guidelines posted)