ant-user mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Robert Simmons" <deri...@arcor.de>
Subject [OT] Seeking input from the comunity at large.
Date Tue, 11 Nov 2003 23:05:36 GMT
Greetings,

I am embarking on a kind of research project and I would like to know your input
on a couple of questions. I have posted these groups because of the large number
of very different developers in these groups.

Whe goal of the research project is to develop a new programming language from
the ground up completely under the auspices of open source. The goal is to take
on the java and C# community at the same time.

The idea revolves around a couple of thoughts. First of all, as a java, c# and
c++ programmer, I am aware of a very large number of problems that these
languages have. In addition, I find that no one has tried to merge all of the
good traits of these languages into one. You have Sun holding Java (proprietary,
dont fool yourself) and Microsoft holding C# (also proprietary) and doing mortal
combat. However, neither one of them have the resources to throw into a language
to really make it transition to the next century. To accomplish that you need
far more resources than either can muster. In short, you need open source.

I want to draw your opinions on a couple of questions:

1) What is the reason for Java's success? I postulate that the write once, run
anywhere paradigm hasnt really happened. All developers seem to release versions
of java software targeted at specific OS's. There are few that actually let you
dowload a jar and go. I think the motivation was never to be able to run a
single executable anywhere but rather to make it so that converting code between
one OS to another was a trivial matter (or at least as trivial as can be)

2) The byte code paradigm. Is it needed? Do we really need interpreted programs
or is it just a hack to create pseudo OS agnostic constructs. (There are many
other ways to make an OS agnostic)

3) One problem many languages have gotten into is that thier keywords are
similar to their variable names. Java got smacked by this when they created a
new keyword assert() in JDK 1.4. Now they are gunshy about creating another
keyword called foreach. I propose a language to prefix keywords with a symbol to
identify them and facilitate expandability. Could you live with code like the
following?


:namespace org.myorg.example

:protected :class SomeClass {

    /**
     * Compares this object to obj for equality.
     * @param obj The object to compare to.
     * @return The result of the equality check.
     */
    :public boolean equals(any obj) {
        SomeClass target = (SomeClass) obj;
        :if (target.getValue() == :this.getValue()) {
            :return true;
        }
        :return false;
    }

    /**
     * Performs some work.
     * @param obj The object to compare to.
     *
     */
    :public :static :const int processArray(:const any[] &values) :const {
        List<SomeClass> list = :new List<SomeClass>(values);
        :foreach (string value :in list) {
            :assert((value != null); ("Bad Data " + &values));
            int length = value.length();
            :switch (length) {
                :case (0) {
                    // do code
                }
                :case (1) {
                    // do other code
                }
                :default {
                    /*
                     * Shouldn't happen unless user is nuts.
                     */
                }
            }
        }
    }
}

For the java programmers out there, the :namespace directive is similar to
package. The other code should be familiar after you stare at the changed syntax
a minute. This code is from a prototype of the grammar. If you dont like the
symbol I chose (the colon) what other symbol would you feel better with.


Well that should get you all thinking. Thanks for your time and I eagerly await
your answers.

-- Robert Simmons

Mime
  • Unnamed multipart/alternative (inline, None, 0 bytes)
View raw message