Did Haskell get significant whitespace from Python - doubtful as Python possibly wasn't visible enough at the time, but you never know.

Whitespace is significant in almost every language: foo bar /= foobar. Using indentation for program structuring was introduced by Peter Landin in his ISWIM language (1966), which is where Haskell picked it up from (via Miranda). See http://en.wikipedia.org/wiki/Off-side_rule Regards, Malcolm

Python is approximately as old as Python and most likely got indentation from ABC. Checking on Wikipedia, one of the ABC's creators was Lambert Meertens (famous for *-morphisms amongst other things) so there is a lineage going back to Algol and Peter Landin / ISWIM. PS. my fact-checking is a bit ropey, but I think my general point stands that the current popular languages haven't taken much if anything from Haskell, rather its predecessors in the functional family. On 4 November 2010 11:09, Heinrich Apfelmus wrote:

As far as I am informed, Python got the significant whitespace from Haskell. Haskell itself (or rather the design committee) got the idea from SASL (1976) and Miranda (1986), though it goes way back to the 1960s, as described in section 4.1 "Layout" of

 http://www.haskell.org/haskellwiki/History_of_Haskell

Regardless of which languages got which features for which other languages, Haskell is surely NOT a "scripting language inspired by python"... Also, it was my understanding that Python got list comprehensions straight from Haskell. Unless, of course, some of the pre-Haskells also had this feature. Haskell: [f x | x <- xs, x <= 15] Python: [f(x) for x in xs if x <= 15] The Python version reads the way I would speak the Haskell one if I were reading code aloud, though I might say "such that" rather than "for" --Jonathan Geddes On Thu, Nov 4, 2010 at 6:05 AM, Stephen Tetley wrote:

On 4 November 2010 12:03, Stephen Tetley wrote:

...

Python is approximately as old as Python and most likely got indentation from ABC.

Apologies that should read - "as old as Haskell"

Obviously IDSWIM - (I _don't_ say what I mean). _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

I'm no compiler writer but as a layperson I'd guess for that you'd at least need a program that could determine if two constructs are equivalent, the Haskell and Python list comprehension example from 2 emails ago. The only way I can think to do that is to parse some source in language X and see if the AST generated is the same as language Y. As far as something fully automated my intuition tells me that you'd need a single program that could act as a compiler and/or interpreter for all the languages you're trying to test. This is the only way, for example, to automatically determine that variable scoping works the same in Javascript and Scheme. -deech On Thu, Nov 4, 2010 at 10:03 AM, Dupont Corentin wrote:

Hello, reading this thread a question came to me: Is there a way of automatically deriving programming languages ascendancy?

Like biologist can determine the distance between two genotypes, and determine a hierarchy between species from that.

Are you aware of researchs made in the field?

On the net I found interesting graphs but no comments on the methodology. http://www.levenez.com/lang/ http://rigaux.org/language-study/diagram.html

Cheers, Corentin

_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

"Richard O'Keefe" writes:

Automatically? Probably not.

...

Like biologist can determine the distance between two genotypes, and determine a hierarchy between species from that.

I'm going to say the same as Richard, only differently. For computer languages, we can't observe the genotype, only the phenotype. I.e. we can look at what the language looks like on the surface, but not what made it so - there are no "genes" available. This is where biology was before DNA was discovered, and it led to interesting taxonomies, starting with Genesis's division into animals by habitat.

Until this year I taught some of that stuff. The distance between two sequences depends hugely on *what* you choose to measure (which particular features) and *how* you measure distances (there are similarity matrices people use, but you have to choose).

I think you are referring to edit distance here, where you find the optimum given penalties for substitutions and gaps - typically an affine penalty for gaps (exepensive gap opening penalty, somewhat cheaper gap extension), and a char x char cost matrix for substitution. Especially the gap costs aren't well founded theoretically, so hopefully the results aren't varying /hugely/.

Then there are algorithms that give optimal results but blow up for anything much past 15 species,

I.e, edit distance is O(n^k) for k sequences of length n.

Then we turn to human designs, and suddenly THERE IS NO TREE.

Bacteria can also do horizontal gene transfer, so there is no (single) tree there either. -k -- If I haven't seen further, it is by standing in the footprints of giants

ZF Expressions (aka list comprehensions) date to at least David Turner's KRC (St. Andrews Static Language) and Rod Burstall and John Darlington's Hope c.1980. Maybe they were present in NPL, the predecessor of Hope before that. The Hope paper nods to SETL as an influence. Without interviewing the people concerned its probably impossible to actually find out what influenced what - even though list comprehensions have a long history the designers of Python might have only seen them in Haskell so Python could well have "got" them from Haskell. Hope - An Experimental Applicative language http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.18.8135 The language guide is truly strange - maybe it was written by work experience students. The Icon entry made me smile, although the SML entry where they missed a crucial suffix is good too - "The current implementation is Moscow" - what, the city implements a programming a language?

On Nov 4, 2010, at 9:51 AM, Stephen Tetley wrote:

Without interviewing the people concerned its probably impossible to actually find out what influenced what - even though list comprehensions have a long history the designers of Python might have only seen them in Haskell so Python could well have "got" them from Haskell.

The Python people have explicitly said they got the idea and syntax from Haskell. http://wiki.python.org/moin/PythonVsHaskell

On Thu, 4 Nov 2010, Andrew Coppin wrote:

It's a full-scale programming language (although I gather folks do use it for scripting too), and while it may or may not contain features that are also in Python, it is manifestly /not/ "inspired by" Python. Clearly it was inspired my Miranda and the host of similar-yet-incompatible languages like it. (The design goal was to replace these languages, after all.)

On a somewhat tangental note: It seems increadible to me that Haskell was invented in 1990, and Miranda way back in 1985. At the same time, Commodore Business Machines released the iconic Commodore 64 in 1982, and most of the civilised people of the world spent the next 10 years or so writing computer programs in BASIC. It's a rather sobering thought to think that way back in those long-lost days of 8-bit microprocessors, RF-modulated graphics and unstructured programming, there were people somewhere working on languages such as Miranda. I mean, comparing BASIC to FP is like comparing a water pistol to a tactical thermonuclear device. (!) Where the heck did all this stuff happen?! Can you actually run something like Haskell with mere kilobytes of RAM?

For me at least 1985 is the year, where the Amiga 1000 was released. At this time, machines with a MC 68020 were refered to as "Work stations", what for me meant something like "expensive professional computer". For Amiga with some megabytes RAM and a CD drive we had the Geek-Gadgets-2-CD in 1997 that contained Gofer. However at this time I was glad to program in object oriented style and especially GUIs with OOP.

Quoth Andrew Coppin , ...

I didn't get to see the Amiga 600 until at least five or six years later than that. (It's actually news to me that the Amiga line is that old.) And I spent most of my time programming it in Pascal (or AMOS BASIC - but that's not really "BASIC" any more). And between that, there was Borland Turbo Pascal 5.5 for MS-DOS, if you were forced to use a PC. It's scary to think that even way back then, vastly superior languages were being used in secret...

I imagine it's the same in most areas of human endeavor. When the Amiga came out, I remember a somewhat effusive article in a major magazine (BYTE, I think?), enough that it sure would have been my choice (had I the funds and need for a computer.) But of course, for all it's obviously vast superiority, never really went anywhere. Haskell has a lot going for it, too, but that doesn't make much difference in the big picture. Is it because merit just doesn't count? Tough question. The Amiga had some great stuff, but also some rough edges, and while it may have all been about marketing and herd behavior, you can't totally discount the possibility that people just know what they like, and that wasn't it. Surely it's the same with Haskell in some ways. I don't care about whether Python had any influence, but I'd sure like to stamp out the "scripting language" rumor. For that matter, I propose that there is hardly any such thing as a scripting language per se, but rather that it's a relative notion - if I have an application X, then I may enhance it with a scripting language Y, but outside of that context it's a programming language, not a scripting language. I know this contradicts common usage to a considerable extent, but it's an ignorant and foolish common usage. I suppose the confusion may begin with system scripting languages, like the UNIX shell or REXX, where the parallel between an OS and an application may not be as obvious (unless you're an Amiga geek!) as the resemblance between the shell and other interpreted programming languages. Donn Cave, donn@avvanta.com

On Thu, Nov 4, 2010 at 6:00 PM, Donn Cave wrote:

I don't care about whether Python had any influence, but I'd sure like to stamp out the "scripting language" rumor.

You all are talking about calling Haskell a scripting language like it's a bad thing. Coming from a Perl background, I learned that when a culture made stuck-up claims about its language being a "real" programming language, what it meant was that it would be verbose, dry, and no fun. To us, scripting meant short, potent code that rolled off your fingers and into the computers mind, compelling it to do your job with reverence to the super power you truly are. Programming meant a system with 100,000 lines of boring code that reinvents a broken dialect of LISP because it was too rigid to get the job done naturally. I also have a C++ background and a C# foreground. This large, inert culture views Programs with a capital P as large, complete tools like Photoshop (also with a capital P). Their #1 stigma against scripting languages is that they are too slow to do real work. Also they "don't scale well", which I guess means that they don't make it inconvenient to design badly. Haskell is a language in which it is possible to write short, potent code (I use it at the command line). It is fast enough to do real work. It is inconvenient to design badly. It is fun. It is also dry sometimes. "Scripting language" strikes me as one of those terms that is used in heated arguments despite having no meaning (meaningless terms seem to proliferate as the heat is turned up). I dunno, I just don't think it is a big deal. Everybody seems to be calling Haskell a "DSL-writing language", but that can just as easily be taken as a point for and against it. If people find Haskell useful for scripting, then it is a scripting language. No need to be offended. Luke

Luke Palmer writes:

To us, scripting meant short, potent code that rolled off your fingers and into the computers mind, compelling it to do your job with reverence to the super power you truly are.

Just when I thought, oh, there are two definitions for "scripting language", another one pops out. So scripting languages can be three things: 1) A language for controlling ('scripting') an application (e.g. TCL, VBA) 2) A language for controlling the running of various applications (e.g. shell scripts) 3) An agile language for making short programs (e.g. Perl) Although Haskell is quite expressive, programs tend to need a bit of 'wrap' (module declaration, imports, etc), making it a bit more heavyweight than Perl or AWK for #3. For #2, I think running other programs are a bit too cumbersome, but perhaps this is just a library problem? I haven't really looke at #1, I think we lack a small, easily embeddable interpreter. So, I wouldn't really call Haskell a scripting language in its current state in any of these senses, although it's close for #3. I think you see more of an advantage for slightly larger programs - ones that you perhaps need to maintain - though. More definitions of scripting language: a) too slow to do real work b) Also they "don't scale well" I think Haskell can be fast enough to do 'real work', and although I haven't really written any large programs in Haskell, I don't see why it should scale worse than other languages. -k -- If I haven't seen further, it is by standing in the footprints of giants

On 05/11/2010, at 4:11 PM, Luke Palmer wrote:

Also they "don't scale well", which I guess means that they don't make it inconvenient to design badly.

And they don't communicate enough information about the preconditions/postconditions of their functions to easily allow large programs to remain correct? That is, the types expected and returned.

On 04/11/2010 08:47 PM, Ketil Malde wrote:

Andrew Coppin writes:

...

On a somewhat tangental note: It seems increadible to me that Haskell was invented in 1990, and Miranda way back in 1985. At the same time, Commodore Business Machines released the iconic Commodore 64 in 1982, It is amazing - although as you point out, computers weren't very capable, so although it may have been possible to run Gofer on an Amiga, it was not what the 1337 hackers used for their demos.

But it shows how incredibly inert the field of computer science really is. Or perhaps, how far software engineering is removed from computer science.

Well, mainstream computing seems to be far more driven by economics than technology. It's weird; on the one hand, every new programming language (or product, for that matter) must have some astounding new whizz-bang to make it stand out. And yet, at the same time, it mustn't be too radical, or people might be scared of it...

Makes you wonder what the current day developments are that will be fighting for a corner of the mainstream in thirty years.

Only time will tell.

-k

"If I haven't seen further, it is by standing in the footprints of giants" What an oddly apt sentiment...

On 4 Nov 2010, at 22:38, Lennart Augustsson wrote:

The smallest bootstrapped Haskell compiler is NHC which (I think) runs in a few MB.

Originally, it needed to be able to compile itself in the 2Mb available on Niklas's Amiga. Then he got an upgrade to 4Mb, so he started to become less disciplined about keeping things small. :-) I haven't checked how much RAM nhc98 needs for bootstrapping recently, but the Makefile suggests 16Mb of heap + 2Mb of stack is more than sufficient - it could probably manage with less. Regards, Malcolm

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 On 11/11/10 11:12 , Simon Marlow wrote:

I bootstrapped GHC from the intermediate C files on a 640K PC around 1993 or so. I don't remember exactly, but I think it might have worked, for some small value of "work".

If you used the right build environment, the compiler would have arranged for overlays; the better ones even supported data overlays, but I imagine that would have wreaked utter havoc with the runtime (its thunks would have been wrapped in compiler-generated thunks that swapped the overlay space as needed). - -- brandon s. allbery [linux,solaris,freebsd,perl] allbery@kf8nh.com system administrator [openafs,heimdal,too many hats] allbery@ece.cmu.edu electrical and computer engineering, carnegie mellon university KF8NH -----BEGIN PGP SIGNATURE----- Version: GnuPG v2.0.10 (Darwin) Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/ iEYEARECAAYFAkzcF7wACgkQIn7hlCsL25UdJACeNi0aPwQRAatUiBH1MDFQrttR jOcAnjrUA29p/lxqwv3N0WXDRvEO+DYW =+BuC -----END PGP SIGNATURE-----

On 5/11/2010, at 8:54 AM, Andrew Coppin wrote: Can you actually run something like Haskell with mere kilobytes of RAM? There was a Lisp for PDP-11s (64k). Henderson's LispKit ran on the Apple II, which was pretty small, and LispKit was basically a lazy Lisp. To that degree, yes you *can* run something "like" Haskell with mere kilobytes. See ftp://ftp.comlab.ox.ac.uk/pub/Documents/techpapers/Geraint.Jones/PRG-TM-32.pdf To think that when I met LispKit, I said "oh, it's not a *real* Lisp" and turned away. Talk about missing the point!

On Thu, Nov 4, 2010 at 20:54, Andrew Coppin wrote:

On 04/11/2010 02:16 PM, Jonathan Geddes wrote:

I mean, comparing BASIC to FP is like comparing a water pistol to a tactical thermonuclear device.

You have the similitude backward. It's Haskel that is fun and BASIC which caused disasters. :)

On 11/04/2010 03:30 PM, Lennart Augustsson wrote:

KRC, Miranda, and LML all predate Haskell and have list comprehensions.

Just because those languages predate Haskell and have list comprehensions doesn't mean that they still couldn't have gotten the idea from Haskel!. After all, I fully anticipate us using the Haskell language in the near future to build a time machine that will allow us to beam some of our insights back to influence earlier programming languages. Cheers, Greg

On Thu, Nov 4, 2010 at 4:48 PM, Richard O'Keefe wrote:

On 4/11/2010, at 9:08 PM, Stephen Tetley wrote:

...

Did Haskell get significant whitespace from Python - doubtful as Python possibly wasn't visible enough at the time, but you never know.

Python did not originate indentation-based syntax. Occam has it too. I first came across the idea in a rather old book which I *think* was by Reynolds.

I had absolutely nothing to do with it.

However, I must say that it is obvious to anybody properly schooled in philology and hermeneutics, to say nothing of theology and geometry, that both Python and Haskell stole their whitespace ideas from the medieval scribes who invented interword spaces. As is well known, the reason Roman computers never caught on is because they didn't use white space in their programming languages. For more info, see "Space Between Words; The origins of silent reading" by Paul Saenger, Stanford U Press, 1997. I'm not joking; anybody who enjoys thinking about computation will find it very enjoyable. It's one of those historical works that makes you realize that what you thought was trivial (e.g. whitespace) is actually of enormous import.

...

Doesn't COBOL have significant layout anyway as an inspiration to both?

Yes and no. What it actually has relates strongly to punched cards and is more like assemblers of the day.

Columns 1 to 6 were for the sequence number. Column 7 is called the indicator area. Columns 8 to 11 are "Area A". Certain structure keywords and labels must go in that area. Columns 12 to 72 are "Area B". Normal statements go in that area. Indentation *within* area B has no significance whatever. Columns 73 to 80 have a name (the Identification Field) but

And I thought I was the last mainframer alive! (I'm sure you'll agree calling COBOL an "inspiration" of Haskell might be a wee bit of a stretch.) Anyway, anybody who has ever wondered why 80 cols is a standard width now knows. -Gregg

On 10/11/2010, at 12:50 AM, Bulat Ziganshin wrote:

i never programmed in COBOL, but afaik data structures usually was organized this way - together with level numbers at left. it was just easier to read it this way

The clue here is "level numbers". In a declaration like 01 Thingy 03 Wotsit 05 Uggle PIC X(5) 05 Zonko PIC 9(4) USAGE COMPUTATIONAL 03 Snork 05 Name PIC X(20) 05 Price PIC 9999V99 USAGE DISPLAY. the indentation is solely for the benefit of people. The compiler uses the *numbers* to figure out the structure. 01 Thingy 03 Wotsit 05 Uggle PIC X(5) 05 Zonko PIC 9(4) USAGE COMPUTATIONAL 03 Snork 05 Name PIC X(20) 05 Price PIC 9999V99 USAGE DISPLAY. would work every bit as well. The same is true of PL/I, which also used level numbers for structuring.

On 4 November 2010 15:30, Mark Lentczner wrote:

On Nov 3, 2010, at 7:00 PM, Jonathan Geddes wrote:

...

http://www.datarecoverylabs.com/ultimate-computer-language-guide.html

It's called "The *Ultimate* Computer Language Guide," and it's on the internets, so it must be correct, right?

Wow! Did you read the rest of that page? It is so full of fail! Can you imagine trusting your data to these people?

Best laugh I've had in ages. Personal favourites are:

Forth [...] "the language represents two virtual stacks to accomplish algorithms" Ruby [...] "is often compared to Java in as much as both languages borrow object-oriented syntax pioneered by small talk[sic]" Tcl [...] "is extensible through high level languages like Java" Perhaps we should help them to update their page. I suggest "*Haskell was developed by Isaac Newton in the 15th Century as a tool to help his investigations into the Alchemic arts. It was rediscovered in the 1980s by three Cambridge undergraduates who were browsing through Newton's laboratory notebooks looking for smutty jokes in the margins, and has since developed into an elaborate joke perpetrated by elite computer scientists who believe that predictable order of execution is contrary to natural law. The current version of Haskell is Haskell 1714, which adds syntactic sugar for Zygohistomorphic Premorphisms to the original language definition of 1693*."

Mark

_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

On Thu, Nov 4, 2010 at 2:27 PM, Dan Doel wrote:

On Thursday 04 November 2010 12:12:51 pm Jeremy O'Donoghue wrote:

...

Best laugh I've had in ages. Personal favourites are:

The Forth one got me. I also like:

OCaml: "OCaml is an attempt to implement object-oriented syntax in Caml. It is related to SML."

No mention of what Caml is, by the way. Hope you already know that. Maybe the SML entry will help?

SML: "SML is the current descendant of the ML programming language. The most common current implementation is Moscow."

Nope, it has no information on what ML is.

it is a meta-language afterall...

On Thu, Nov 4, 2010 at 2:41 PM, Albert Y. C. Lai wrote:

On 10-11-03 10:00 PM, Jonathan Geddes wrote:

...

It's called "The *Ultimate* Computer Language Guide," and it's on the internets, so it must be correct, right?

The correct conclusion: it's on the internets, so it must be LOL.

The stuff that is *not* on the internets must be really awesome - can anyone give me a link to that? -david

<< Also they "don't scale well", which I guess means that they don't make it inconvenient to design badly. >> Luke Palmer I nominate the above for quote of the week !