
Martin v. Löwis wrote:
"Brett C." <bac@OCF.Berkeley.EDU> writes:
So, anyone have any ideas? The best one that I can think of is optional type-checking. I am fairly open to ideas, though, in almost any area involving language design.
Did you explicitly mean language *design*?
Design/implementation. Basically something involving how a language either works or is created.
Because there might be areas of research relevant to language implementation, in terms of efficiency, portability, etc.
Here are some suggestions: - memory management: attempt to replace reference counting by "true" garbage collection
Maybe. Kind of happy with the way things work now, though. =)
- threading: attempt to provide free threading efficiently
Wow, that would be a challenge, to say the least. Might be too much for just a masters thesis.
- typing: attempt to provide run-time or static type inference, and see whether this could be used to implement some byte codes more efficiently (although there is probably overlap with the specializing compilers)
I was actually thinking of type-inference since I am planning on learning (or at least starting to learn) Standard ML next month.
- floating point: provide IEEE-794 (or some such) in a portable yet efficient way
You mean like how we have longs? So code up in C our own way of storing 794 independent of the CPU?
- persistency: provide a mechanism to save the interpreter state to disk, with the possibility to restart it later (similar to Smalltalk images)
Hmm. Interesting. Could be the start of continuations.
On language design, I don't have that many suggestions, as I think the language itself should evolve slowly if at all: - deterministic finalization: provide a way to get objects destroyed implicitly at certain points in control flow; a use case would be thread-safety/critical regions
I think you get what you mean by this, but I am not totally sure since I can't come up with a use beyond threads killing themselves properly when the whole program is shutting down.
- attributes: provide syntax to put arbitrary annotations to functions, classes, and class members, similar to .NET attributes. Use that facility to implement static and class methods, synchronized methods, final methods, web methods, transactional methods, etc (yes, there is a proposal, but nobody knows whether it meets all requirements - nobody knows what the requirements are)
Have no clue what this is since I don't know C#. Almost sounds like Michael's def func() [] proposal at the method level. Or just a lot of descriptors. =) Time to do some Googling.
- interfaces (this may go along with optional static typing)
Yeah, but that is Alex's baby. Thanks for the suggestions, Martin. -Brett