A new major version of Nemerle is out there. Nemerle is a high-level statically-typed programming language for the .NET platform. It offers functional, object-oriented and imperative features. It has a simple C#-like syntax and a powerful compiler extensibility capabilities by means of hygienic macros. New release brings custom implicit conversions, interactive shell and many bugfixes.
Nemerle 0.3.0 released
About The Author
Eugenia Loli
Ex-programmer, ex-editor in chief at OSNews.com, now a visual artist/filmmaker.
Follow me on Twitter @EugeniaLoli
These new languages mostly look interesting, though they never made me seriously think about changing my way of coding. There are advantages in languages like Nemerle (or F# or Omega# – or whatever it’s called) but they need you to switch to something new, which you’re not confident of as your old lang, sometimes. Or maybe I’m just sooooo lazy 😉 lol
But they’re very interesting…
I love this ExecuteReaderLoop macro, maybe i should use a few minuttes to look into this.
I’ve been following the development of the Nemerle language since it was first announced, and find many of its ideas to be quite amazing. The way the language is evolving can be thrilling at times, but also a little disturbing. I’m used to languages changing their runtimes, libraries, even adding a datatype on occasion between versions. Nemerle has been changing its syntax, adding whole new concepts and such. It’s like watching Perl 6 development in fast-forward.
I’d love to use this language to implement something, but am a little afraid that I’ll have to do some rewriting for the next version. For instance, at this point I’m not sure what the generics syntax is, just that it’s different that the last time I looked.
The alphas have been great – I’m looking forward to the betas!
It certainly does evolve quickly. The developers are also great at talking to the users (testers). Hopefully I’ll have some time this summer to play around with it more, as well as Boo.
Where are the 4th gen languages ?
We need click and create languages for rad that reduce time for big projects.
Kind of like coldfusion or macromedia.
If a new language brings nothing like development speed to the table then it’s dead for me.
I think a language that changes so fast (see Brian Hawley’s post) is of course not suited for corporate usage.
In my opinion it is mainly for introducing new styles of programming – just like e.g. smalltalk did.
The point is that you will probably find many features of nowadays experimental languages somehow matured in the big languages of the future.
It is all about exploring new concepts (which, by the way, does not mean that you cannot get real work done in these languages).
Thanks for pointing it out. We can assure you that every incompatible syntax change is a pain also for us, but it is always well discussed, have its reasons, etc.
We hope that there will be no or only very minor breaking changes in syntax in future – that is its current state is much more stable than say half year ago. There will be some additions, etc. but existing code should be expected to work in future.
Generics, yap, that was the biggest change since initial release. But now it is 100% sure that we will stick to current
solution
foo (x : list [int]) : Hashtable [int, string] { }
why are so many of these new languages written to be C -like (or C++ like or C# like or Java like- which is kind of C- like anyway)
Surely the way forward is to make languages more human readable, easier to learn and write. Why are languages just being re-hashed (no pun intended) instead of really moving things forward.
and by c-like you mean…”has semicolons as terminators and braces as block delimiters?”
because that’s about the only way i can see the nemerle is “c-like.”
maybe take more than a casual look…
I agree with you. From my point of view, languages like Nemerle are cute but they don’t provide enough innovation to justify a developer to change her/his habit. They probably shine under an academic point of view.
However, there’s something really important about this story, if considered from a general point of view. Before .NET (AFAIK), investing your time into something like Nemerle instead of (say) C++ would have been crazy (unless you did that for fun) because even if language itself could have been good, then you would face lack of libraries / software / examples and millions lines of code most mainstream languages can provide you.
Now that we have .NET, I can think about learning Nemerle (or F# or whatever) without fearing to be left out of mainstream development because I can be sure that I will be able to use libraries written by other people using C#, VB.NET, J# and so on.
That’s amazing, IMO.
The way forward is not to make languages more human readable but to make the underlying concepts more robust.
Let us assume that you could already program in plain english. Programming would still be so hard that you would need professional programmers for all but the most primitive tasks.
It is not the ability to close braces that makes a good programmer but rather the ability to make a concrete product out of the diffuse requirements of the customers.
Sure, natural language programming will have its place, for example as scripting languages (e.g. Applescript). But professional programmers will prefer the concise syntax of programming languages like nemerle.
And if you think that nemerle is c-like or even C#-like, you just don’t know the language.
You are right that the CLR makes it possible to use exotic new languages productively. The CLR seems to have led to a whole group of new programming languages (also on the java vm).
But I think that you underestimate the advantages of the functional programming style that is possible with nemerle.
Functional data structures are inherently thread-safe because of the lack of destructive updates. So a program that uses solely functional data structures could be made implicitly parallel by the compiler.
You also eliminate very large classes of bugs completely.
So functional programming makes it possible to write languages that scale on many processors and have much less bugs. And they are also much shorter than imperative programs.
Nemerle is not a pure functional language, but it offers a bridge from the OO world to the functional world, which is probably more important from a practical POV than pure functional languages such as Haskell or Clean. (even though clean is the best language in existence 🙂
But learning new ways of doing things is my habit
Kamil, I’m glad to hear it! I look forward to seeing how Nemerle develops in the future.
Never going to happen. “Click and create” is never going to be expressive enough to do more than glue pre-built solutions together. Such languages will never be useful for solving real problems.
Look, after two thousand years, we still use an essentially text language to do mathematics. There is a reason for this: our linguistic skills are highly developed, and intertwined with our reasoning skills. Programming is fundementally an exercise in reasoning, and requires the expressive power that only a textual language can provide. That is not to say that there cannot be graphical aids for programming, just as we have graphical aids for mathematics, but they will be just that — aids to help us understand what the program is expressing, not a general mechanism of expressing new concepts.
Don’t get me wrong: it WAS hard to switch language. Now CLR makes it easy to retain your previous code while experimenting new languages. This is clearly good.
Plus, I’m very open to new things. For example, I’m getting very seduced by prevalence concept (for object persistence).
Before writing anything, I took the basic tutorial for Nemerle and I have to say that it has very good features. My only doubt (but it mostly depends on MY OWN habits, as for anyone else) is that large parts of FP code might look convoluted… a bit harder to understand than usual languages, so maybe it could be harder to maintain, at least until you get confidence with language structure. By contrast, as you emphasized, you automagically get many advantages and less error-prone code.
For sure it’s a bit hard to stop thinking the OO way after OO got drums rolling for many many years… 🙂
The OO model of thinking is certainly better to model real world situations.
It is quite easy to explain the basic concepts of OO to a layman. There are objects (like objects in the real world) which have properties etc. You can even explain encapsulation by mentioning that you only need to know the interface of a video recorder to use it and not the internal workings.
So I think that OO will not go away. But if you are programming complex algorithms you will be much more productive using functional programming. And if your program needs to be as secure and bug-free as possible functional programming also has large advantages.
What nemerle does is to keep the interface between components object oriented (this is what people are used to, and from a practical point of view this is the only thing you can currently sell), but lets you develop the inner workings of objects using the functional paradigm if appropriate.
Usually combining different programming paradigms in a language will lead to a horribly complex and ugly language (like C++ :-). But since the functional and object oriented paradigms are related, this does not have to be the case with nemerle.
See this very interesting PDF for a comparison of lambda calculus and an object oriented calculus called opulus:
<http://www.mm.informatik.tu-darmstadt.de/~kuehne/fps/>
>It’s a .NOT – Language and therefore – I won’t touch it. I’m >a Linux professional – so I won’t use languages which are >inferior.
Who’s asking *you*?
I’ll stick to ruby. nemerle hasnt got enough to interest me _yet_.
That is Eiffel.
Sure they got Eiffel.NET but every time I try to implement it either crashes or even corrupts my environment.
Gonna search to see if there is RUBY for .NET, I don’t really like C#