Slashdot Mirror

Lisp and Dylan use something called conditions. The signal() function (equiv. to throw) calls condition handlers; the stack is not unwound. You get a perfectly understandable stack trace that looks like normal function calls.

Even better, the code can retry operations, since the stack is not unwound so the context is preserved.

Here is a brief overview: http://opendylan.org/documentation/intro-dylan/conditions.html

Well, we are still trying to make it successful. Come on by and help. :)

Don't forget the open source Lazarus

Or actually, maybe do forget it. Object Pascal and C++ have virtually identical capabilities with slightly different syntax. But C++ is so widely used that there are always more available libraries, IDEs and sources of support. And I say this as someone who used to program in Pascal myself. If you want to go for an obscure language, at least make it something interesting like Dylan...

I'm interested in really learning functional programming. Is clojure a real funcional language? What are some you would recommend?

Depends on if you want to sink or swim. If you want a relatively easy learning curve, I suggest Dylan. I've heard that Scala is also approachable.

Lisp, Scheme, Haskell, Ocaml, and Erlang will make your head explode. But if you survive, you'll eventually grow a replacement head.

Dylan had a very powerful macro system.

http://www.opendylan.org/

with all the advantages of a late-bound language.

I'm fairly well acquainted with gcj, and in fact it compiles a fair amount of standard Java without problems. There is also the Jet compiler which is ahead-of-time and fully compliant.

So, it's certainly possible to do a good ahead-of-time Java compiler. Whether Java is desirable as the "next big general purpose language" is another question, of course.

D is attractive if viewed as a superior C++.

Maybe it makes sense for some resource-constrained settings like embedded systems, but there i've used Java straight up, satisfactorily. Granted, these are not life-critical systems I've built, but rather than compiling Java - or trying to - the better answer is to use a more appropriate language in those circumstances.

There is a very big sweet spot for a language that's approachable, powerful, productive and efficient. With the advent of performance/Watt thinking, it makes no sense to get efficient processors and then throw away that efficiency on slow software. Of course, there are also applications where raw speed is very important; real time apps, simulations, games and scientific programs.

C++ is widely viewed as less than desirable. It's good to have better, more modern alternatives going forward. Another interesting looking language is Dylan, though quite different in many ways.

You want to know the latest trends for Java-based web development? Fewer and fewer people are going to be doing Java-based web development in the future.

Fuck trends. They're wrong. Every day the industry continues to stay with its current ridiculous technologies when vastly superior ones were invented decades ago infuriates me further. If it doesn't infuriate you, you're not paying close enough attention.

My advice: read Lambda the Ultimate and Steve Yegge's blog. Endeavor to learn what the lambda calculus and referential transparency are. If you are sincerely interested in bettering yourself as a programmer and don't go find out who Alonzo Church was then so help me God I will kick you in the balls. Learn about SML and type inference. Learn about Haskell and monads. Learn about process calculi and Erlang. Learn about Lisp and code generation and domain-specific languages. Learn about Scheme and lexical closures and continuations. Learn about Smalltalk and what OO was really supposed to be. Learn about type theory and formalism and the Curry-Howard correspondence. Learn about Forth and Joy and how you can have a powerful, expressive language without even so much as a grammar. Learn about Intercal and Befunge and just how badly your choice of programming language can torture you. Learn about UML and Ruby on Rails and Seaside and agile programming and Java generics and Python generators. Learn about aspect-oriented programming, context-oriented programming and concept programming. Learn about multi-paradigm languages like OCaml or Oz. Learn about weird Lisp dialects with syntax like Rebol or Dylan.

Realize that library design is language design. Realize that asynchronous programming with callbacks and explicit state in a world where lightweight coroutines were around in the days of fucking Simula in the 60s for Christ's sake is cruel and unusual torture. (Sorry, pet programming construct.) Realize that the programming language research community, while considering systems programming a solved problem and generally not interested in talking about human factors, is doing some genuinely promising work. Did you know that there are conc

Dylan (invented by Apple for the "Newton") was open-sourced last year.
Well, the popular "Harlequin / Functional Objects"-Implementation in fact.
Comes with a nice IDE with object browser etc. and produces fast, _native_ code!
http://www.opendylan.org/

At one point, not that long ago, I agreed 100% with this thinking. I was still drinking the "Java will have C performance" Koolaid from Sun.

I'm now of the opinion that the "managed" languages are a short-term abberation, unless they adopt an ANDF type "freeze" approach. That is where the bytecodes are pre-compiled once into machine code, just like a traditional compiler. I'm also not happy with where Java is at as a language after 10 years of evolution. No operator overloading, feh.

Lately I've been looking at D and Dylan for some projects. Both are quite advanced compared to Java, just as portable, and from what I've seen so far both outperform it in many areas. Game and HPC programmers could really use a better language than FORTRAN/C/C++, and Java will never be it, IMO. D seems the more pragmatic of the two, while Dylan looks "better" from a pure language perspective.

If the new processor performance metric (as touted by Intel) is "performance per watt", someone should take a hard look at Java and .Net performance compared with the top compiled languages. Dylan or D would work fine as "server side" web development languages.

There have been historical examples of languages that hit large sweet spots of "general use". Fortran, C, Lisp, Pascal, Java, C#...all of these are usable for probably 90% of programming tasks. There has been a break from "true" general purpose languages with those that require GC, they aren't suitable for system development as delivered. (I do think there's a lot of interesting stuff to be done on the hardware end to make GC and memory systems in general work better.) Back to my original point, I think it would be unbelievably beneficial to the computer science world if there was a single dominant language for most general-purpose programming, to include system and embedded programming.

How much money and time would be saved if most programmers could have a productive career only learning and using one language? How good would the compilers be if 90% of compiler companies focussed on improving and optimizing one language? How good would programmers be if they focussed on mainly one language for their entire careers? Java is trying to fill this niche, but I don't think it's a great fit, read on to find out why.

I find it puzzling that so much focus is currently on VM oriented languages. With the focus on the hardware end of things on "performance per Watt", one should realize that software is an extremely important part of the performance equation. I think the days of massive, gratuitous abstraction for the sake of abstraction may be drawing to a close. I also think that VM based languages had better "walk the walk" of compiled language performance, or they'll become yesterdays technology (p-System Pascal all over again). Those who don't study history...

All that said, for me if there is to be a single dominant language, it must be:

• Performant
• Safe
• Portable
• Extensible
• Interoperable
• All-level
• Available

I'll take these on one by one.

"Performant" means "performs as close as possible to the theoretical maximum". A good starting goal would be 90% the performance of hand-tuned assembler.

"Safe" means "it requires effort to blow my leg off". (Something like Java's security model might be added as a layer if necessary, but wouldn't be part of the base language due to performance concerns.)

"Portable" means the usual thing - programs will compile on multiple architectures and operating systems, and produce similar results.

"Extensible" means the language can be extended in meaningful ways without a new compiler. Lisp, Scheme, and Dylan are all examples of languages that provide a good deal of this type of functionality.

"Interoperable" means that the language can efficiently interoperate with legacy and other code, e.g. an efficient C calling interface.

"All-level" means that, ideally, the language should naturally lend itself to systems running the gamut from small, possibly hard realtime, embedded systems, to the largest distributed systems. It should well address all problem domains from numerics to string manipulation to parallel processing. Ideally, it should provide a subset of some kind that works well as an interpreted scripting language, so that once again the cognitive overload of having to learn and remember many computer languages is reduced.

"Available" means that not only must it exist ;-) it must be obtainable at low or no cost. Many very good languages *cough* Smalltalk *cough* have died on the vine since few wanted to spend the money to play with them.

I've been looking for a reasonable fit to these criteria for a long time. The best thing I've found so far is Dylan. It's not perfect, but it is quite good. It even fu

It's been done. It's called Dylan. It's got much of the power of Lisp, much of the speed of C++, and has a conventional syntax. Apple was pushing it for awhile in the early 1990s. Unfortunately, it never really caught on. The Lisp users didn't like the new syntax, and the project's distancing of itself from Lisp, while the mainstream didn't like it because it was created by a bunch of Lisp gurus. The Apple Dylan implementation suffered from being too memory hungry (like most OOP languages) to fit properly in a Newton, and lost out to a competing C implementation of Newton OS. Ultimately, the language was killed (within the company) when Apple closed its Cambridge Development Lab. Today, there are two existing Dylan implementations maintained by the Gwydion Project. The first, Gwydion Dylan, is derived from CMU's Dylan Compiler while the second, Open Dylan, is derived from Harlequin/Functional Objects's compiler.

http://www.opendylan.org/
http://www.livelogix.net/logix/index.html

You're both wrong. Once you realize your shiny new languages are running your programs at the speed of molasses flowing in the Antarctic winter, you'll want a similarly powerful language that's in the same runtime efficiency domain as C/C++.

Try Dylan.

From what I've seen and heard of it (I've not yet used it) I'd tend to agree. I can't understand why so many programmers stick with C++. It's just not a very good language. I'll never understand why it's not possible to even enable bounds checking in STL arrays...

For those willing to look at something a little less C-like, Dylan is quite nice also. There are two high-quality OSS compilers.

I think we're soon going to see a resurgence in "traditional" compiler technology. No sense throwing away cycles for no particular reason.

Perhaps. It isn't clear to me why one would necessarily want to write a "traditional" application (i.e. desktop style application) in a "managed" language. I've been a big Java fan, mainly from the standpoint of someone who came from C++ and could see that Java was much more productive. I even wanted to write high-performance code (and games) in Java. However, the numbers have never really been in Java's favor. Look at the benchmarks at the Great Computer Language Shootout. They're microbenchmarks, where Java should do quite well if it can really stand up to "traditional" languages in efficiency. The short story is, it doesn't. Further, I don't see the JVM/JIT ever catching up with a highly optimizing ahead-of-time compiler, especially in terms of memory efficiency.

In short, I'm planning on using Java for web-oriented programming, but for 'real' desktop apps it'll either be D or Dylan for me. Both are far more expressive, just as safe, just as productive (if not moreso) and both are significantly faster. Oh, one final point...both are available as FOSS.

C/C++ will only be used where bit-banging stuff is needed AND NO ONE will care about except a few grumpy old man...

Both will be around for a *long* time due to legacy code, but I agree for new development a more modern language is desirable. D and Dylan both fit the bill...Java really doesn't hit the same target. Also, both languages have language constructs like operator overloading that're more suitable for HPC/simulation/game programming, and feature very performant C calling interfaces.

Were they "popular" at some point in the past? o.O

I think Dylan has a shot at significant popularity, now that high quality open source compilers exist. It has all the flexibility, expressiveness and power of CL/Scheme, the safety and portability of Java, and the efficiency of C++.

So, get out there and use it! :-)

It is perhaps ironic that the Dylan Language Wiki is written in PHP, but that is being rectified.