Slashdot Mirror

The unsupervised or weakly supervised achivements are new.

Not really.....

A "real" AI

No true scotsman

the ultimate psychopath: Intelligence without any kind of conscience.

Nobody calls a hammer a psychopath, it's just a tool. But you're exactly right, it'll be like corporations. Most of which are given the marching orders "Whatever make money". And just like corporations are heartless soulless and occasionally do horrible things, we'll have the same experience with AIs. But it all comes down to who is using them. Even a souless corporate overlord will call a halt when it's AI chatbot starts spouting racist rhetoric. A corporations asking a panel of analysts how best to minimize recall costs isn't different then asking an AI.

intelligence. I.e. the ability to use prior experience in totally new situations, evaluate those situations and draw conclusions that can be applied to react properly to it. And I mean totally new.

No true scotsman and you redefined a word to pidgeon-hole the debate.

Care to describe a totally new scenario that you've encountered where you had to employ your intelligence? Because I'm going to bet that you've used your past experience with similar problems to tackle new situations. JUUUUUUUUUUST like how AI can apply past learning sets on similar problems. Just... more narrowly. They're working on a broader, more general intelligence whose learning sets include more and there will be incremental improvements over time.

it's not possible (yet, maybe forever) to create an AI that can make such abstractions and apply old knowledge to new situations.

Uh huh.

3D reconstruction can be generated from 2d images: http://cvl-demos.cs.nott.ac.uk...

Yep. They likely don't have to start from pixelated photos. Most people have high-quality photos out there somewhere. If not, a determined attacker can take his own as you walk down the street.

Also, you don't need the mind pool of Google or Apple to do this. Check out this publicly available demo of 3D Facial Recognition from a Single Image. You can submit your own photo or someone else's and view a 3D model created from it. The model certainly isn't perfect, but it isn't too bad either.

Anyone who uses Face ID on a device with data that they are concerned about protecting is making a mistake. The same is true of fingerprint scanners or virtually any other biometric identification.

How ironic that the paper titled No Silver Bullet" was written by no other than Fred Brooks. Yes, the same guy who wrote the famed The Mythical Man Month, which was about his experience as a manager for software development at IBM.

This is old news folks.

Frederick P. Brooks Jr. wrote an excellent paper (No Silver Bullet: Essence and Accidents of Software Engineering) back in 1987 (link: http://www.cs.nott.ac.uk/~cah/...) that highlights how so much of the complexity that exists in software is *accidental*. This problem is in no way specific to Java, but the language and the supporting eco-system of conventions, libraries and the various supporting "enterprise" tools certainly contribute to the situation. As a language that champions OOP (note: the paper calls out OOP specifically), it makes sense that Java's mainstream-status would lend itself towards being a poster-child for Accidental complexity.

Having worked in the software industry, on various Java code bases, for the past decade: I have observed this curious phenomenon first-hand, repeatedly. It really is quite unfortunate, as it is very possible to write elegant, and concise Java code: one simply has to adopt a more functional programming style and limit mutability within their code. The problem is: most Java developers who appreciate the value of functional programming and immutable design, have already moved on to other languages that have a syntax, standard library and an eco-system that is centered around these principles. I've moved on to Scala largely for this very reason: I grew tired of spending an hour frantically searching through a mountain of convoluted procedural code and XML configs: just to to see why a boolean flag I set was not "seen" by a particular class method.

Both Apple and Microsoft have been using ripoffs of Helvetica for decades as their default font. [...]

All this announcement means is that Apple has finally decided to pay whomever has the copyright on Helvetica for the rights to use it as their default system font.

You managed to pack a lot of factual inaccuracy into such a small package.

Geneva—the font you linked—was never used as Mac OS' default font, was not a rip-off of Helvetica (though it originally shared the same classification as Helvetica), and never had its metrics in common with Helvetica (unlike Arial, which does). The Geneva Wikipedia article linked to a great PDF file as source material on the subject, and you should definitely take some time to read through it, since it's a fascinating read. But, to make a long story short, the differences back then were still apparent enough that even a layperson could have easily told the two apart. Suggesting the one was a rip-off of the other is patently untrue.

With the introduction of TrueType to Macs in 1991, Helvetica itself was licensed for inclusion on all Macs, so Geneva's design was moved away from what little resemblance it did have to Helvetica such that it could fill a different void. During that entire time (all the way through '97, in fact), the actual typeface used by the Mac OS was Chicago, not Geneva, though the two do share the same creator (who also designed many of the iconic Apple icons from the early days). That's about all they share though, since they look nothing alike.

Moreover, your assertion that Apple only just now licensed the rights to use it for a system font are also wrong, since Helvetica was used as iOS' system font at least as far back iOS 2 or iOS 3 (possibly from the very beginning, though I haven't managed to verify that), before being switched to Helvetica Neue with iOS 7. Apple's move to bring Helvetica Neue to OS X now seems to be in line with maintaining a consistent design across their platforms, and has nothing to do with only just now securing the rights to the fonts after having ripped them off for decades, as you claimed.

Frankly, I find it absurd that you're seriously trying to assert that a company with over $100B in the bank and a strong presence in the design industry has been too stingy to pay for the rights to Helvetica this entire time.

Ah, Wikipedia, that most reliable of sources... Would you please read this?

Try this for size; I did some collaboration with Dr. Jolanda Tromp after meeting her at a LUG open day, from which I started the research on IRC. This was while she was writing her paper on CoVEn and following projects (IIRC CoVEn got an extension of four years), out of which she gained her post-Doctorate. I have a hardcopy of her thesis "Systematic Usability Design and Evaluation for Collaborative Virtual Environments (2001)" which she personally gave me in recognition of my efforts. Then she moved into a cave house in Spain and we kept in touch for a few years via Second Life (Bluepill island) after that.

What would you describe as "Functional" then? i.e. What is the key difference between a Functional language and a language that has "Functional Aspects"? Show me the difference you believe is there and I'll show you the Javascript goods.

Oh, and BTW? Academia agrees with me that Javascript is a functional language.

Javascript is a functional language [...] The world's most-widely deployed functional language
--Professor of Theoretical Computer Science Philip Wadler, University of Edinburgh

I've even seen such bullshit claims like that it basically holds all possible states at the same time, so it can calculate anything instantly, since the solution state is already one it simultaneously holds. Which is blatantly bull. If it simply holds all possible states at the same time, that's as good as saying that it has no state at all, or you can't measure it. To get an answer out of the computer, you need to get out of it a particular state which represents the result of the calculation. By that logic I could give you a CD with all possible 4 million DWORD (4 byte, 32 bit) values, from -2 million to 2 million, one of which is the result to your problem. There you go, any problem that has a DWORD result already has the result on that CD, so it was "calculated" instantly. Isn't it an impressive feat? I don't even know your problem, but that CD already has the result to it. It's also completely freakin' useless, if you don't know which one of them. That CD as such holds no more actual usable information that that it's a 32 bit number, which you knew in the first place.

I know little about quantum mechanics and have no clue about quantum computing, but being an expert in constraint-based problem solving perhaps I may throw some light on how this might actually work.

Automated reasoning and theorem proving are usually computed by performing inferences over a search space, defined by a problem stated in a declarative language. A way to represent this kind of problems is by defining a "raw" region of data (like your "All the possible DWORDS", and then asserting constraints over the data that all solutions must fulfil. A classic solver will then proceed to generate many candidate solutions one after another, testing whether they break one of the constraints.

As an example of how this strategy, think of the Eratostenes sieve - you have a pool of numbers in sequence, and want to find all primes. First you remove every second number (greater than 2), because you know those numbers are even; do the same to every third number, every fifth (4 is already removed), etc. This algorithm is not efficient in a classic computer because you have to loop number by number through every inference step.

The dream of every IA researcher and every parallel computer designer would be a way to test all generated candidate solutions at once, instead of looping through them one by one. Quantum computing, if works as advertised, would provide just that - they should implement flooding algorithms in which the computer follows all viable reasoning paths simultaneously, while the stated constraints prune all the forbidden states.

Since all followed paths are equally valid, it doesn't matter to which particular solution the system will collapse when finally observing the result. As the number of loops required to solve logic combinatorial problems grow exponentially, this could reduce the required time to linear, in many cases.

Practical quantum computers are still far away, if ever possible. But if they can work as I've described (and for what people are doing, they might work), they could represent an advance in the field as important as the transistor was to digital computers.

I've even seen such bullshit claims like that it basically holds all possible states at the same time, so it can calculate anything instantly, since the solution state is already one it simultaneously holds. Which is blatantly bull. If it simply holds all possible states at the same time, that's as good as saying that it has no state at all, or you can't measure it. To get an answer out of the computer, you need to get out of it a particular state which represents the result of the calculation. By that logic I could give you a CD with all possible 4 million DWORD (4 byte, 32 bit) values, from -2 million to 2 million, one of which is the result to your problem. There you go, any problem that has a DWORD result already has the result on that CD, so it was "calculated" instantly. Isn't it an impressive feat? I don't even know your problem, but that CD already has the result to it. It's also completely freakin' useless, if you don't know which one of them. That CD as such holds no more actual usable information that that it's a 32 bit number, which you knew in the first place.

I know little about quantum mechanics and have no clue about quantum computing, but being an expert in constraint-based problem solving perhaps I may throw some light on how this might actually work.

Automated reasoning and theorem proving are usually computed by performing inferences over a search space, defined by a problem stated in a declarative language. A way to represent this kind of problems is by defining a "raw" region of data (like your "All the possible DWORDS", and then asserting constraints over the data that all solutions must fulfil. A classic solver will then proceed to generate many candidate solutions one after another, testing whether they break one of the constraints.

As an example of how this strategy, think of the Eratostenes sieve - you have a pool of numbers in sequence, and want to find all primes. First you remove every second number (greater than 2), because you know those numbers are even; do the same to every third number, every fifth (4 is already removed), etc. This algorithm is not efficient in a classic computer because you have to loop number by number through every inference step.

The dream of every IA researcher and every parallel computer designer would be a way to test all generated candidate solutions at once, instead of looping through them one by one. Quantum computing, if works as advertised, would provide just that - they should implement flooding algorithms in which the computer follows all viable reasoning paths simultaneously, while the stated constraints prune all the forbidden states.

Since all followed paths are equally valid, it doesn't matter to which particular solution the system will collapse when finally observing the result. As the number of loops required to solve logic combinatorial problems grow exponentially, this could reduce the required time to linear, in many cases.

Practical quantum computers are still far away, if ever possible. But if they can work as I've described (and for what people are doing, they might work), they could represent an advance in the field as important as the transistor was to digital computers.

Saying that something runs NetBSD is approximately equivalent to saying that something exists.

Doesn't this run NetBSD too?

Sure, your algorithm would count as functional programming, but part of the point about functional programming is that entire programs, not just individual functions, consist of nothing but the composition of pure mathematical functions. Which means that a lot of what you do is "normal" languages just isn't allowed. Point 2.1 in the comp.lang.functional FAQ, which gives a simple comparison between imperative and functional style, although to really understand it you'd need to learn a bit more about at least one of the functional languages.

Just about any language allows you to implement simple pure mathematical functions - as you say, "a simple equation would have unlimited portablity" - but very few languages allow you to construct entire programs that way. None of the mainstream languages (PHP, Perl, Python, Ruby, Java, C, C++, BASIC, etc.) support functional programming to that extent. The languages which do support it are ones like Haskell, ML, OCaml, and Scheme. The reason I say that functional programming is not commercially applicable is not because there aren't commercial applications of it, but because these languages are hardly being used at all commercially. There's a bit of a catch-22 there, because people don't know them because they aren't being used, and they aren't being used because people don't know them.

Here's your algorithm implemented in the Haskell language. If you want to try running it, download and install Glasgow Haskell (on Debian, you can do "apt-get install ghc6"), and run "ghci" to get an interactive Haskell prompt.

-- define a list of p values
let ps = [0.825, 0.8868, 1, 0.8542, 0.8889, 0.8, 0.9118, 0.95, 0.9487, 1, 1, 0.8333, 0.8197, 0.6383, 1, 0.8727, 0.875, 0.7879, 0.8667, 0.8636]

-- define a function which averages a list of numbers.
-- The 'fromIntegral' is needed because Haskell is a strongly, statically typed language
let avg xs = sum xs / fromIntegral (length xs)

-- work out the average of all the p's
let avgP = avg ps

-- define the function, f(p)
-- this would usually be written on multiple lines, but the interactive shell doesn't allow that (?)
let z p = x / y - 1 where x = p - avgP; y = 1 - avgP

-- Finally, "map" the function f over the list ps, giving a list of results.
map z ps

The output from this is:

[-1.4721965172036693,-0.9523008328426015,0.0,-1.22 65500126188285,-0.9346344746361576,-1.682510305375 6212,-0.7419870446706487,-0.4206275763439058,-0.43 156389332884704,0.0,0.0,-1.4023723395305803,-1.516 783040296123,-3.0428198872718117,0.0,-1.0709178093 715828,-1.0515689408597635,-1.7843021788508464,-1. 1213931185328516,-1.1474720282661737]

The above is oriented towards experimenting with it at the command line. For a real program, you'd probably ultimately package it into a single function that takes an input list and produces an output list, e.g.:

-- repeating the avg definition for the sake of completeness
let avg xs = sum xs / fromIntegral (length xs)

let f ps = map z ps
where avgP = avg ps;
z p = x / y - 1
where x = p - avgP;
y = 1 - avgP

("f" is defined over multiple lines for readability, the way it would be written in a program file, although the indentation didn't make it through Slashdot; to enter it interactively, you'd have to do it on one line.)

This last version defines your entire formula quite clearly, for anyone who knows functional programming. That's one answer to your question of how to express these things mathematically: if you express them using high-level programming languages, it has the benefit being concise and unambiguous, but also checked by the compiler, so if it works you know you haven't made any mistake

I'd stay skeptical of such a claim until there is a peer-reviewed paper out. Perhaps you should look for one! A good place to start is here: http://www.virart.nott.ac.uk/ibit/

http://www.crg.cs.nott.ac.uk/research/applications /pits/

"We refer to the generated visualizations as Populated Information Terrains (PITS) to reflect the the fact that a key feature of this work is that these visualizations are intended to be multi-user applications in which the users are explicity embodied in the virtual environment and are thus visible to each other."

http://www.aalab.net/projects/maps/

"

The Map Is The Territory

visualizing on-line communities "

http://www.cs.nott.ac.uk/~gxk/courses/g5baim/paper s/checkers-002/TNNKChellapillaAndDBFogelText.pdf

Too complicated! Try sum [1..8]

A neat paper on fold is A tutorial on the universality and expressiveness of fold.

Oh, please stop it. I am so sick and tired of this global warming whining and hyperbole. As if the forces of nature were were in any way under mankind's control, and as if it would even be possible to significantly reduce carbon emissions without reducing the Earth's population accordingly. What about this thing that's ready to wipe out civilization as we know it (a bit overdue)? Or the old favorite, the big rock from the sky? Oh, and here's my new personal favorite: EVERYTHING goes boom... the whole of Creation jumps to another energy state, just like an electron orbiting an atom... just as it's probably done before. Why, there are countless ways in which this meaningless speck of dust that we inhabit might just shake itself out of its current human infestation. Why focus on just one that's out of our control?

Programs like Eliza have been around since and have not increased in their ability to pass the Turing Test signifigantly. The results Loebner Prize do not show a significant improvement, at least not one that correlates to the improvement in speed/storage. Therefore, I don't think that one can infer that a, future, "fast" computer would be able to pass the turing test based on engineering advances. This will have to come from biological/psycological/neurological/algorithmic advances that are not assured.

http://www.bagley.org/~doug/shootout/

Since CAML is a functional language, it's probably more productive to compare it with other functional languages than with more familiar procedural languages. Good stuff here and here. In this context, it makes sense to have a particular look at Guile, which is like mod_caml in that it implements a functional language as a means of writing application extensions.

The old U.K. rules are quite clear that the attacker rolls the dice first, then the defender rolls. Though it isn't explicit, this suggests that the defender can choose how many to roll based on the attacker's dice, since this would seem to be the only point of rolling later.

This sometimes causes the defender to use only 1 die when he was entitled to use 2. If faced by 2 sixes you only roll 1, whereas faced with the second highest being a one you roll 2. (In both cases this assumes you are not trying to let the attacker through with minimal losses to get to a mutual enemy.)

The U.S. and new U.K. rules specify that both attacker and defender decide beforehand and roll simultaneously. This leads to a faster game and it is rare that the defender rolls 1 when entitled to 2

The same way you bluff a human. Feign greater hand strength than you actually do, through betting and a good reading your opponent. I play poker online regularly at *Party Poker so I know from experience that seeing your opponent is not a required aspect of poker. As the article itself points out, the winner of the last World Series of Poker never played> a tournament in real life before winning the biggest poker tournament in the world. What that means is that there is definitely something to be said about analyzing the betting and behavior patterns of your opponents. On that level, the computer must have a betting and behavior pattern of it's own, as it must follow it's own programming rules put in place by the developers. Thus, when you then sense a weakness, you bet - and hope the computer folds to your bluff. Sure, trying to reverse engineer a poker AI on the fly probably isn't the easiest thing to do, but you didn't hear me complain when I learned my psychiatrist was a stinking robot! Now if you'll excuse me, I have the sudden urge to ask myself in endless loops why I wish to purchase death sticks.. (*Btw, if anyone is interested, they have a $25 bonus deposit going now if you use the code MAGIC when you sign up. Pretty nice deal)

Erlang is a dynamically typed concurrent functional programming language for large industrial real-time systems. Features of Erlang include...

It's easily possible to write a program that plays a game better than the programmer; in fact, this very thing happened early on in the history of computers that play games (in this case, checkers).

I guarantee you that Deep Blue and Deep Junior play chess better than their programmers, and for that matter, almost everyone on earth. That's why they get to play Kasparov.

Same way, manual operations with memory ponters must be prohibited. And they are prohibited in languages with garbage collectors and automatic memory allocation: Java, Python, Perl, Ruby.

GC, automatic memory allocation and disabled GOTO, such methods limit programmers (in a positive way) and help to avoid very critical mistakes. But not all mistakes. Changing the variable (object) value is another source of common mistakes, which must be eliminated. It's solved in Functional Programming languages, such as Lisp, Haskell, ML, Oz, Mercury and Erlang.

Convert various stuff to SVG

Then perhaps people would switch away from Flash, to a fully open, free, W3C-supported standard like Scalable Vector Graphics (SVG)? (See a comparison of SWF and SVG functionality and a description of how Flash animation maps to SVG - both fairly old articles BTW.)

I wish, but MS will use their browser market dominance to make sure that IE doesn't support it. Or if they do decide to incorporate it they'll use their tried-and-trusted tactic of "embrace(alter) and extend", so any W3C standards that are supported suddenly only seems to work properly in IE, thanks to a few subtly different things (not that they've done that before, cough - document.all, element.innerHTML - cough!). And as they'll have also aquired Dreamweaver (the most popular web development tool) they will therefore control the output format of 90% of the code produced; I dread to think how this'll affect the web as a whole.

Wouldn't surprise me if they just stuck their middle finger up at the W3C and took control for themselves... or am I being overly paranoid?

Damn I sure do hope this is just a rumour...

Then perhaps people would switch away from Flash, to a fully open, free, W3C-supported standard like Scalable Vector Graphics (SVG)? (See a comparison of SWF and SVG functionality and a description of how Flash animation maps to SVG - both fairly old articles BTW.)

I wish, but MS will use their browser market dominance to make sure that IE doesn't support it. Or if they do decide to incorporate it they'll use their tried-and-trusted tactic of "embrace(alter) and extend", so any W3C standards that are supported suddenly only seems to work properly in IE, thanks to a few subtly different things (not that they've done that before, cough - document.all, element.innerHTML - cough!). And as they'll have also aquired Dreamweaver (the most popular web development tool) they will therefore control the output format of 90% of the code produced; I dread to think how this'll affect the web as a whole.

Wouldn't surprise me if they just stuck their middle finger up at the W3C and took control for themselves... or am I being overly paranoid?

Damn I sure do hope this is just a rumour...

Just to follow up on my previous post, here are some resources:

• Memetic Algorithms' Home Page
• A Simple Heuristically Guided Search for the Timetable Problem
• (extract from the comp.ai.genetic FAQ)
• An honour's thesis on the topic
• Taiwanese site (in English) with links to papers, etc
• paper and paper available on citeseer

No, this is not a problem for the faint of heart.

You mean Pink?

So the short answer to your question is : no, XSL is not the right choice to do procedural logic.

Functional programming requires a completely different mode of thinking than procedural programming. Anybody who understands the definition of "procedure" in ordinary English understands the procedural programming paradigm, even if they don't know the technical details. But the functional programming paradigm is a lot less commonplace, and takes some getting used to. Before tackling XSLT, it might make sense to try to pick up some fundamental FP concepts. One way to do this would be to work through the leading functional programming textbook. (It says a lot about MIT that they've gone and made the entire book available online!)

It is kind of irritating that XSLT's creators decreed that a syntactically correct XSLT program had to be a well-formed XML document -- and thus rather verbose. But that sort of thing rather goes with the FP mindset -- FP source is supposed to be easily transformable using the same language it's written in. That's why there are Lots of Insipid Silly Parentheses -- and so few syntax rules -- in languages like Scheme.

It's worth mentioning that Perl, though basically a procedural language, has some of the same design philosophy as the FP languages. It's easier to code a simple loop in Perl than in an FP language -- but Perl has as many ways to avoid coding a loop as any FP language!

Also worth mentioning that XSLT and XSL are not quite the same thing. XSLT is the transformation language for XSL. It's a relatively recent invention. As originally conceived by Microsoft (yep, the evil empire was the biggest partner in drawing up the original XSL spec), transformation languages were a mix-and-match affair. A lot of early examples had XSL stylesheets with embedded Visual Basic code!

Come to think of it, it wouldn't be hard to do a stylesheet language based on Perl, or to evolve a convention for embedding Perl instead of XSLT in XSL stylesheets. Now, why do you suppose nobody is working on that. Uh, that's a rhetorical/socratic question!

Haskell has no assignment to variables, because of one of the most important properties of functional languages (though not obeyed by all languages calling themselves functional):

• A function called with the same arguments will always yield the same result, no matter what.

Limited storage just means that you can't use programming methods that use a lot of state variables. Procedural programming, which is what most of us do, requires state variables. Functional programming does not.

But you're basically right -- nobody's going to write anything interesting for such a platform. Which is obviously why so little RAM is available. They certainly don't save any money using such a small chip. Given current e-economics, it might even cost extra.

So the idea is hardly hot news.

So the idea is hardly hot news.

http://www.cs.nott.ac.uk/~gmh//faq.html#functional -languages

• Paul Verhelst, Computer Chess Programming. Includes many other links.
• T.A. Marsland, The Anatomy of Chess Programs. International Computer Chess Association.
• A.N. Walker, Notes for a course at the University of Nottingham.
• Fox, Williams, and Messina. Chapter from a book called Parallel Computing Works.

Here is a useful description.

This simply isn't true. Chess is a strictly competative zero-sum game (what is good for me is bad for you and vice verse) with perfect information (there is a finite number of possible positions). Therefore, Chess has a value when using pure strategies - that is, one player has a best strategy that, if played, the other could do nothing to prevent the outcome! We just don't know what this value is... yet.

While this may be counter-intuitive, this was first put forth by E. Zermelo in 1913! But it requires rational players that consider all possible moves... something humans can't do but computers someday just might.

Dr. Walker of The University of Nottingham has a very interesting page on computerchess. On a general level he discusses techniques for chess computers. For anyone unfamiliar with gaming AI, I would recommend it as a good place to start.

It may have been coined originally by occasional Slashdot poster Leo Schwab for his Amiga demo of same name. It certainly helped to further popularize the term. The demo was a clever Robotron spoof.

As Bill Hicks said, "If you are in marketing or advertising... kill yourself."

Flash, you've only got 14 minutes to save the Earth.

Flash is binary, nasty and costly to develop, it must die.

I went to a talk on converting flash to SVG a few months ago, the program to do it is available online via some cgi

Haskell has CGI and animation libraries, as well as a system for writing music. There are foreign library interfaces and highly optimizing compilers, database interfaces and graph visualizers.
Libraries and Tools in Haskell
Haskell in Practice
Here are some books and papers about how to program in Haskell and functional languages in general.
I particularly recommend Hudak's book; Paul himself is a very clear teacher and lecturer, as is Zhong Shao, who does research in ML (Standard ML of NJ). I think SML is the only functional language around whose semantics are completely specified.
Follow these links and learn about Erlang (in massive production use at Ericsson), high level abstraction through functions defined via structural induction over datatypes, monads, layered functionality used to build parsers (via parser combinators), and a type theory for object-oriented programming.

Seriously, closures are a very specific notion. If you have not seen them it will take you a while to understand what they are, and longer to see why people want them.

Why not start with some documenta tion? I have neither the ability nor the desire to fully explain an entire philosophy of programming in a brief post. Go and read a FAQ if you want to start down that path.

If this seems needlessly arrogant, ask yourself a question. If you wanted to make a comment on the calculus in a forum where some are mathematicians and some are high-school students, would you feel it sufficient to mention that your comment only will make sense to people who understand calculus? This situation is exactly parallel to that.

Cheers,
Ben

If you are interested in looking into Haskell, my main advice is to be prepared to spend time learning it: if you have never used a lazy functional programming language it takes time to learn how to use these features, and the way Haskell uses state (indirectly via `monads') is tricky to grasp.

the time is worth it in my opinion; laziness provides a powerful heuristic for attacking difficult optimisation problems efficiently: an application of haskell is in providing effiecnt dynamic prgramming solutions to NP hard optimisation problems, and then step-by-step transforming these into industrial strength `C' code. This strategy has produced some of the best solutions to the problem, because laziness captures a fruitful intuition about how to minimise resources in such problems.

If you are not enthusiastic about putting the time in, it is worth having a look at Objective CAML (`ocaml'), a language that combines an excellent marriage of objective and functional programming with one of the best development suites in functional programming. References to both can be found at the FAQ for comp.lang.functional.

Of course both languages lack `prevalence', though that may change, since Simon Peyton-Jones, one of the chief architects of Haskell, has taken a post at Microsoft...

I suggest looking at the comp.lang.functional FAQ. The newsgroup has reasonable traffic even though content varies between beginner and theoretician levels.