Offtopic, but...

Quote: Original post by Mushu
Beyond those two statements, this humble hobbiest can't help much [wink]

"Hobbiest" is not a word.

Carry on.

I'm curious about the use of OCaml in AI circles, but I haven't been curious enough to actually run it down. The biggest difference between the ML family of languages and Lisp generally is the concern for strong typing. Some people wag that ML is dead in academia because worrying about types is usually orthogonal to one's research goals, and thus just creates gratuitous work. But I Am Not An Academic, so don't quote me.

I think Lisp had a lot of high level features earlier than most, like garbage collection for instance. A lot of these various features have trickled their way into other languages now, though. i.e. It's not the late 80's anymore. Lisp may still have some compelling advantages but so do other languages now.

I think we need to avoid the tendency to freeze our perceptions of a language or technology in a previous decade. Reminds me of how people would always cream about Bresenham line drawing algorithms in 3D graphics. Well, that's not exciting in an era that can quickly do divides for you. Nowadays we don't like pipeline stalls for if..then branches. Things march on, and what once seemed like a big special deal becomes more commonplace.

Quote: Original post by vanevery0
I think Lisp had a lot of high level features earlier than most, like garbage collection for instance. A lot of these various features have trickled their way into other languages now, though. i.e. It's not the late 80's anymore. Lisp may still have some compelling advantages but so do other languages now.

What Made Lisp Different.

Quote: Original post by Anonymous Poster
Lua seems to be used for no better reason then it is open source.

Lua is great! It's designed to be an embedded scripting language (fast, small) and it is a really cool language. Lua tables rock, and it has dynamical typing, first order functions, closures, coroutines, garbage collecting, multiple return values, varargs for functions.

Quote: Original post by vanevery0
The biggest difference between the ML family of languages and Lisp generally is the concern for strong typing. Some people wag that ML is dead in academia because worrying about types is usually orthogonal to one's research goals, and thus just creates gratuitous work.

It's "dynamical typing" vs. "statical typing". C&co are statically typed, ML are statically typed with inferred types and Lisp (or Lua) are dynamically typed (although in Lisp you can add type declarations if you want).

I wouldn't call ML dead because it has statical types - even Java isn't dead, and the way ML inferres types (which I never fully understood) retains advantages from both worlds.

Quote: Lisp may still have some compelling advantages but so do other languages now.

Yeah, but their syntax is so very ugly.

Quote: Original post by Fruny
I'm doing AI-related work. I'm using Python and C++. I know that some AI researchers say Lisp has actually held back AI research.

Same here. Python, C++ and Java...

Quote: Original post by vanevery0
[...]I think Lisp had a lot of high level features earlier than most, like garbage collection for instance. A lot of these various features have trickled their way into other languages now, though. i.e. It's not the late 80's anymore. Lisp may still have some compelling advantages but so do other languages now.[...]

If you mean 'maybe 50%' when you say 'A lot', you're being optimistic. Common Lisp has TONS of features not present in other languages, like the powerful macro system and the whole data-is-code-is-data idea. What seems to be happening to me is "hey that feature from lisp is cool, but it depends on (syntax, macros, some other lisp feature they don't want to implement) so we should include feature X and call it the same thing while only providing 1% of the feature that Lisp does"

A good example is the lambda in many languages, where, sure you can have unnamed functions, and if you're lucky you might even get closures, but you don't get the ability to arbitrarily manipulate functions to simplify a great many tasks.

Of course, just about every new language has features Lisp lacks, like socket and threading support etc, and some Common Lisp compilers provide such features through nonstandard extensions, but that makes portability a problem. This could be EASILY fixed with a new Lisp standard, but nobody really seems to care enough to make one.

Quote: Original post by Diodor

Quote: Lisp may still have some compelling advantages but so do other languages now.

[...]Yeah, but their syntax is so very ugly.

Please don't be serious. Even if it was a reason for you staying away, surely you wouldn't dare say such things after that argument has been done infinite times too already.

Quote: Original post by Extrarius
Of course, just about every new language has features Lisp lacks, like socket and threading support etc, and some Common Lisp compilers provide such features through nonstandard extensions, but that makes portability a problem.

With portability do you mean just portability between different Lisp compilers or portability between different platforms, using the same compiler?

Quote: Please don't be serious.

Sorry, I was being entirely not serious, hence the smiley.

Quote: Original post by Diodor
[...]Sorry, I was being entirely not serious, hence the smiley.

Sorry, I missed that =-/

Quote: With portability do you mean just portability between different Lisp compilers or portability between different platforms, using the same compiler?[...]

All the info I've seen says that porting between compilers is difficult but fairly isolated, so it'd be like porting a C++ Win32 OpenGL program to Linux, where the chages are localized(setting up windows, getting input, and many other things that probably each have their own class and thus own files).

The situation seems to be much better for porting across platforms using the same compiler (with very minor changes required unless you use one of the obscure{as all lisp libraries are} Lisp Libraries made for your compiler that automagically changes for you) but really I'd expect it to be that way considing that the really really expensive Lisp compilers are the ones that work on 50 different platforms (all the good free ones that I know of only work for Linux, which is still a variety of systems I guess).