[ge-talk] (no subject)

[Waldemar Kornewald]

Hi,

On 1/11/07, Miguel Mayol i Tur <mitcoes at gmail.com> wrote:
> Perhaps a Gentoo like install would be a good idea, then compiling
> sources for each instalation can give a good number of applications,
> and a faster use of them. I do not know when will D replace C, but it
> would be great to be the first D programing language based OS.

Haiku will definitely never become an OS where users have to compile
applications. This is much too complicated and time-consuming. There
is no point in placing this burden on our users. We plan to get rid of
*installation* as a whole. You should just run the app and not waste
any thought on installing it.


About alternative programming languages:
This will be a very tough decision. Personally, I'd like to go much
further than a simple C++ improvement. As the next step, I'd like to
have
* a powerful type annotation system
* type inferencing
* a very simple syntax without any redundancies (e.g.: no annoying semicolons)
* a strong emphasize on multi-threading
* (optional?) garbage collection
* as much productivity as possible
* flexible syntax and more powerful macros
* maybe well-suited for distributed applications (the Internet is growing)
* good component system
* better object system (e.g.: based on traits instead of interfaces or
class based multiple inheritance)
* maybe integrated testing framework
We could still use C for highly performance-critical code. I don't
know about the others, though. At least, I find D much too overloaded.
My current favorite (unfinished) language is Fortress (developed by
Sun Inc.: http://fortress.sunsource.net/), but it's pretty
complicated.

Then, I think that it's finally time for a language that is well
integrated with an IDE:
* on-the-fly compiler error detection (like when you make spelling
mistakes in MS Word)
* you operate on syntax tree instead of character based source (you
don't need to care about source code layout and coding guidelines,
anymore)
* integrated modeling tools (UML, finite state machine, etc.)
* integration with documentation tools (but not enforcing to have docs
in the source code editor like with Doxygen; take a look at a Lisp
Machine to get an idea for a possible solution)
* integrated distributed SCM
* good tools for code refactoring
* interactive code testing (like with dynamic programming languages)
* tools for more elaborate correctness analysis (and source
annotations beyond type safety)
* ...
We could also get inspiration from Smalltalk IDEs, Strongtalk, and
IntelliJ IDEA.

Probably I'm asking for too much, but I think that developers should
fully concentrate on application logic instead of syntax and language
quirks. We should be able to use the tools that are best suited for
the task at hand and not be forced into a limited text editor window.
We're still in the stone age of software development.

Bye,
Waldemar Kornewald