<html xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:w="urn:schemas-microsoft-com:office:word" xmlns:m="http://schemas.microsoft.com/office/2004/12/omml" xmlns="http://www.w3.org/TR/REC-html40"><head><meta http-equiv=Content-Type content="text/html; charset=utf-8"><meta name=Generator content="Microsoft Word 15 (filtered medium)"><style><!--
/* Font Definitions */
@font-face
{font-family:Wingdings;
panose-1:5 0 0 0 0 0 0 0 0 0;}
@font-face
{font-family:"Cambria Math";
panose-1:2 4 5 3 5 4 6 3 2 4;}
@font-face
{font-family:Calibri;
panose-1:2 15 5 2 2 2 4 3 2 4;}
@font-face
{font-family:"Segoe UI Emoji";
panose-1:2 11 5 2 4 2 4 2 2 3;}
@font-face
{font-family:Consolas;
panose-1:2 11 6 9 2 2 4 3 2 4;}
/* Style Definitions */
p.MsoNormal, li.MsoNormal, div.MsoNormal
{margin:0cm;
margin-bottom:.0001pt;
font-size:11.0pt;
font-family:"Calibri",sans-serif;}
a:link, span.MsoHyperlink
{mso-style-priority:99;
color:blue;
text-decoration:underline;}
a:visited, span.MsoHyperlinkFollowed
{mso-style-priority:99;
color:#954F72;
text-decoration:underline;}
p.MsoListParagraph, li.MsoListParagraph, div.MsoListParagraph
{mso-style-priority:34;
margin-top:0cm;
margin-right:0cm;
margin-bottom:0cm;
margin-left:36.0pt;
margin-bottom:.0001pt;
font-size:11.0pt;
font-family:"Calibri",sans-serif;}
.MsoChpDefault
{mso-style-type:export-only;}
@page WordSection1
{size:612.0pt 792.0pt;
margin:72.0pt 72.0pt 72.0pt 72.0pt;}
div.WordSection1
{page:WordSection1;}
/* List Definitions */
@list l0
{mso-list-id:955331552;
mso-list-type:hybrid;
mso-list-template-ids:-1929625484 -1 134807555 134807557 134807553 134807555 134807557 134807553 134807555 134807557;}
@list l0:level1
{mso-level-start-at:0;
mso-level-number-format:bullet;
mso-level-text:\F0D8;
mso-level-tab-stop:none;
mso-level-number-position:left;
text-indent:-18.0pt;
font-family:Wingdings;
mso-fareast-font-family:"Times New Roman";
mso-bidi-font-family:"Times New Roman";}
@list l0:level2
{mso-level-number-format:bullet;
mso-level-text:o;
mso-level-tab-stop:none;
mso-level-number-position:left;
text-indent:-18.0pt;
font-family:"Courier New";}
@list l0:level3
{mso-level-number-format:bullet;
mso-level-text:\F0A7;
mso-level-tab-stop:none;
mso-level-number-position:left;
text-indent:-18.0pt;
font-family:Wingdings;}
@list l0:level4
{mso-level-number-format:bullet;
mso-level-text:\F0B7;
mso-level-tab-stop:none;
mso-level-number-position:left;
text-indent:-18.0pt;
font-family:Symbol;}
@list l0:level5
{mso-level-number-format:bullet;
mso-level-text:o;
mso-level-tab-stop:none;
mso-level-number-position:left;
text-indent:-18.0pt;
font-family:"Courier New";}
@list l0:level6
{mso-level-number-format:bullet;
mso-level-text:\F0A7;
mso-level-tab-stop:none;
mso-level-number-position:left;
text-indent:-18.0pt;
font-family:Wingdings;}
@list l0:level7
{mso-level-number-format:bullet;
mso-level-text:\F0B7;
mso-level-tab-stop:none;
mso-level-number-position:left;
text-indent:-18.0pt;
font-family:Symbol;}
@list l0:level8
{mso-level-number-format:bullet;
mso-level-text:o;
mso-level-tab-stop:none;
mso-level-number-position:left;
text-indent:-18.0pt;
font-family:"Courier New";}
@list l0:level9
{mso-level-number-format:bullet;
mso-level-text:\F0A7;
mso-level-tab-stop:none;
mso-level-number-position:left;
text-indent:-18.0pt;
font-family:Wingdings;}
ol
{margin-bottom:0cm;}
ul
{margin-bottom:0cm;}
--></style></head><body lang=RU link=blue vlink="#954F72"><div class=WordSection1><div><div><div><div><ul style='margin-top:0cm' type=disc><li class=MsoListParagraph style='margin-left:0cm;mso-list:l0 level1 lfo1'>Eta does. Through a very nice FFI. But so does Haskell. We have nice FFI to use C libs. I maintain a couple of libs that use it extensively, works quite well.</li></ul><p class=MsoNormal><span lang=EN-GB><o:p> </o:p></span></p><p class=MsoNormal><span lang=EN-GB>I asked because never tried Eta. So, if you are right, seems no reasons to develop Eta...</span></p></div></div></div><div><div><div><p class=MsoNormal><o:p> </o:p></p></div></div></div><div><div><div><ul style='margin-top:0cm' type=disc><li class=MsoListParagraph style='margin-left:0cm;mso-list:l0 level1 lfo1'><span style='color:#212121'>Can I have a definition and laws of "monad++"? Otherwise, I don't understand what you are talking about. If it obeys monadic laws it is a monad. But I'll wait for the definition. </span></li></ul></div></div></div><div><div><div><p class=MsoNormal><span lang=EN-GB><o:p> </o:p></span></p><p class=MsoNormal><span lang=EN-GB>No better definition then original: </span><a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/computation-expressions">https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/computation-expressions</a><span lang=EN-GB> You see, they are different.</span></p><p class=MsoNormal><o:p> </o:p></p></div></div></div><div><div><div><ul style='margin-top:0cm' type=disc><li class=MsoListParagraph style='margin-left:0cm;mso-list:l0 level1 lfo1'><span style='color:#212121'>But it is not lazy - one. Remember, laziness is our requirement here. Whatever you propose _must _ work in a context of laziness.</span></li></ul><p class=MsoNormal><span lang=EN-GB><o:p> </o:p></span></p><p class=MsoNormal><span lang=EN-GB>Does it mean because Haskell is lazy (Clean – not) then linear types are impossible in Haskell? If they are possible why we need monads? <o:p></o:p></span></p><p class=MsoNormal><o:p> </o:p></p></div><div><ul style='margin-top:0cm' type=disc><li class=MsoListParagraph style='margin-left:0cm;mso-list:l0 level1 lfo1'><span style='color:#212121'>Second, the inability to track side effects in F# is not "simplification" and is not a benefit, but rather a limitation and a disadvantage of the language and its type system.</span></li></ul></div><div><p class=MsoNormal><span lang=EN-GB style='color:#212121'>Why?<o:p></o:p></span></p><p class=MsoNormal><span lang=EN-GB style='color:#212121'><o:p> </o:p></span></p><p class=MsoNormal><span lang=EN-GB style='color:#212121'>Haskell “tracks” effects obviously. But I shown example with State monad already. As I saw, nobody understand that State monad does not solve problem of spaghetti-code style manipulation with global state. Even more, it masks problem. But it was solved in OOP when all changes of state happen in <b>one place</b> under FSM control (with explicit rules of denied transitions: instead of change you have <b>a request to change</b>/a message, which can fail if transition is denied). Haskell HAS mutable structures, side-effects and allows spaghetti-code. But magical word “monad” allows to forget about problem and the real solution and to lie that no such problem at whole (it automatically solved due to magical safety of Haskell). Sure, you can do it in Haskell too, but Haskell does not force you, but Smalltalk, for example, forces you.<o:p></o:p></span></p><p class=MsoNormal><span style='color:#212121'><o:p> </o:p></span></p><p class=MsoNormal><span lang=EN-GB style='color:#212121'>We often repeat this: “side-effects”, “tracks”, “safe”. But what does it actually mean? Can I have side-effects in Haskell? Yes. Can I mix side-effects? Yes. But in more difficult way than in ML or F#, for example. What is the benefit? Actually no any benefit, it’s easy understandable with simple experiment: if I have a big D program and I remove all “pure” keywords, will it become automatically buggy? No. If I stop to use “pure” totally, will it become buggy? No. If I add “print” for debug purpose in some subroutines, will they become buggy? No. If I mix read/write effects in my subroutine, will it make it buggy? No.<o:p></o:p></span></p><p class=MsoNormal><span lang=EN-GB style='color:#212121'><o:p> </o:p></span></p><p class=MsoNormal><span lang=EN-GB style='color:#212121'>IMHO there is some substitution of concepts. Monads roots are not safety, but workaround to have effects in pure lambdas. And <b>after</b> monads introduction, a thesis was appeared: “monads make code more safe”. Motivation of monads was not to track effect (because it’s allegedly more safe), but to inject/allow/introduce effects in language like Haskell. Good example is State monad, again. State monad is needed to support manipulation of state (through argument replacement in chain of lambdas) but it’s totally other thing in comparison with idea to separate state manipulation in one isolated place under control of some FSM with explicit rules of allowed and denied transitions. If I am switching from read monad to RWST monad, will my code be more buggy? Again, no. Monads don’t decrease buggy or global-state-manipulation problems automatically, they are workaround for specific Haskell problem. Other languages don’t need monads. I CAN have monads in Python, Javascript but I don’t need them. My point is: monads are not valuable byself: Ocaml has not any monads and all is fine </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif;color:#212121'>😊</span><span lang=EN-GB style='color:#212121'><o:p></o:p></span></p><p class=MsoNormal><span style='color:#212121'><o:p> </o:p></span></p><p class=MsoNormal><span lang=EN-GB style='color:#212121'>But it’s really very philosophical question, I think that monads are over-hyped actually. I stopped seeing the value of monads by themselves.<o:p></o:p></span></p><p class=MsoNormal><span style='color:#212121'><o:p> </o:p></span></p></div><div><ul style='margin-top:0cm' type=disc><li class=MsoListParagraph style='margin-left:0cm;mso-list:l0 level1 lfo1'><span style='color:#212121'>Third, AFAIK CLR restrictions do not allow implementing things like Functor, Monad, etc. in F# directly because they can't support HKT. So they workaround the problem.</span></li></ul></div><div><p class=MsoNormal><span style='color:#212121'><o:p> </o:p></span></p><p class=MsoNormal><span style='color:#212121'><a href="https://fsprojects.github.io/FSharpPlus/abstractions.html">https://fsprojects.github.io/FSharpPlus/abstractions.html</a></span><span lang=EN-GB style='color:#212121'> (btw, you can see that monad is monoid here </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif;color:#212121'>😉</span><span lang=EN-GB style='color:#212121'>)</span><span style='color:#212121'><o:p></o:p></span></p><p class=MsoNormal><span style='color:#212121'><o:p> </o:p></span></p><ul style='margin-top:0cm' type=disc><li class=MsoListParagraph style='margin-left:0cm;mso-list:l0 level1 lfo1'><span style='color:#212121'>But again, F# cannot be expressive enough: no HKT, no ability to express constraints, no ability to track effects...</span></li></ul></div></div></div><div><div><div><p class=MsoNormal><span lang=EN-GB><o:p> </o:p></span></p><p class=MsoNormal><span lang=EN-GB>If F# has monads (you call “monads” to computational expressions), then it CAN...<o:p></o:p></span></p><p class=MsoNormal><span lang=EN-GB>About HKT: yes, that’s true. But may be, it’s not so big problem? May be you can write effective, good and expressive code without them? Otherwise, we should agree that all languages without HKT are not expressive...</span></p></div></div></div><div><div><div><p class=MsoNormal><span style='color:#212121'><o:p> </o:p></span></p></div></div></div><div><div><div><ul style='margin-top:0cm' type=disc><li class=MsoListParagraph style='margin-left:0cm;mso-list:l0 level1 lfo1'><span style='color:#212121'>Really? You keep mentioning F#, and I struggle with it right now _because_ of such limitations. There are no meaningful ways abstract over generics, it is impossible to reason about functions' behaviours from their type signatures (because side effects can happen anywhere), it has Option, but you still can get Null, you can't have constraints, etc., etc. It is sooooo muuuuch mooore limited.</span></li></ul></div></div></div><div><div><div><p class=MsoNormal><o:p> </o:p></p><p class=MsoNormal><span lang=EN-GB>IMHO fear of “side effects can happen anywhere” becomes traditional thesis. And what is the problem if I add “print” in some function?! </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😊</span><span lang=EN-GB> Again, substitution of concepts, of monad’s motivations. Haskell compiler can not transform code with side-effects in effective way, and I must isolate all side-effects, mark such functions, but this is the problem of Haskell compiler, not mine. Why programmer should help compiler?! You can look at MLTon compiler, or OCaml one. IMHO they are good and work fine with side-effects; programs WITH side-effects under RWST or State or without those monads in ML are equal: if I port 101 ML functions with side-effects to Haskell, then I will add monad and will have 101 functions with the same side-effects, but now under monad. I can propagate my monad anywhere </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😊</span><span lang=EN-GB> All my functions can be under RWST or State. Again, this problem should be solved in other way, not by wrapping the same actions in some wrapper-type (monad). A funny consequence of this, now my program become deep nested lambdas. Compiler should try to “flat” some of them, but I am not competent how Haskell good in it. Anyway, performance will be worse than in ML version. But focus here is a mark-with-monad-type, not the avoid side-effects. And it’s needed for compiler, not for me. May be I’m not clean, may be it is heavy to accept to the people hypnotized by magic invocations about monads power, may be I don’t understand something </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😊</span><span lang=EN-GB><o:p></o:p></span></p><p class=MsoNormal><o:p> </o:p></p></div></div></div><div><div><div><ul style='margin-top:0cm' type=disc><li class=MsoListParagraph style='margin-left:0cm;mso-list:l0 level1 lfo1'><span style='color:#212121'>No, you can't. </span></li></ul><p class=MsoNormal><o:p> </o:p></p></div></div></div><div><div><div><p class=MsoNormal><span lang=EN-GB>Something like this: </span><span lang=EN-GB style='font-family:Consolas'>user?.Phone?.Company?.Name??"missing";</span><span lang=EN-GB> ?<o:p></o:p></span></p><p class=MsoNormal><o:p> </o:p></p><p class=MsoNormal><span lang=EN-GB>(do<o:p></o:p></span></p><p class=MsoNormal><span lang=EN-GB> u <- mbUser<o:p></o:p></span></p><p class=MsoNormal><span lang=EN-GB> ph <- phoneOf u<o:p></o:p></span></p><p class=MsoNormal><span lang=EN-GB> ...) <|> pure “missing”<o:p></o:p></span></p><p class=MsoNormal><o:p> </o:p></p></div></div></div><div><div><div><ul style='margin-top:0cm' type=disc><li class=MsoListParagraph style='margin-left:0cm;mso-list:l0 level1 lfo1'><span style='color:#212121'>OCaml exists for 22 years now, doing well and solves problems it has been designed for very well. So _already_ more than twice compare to your prediction.</span></li></ul></div></div></div><div><div><div><p class=MsoNormal><span lang=EN-GB><o:p> </o:p></span></p><p class=MsoNormal><span lang=EN-GB>It’s Ocaml. It follows to the golden middle, to avoid danger corner </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😉</span></p><p class=MsoNormal><o:p> </o:p></p></div><div><ul style='margin-top:0cm' type=disc><li class=MsoListParagraph style='margin-left:0cm;mso-list:l0 level1 lfo1'>fields are not starting with “_” prefix, so I need to create lenses explicitly</li></ul></div></div></div><div><div><div><ul style='margin-top:0cm' type=disc><li class=MsoListParagraph style='margin-left:0cm;mso-list:l0 level1 lfo1'>No you don't. You don't have to have "_" prefix to generate a lense. You have total control here. </li></ul></div></div></div><div><div><div><p class=MsoNormal><o:p> </o:p></p><p class=MsoNormal><span lang=EN-GB>Hmm, may be I’m not right. I’m using microlenses and call `makeLensesFor`...</span></p><p class=MsoNormal><o:p> </o:p></p></div></div></div><div><div><div><ul style='margin-top:0cm' type=disc><li class=MsoListParagraph style='margin-left:0cm;mso-list:l0 level1 lfo1'>Can you define "business value" please? You mention it for a couple of times, so I am puzzled. Otherwise, it reminds me of <a href="https://twitter.com/newhoggy/status/999930802589724672" target="_blank">https://twitter.com/newhoggy/status/999930802589724672</a></li></ul></div></div></div><div><div><div><ul style='margin-top:0cm' type=disc><li class=MsoListParagraph style='margin-left:0cm;mso-list:l0 level1 lfo1'>For Haskell programmers, Java solves non-existing problems all the time :) Every single time you see on twitter or here something like "I replaced hundreds of lines of Java code with a single 'traverse'" you get the proof. And it happens so often.</li></ul></div></div></div><div><div><div><p class=MsoNormal><span lang=EN-GB><o:p> </o:p></span></p><p class=MsoNormal><span lang=EN-GB>It involves a long talk </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😉</span><span lang=EN-GB> Business value - I’ll illustrate it, imagine a code:<o:p></o:p></span></p><p class=MsoNormal><span lang=EN-GB><o:p> </o:p></span></p><p class=MsoNormal style='margin-left:36.0pt'><span lang=EN-GB style='font-family:Consolas'>.... lift .... – <i>NO business value in lift! It’s infrastructure code<o:p></o:p></i></span></p><p class=MsoNormal style='margin-left:36.0pt'><span lang=EN-GB style='font-family:Consolas'>m <- loadModel “mymodel.bin” – <i>there is business value<o:p></o:p></i></span></p><p class=MsoNormal style='margin-left:36.0pt'><span lang=EN-GB style='font-family:Consolas'>checkModel m rules – <i>there is business value too<o:p></o:p></i></span></p><p class=MsoNormal><span lang=EN-GB><o:p> </o:p></span></p><p class=MsoNormal><span lang=EN-GB>So, I can mark infrastructure code with red color, business code with green and to calculate ratio. And to talk about “usefulness/effectivity” of language. How many infrastructure noise have the language (Java, btw, IMHO will have bad ratio too). I have a tons of types, JSON to/from instances, - I repeat models which are coded in external 3<sup>rd</sup> part services. But F# team thinks like me: it’s not enterprise way to do things in such manner and they introduced types providers – it’s only small example. In Haskell I wrote a lot of infrastructure code, different instances, etc, etc. But other languages are more concentrated on business value, on domain, on business logic. I though about DSLs, but DSLs can be antipattern and to lead to other problems...<o:p></o:p></span></p><p class=MsoNormal><o:p> </o:p></p></div><div><ul style='margin-top:0cm' type=disc><li class=MsoListParagraph style='margin-left:0cm;mso-list:l0 level1 lfo1'><span style='color:#212121'>Haskell code needs help from IDE, types hints, etc. </span></li><li class=MsoListParagraph style='margin-left:0cm;mso-list:l0 level1 lfo1'><span style='color:#212121'>Types are written and read by programmers. Java is impossible without IDE. What is the point here?</span></li></ul></div></div></div><div><div><div><p class=MsoNormal><o:p> </o:p></p><p class=MsoNormal><span lang=EN-GB>Usually it’s difficult to understand for programmers. Most say: Perl looks like sh*t. Just look at these %, $, etc. And they don’t understand simple thesis: language is about humans, about linguistic, not about computation. Language should not be oriented to compiler or to its computational model, how will you like to work with bytes and words only in C++? So, we have “a”, “the” in English, we have “%”, “$” in Perl. And I don’t know exact object “type” but I can imagine its nature, it’s scalar, vector, etc. In Haskell I can skip most signatures and such code is not readable, I need Intero help to check some types. It’s very bad situation. It’s not 100% true for Java because you will have signatures in Java, you can not skip them, right? And if I add operators noise also (when I have not idea what does this ASCII-art do), the code becomes IDE-centric.</span></p></div></div></div><div><div><div><p class=MsoNormal><o:p> </o:p></p></div></div></div><div><div><div><ul style='margin-top:0cm' type=disc><li class=MsoListParagraph style='margin-left:0cm;mso-list:l0 level1 lfo1'><span style='color:#212121'>Better for whom? Definitely NOT better for me and my team using Haskell commercially. Again, to effectively meet requirements, functional and non-functional, we don't want just a mediocre compromise thing. I gave you an example with parsers already: different parsers have different tradeoffs. It is often a GOOD thing that there are many different libraries doing the same thing differently. </span></li></ul></div></div></div><div><div><div><p class=MsoNormal><o:p> </o:p></p><p class=MsoNormal><span lang=EN-GB>Hm, if I have several libraries which are doing similar things (only due to dependencies), then I have: 1) big Haskell installation (1Gb?) 2) slow compilation 3) big binaries, etc. I understand, you have freedom of choice. But let’s look to IT: C++ turned to one library (imported some Boost solutions, etc, etc), the same R7RS, D with its Phobos, Ocaml has batteries from Jane str., Python </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😊</span><span lang=EN-GB> IMHO its general trend. Let’s imagine: project with 2, 3 parsers libraries, conduit and pipes, etc, due to dependencies. So, IMHO my point is not so strange or weird </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😉</span><span lang=EN-GB> I’m talking about drop off those libraries (parsers, etc), but about creating of one solid library which components will depends only on it. Other alternatives will be somewhere in repos, who want, can use them without any problems. Something like Qt, Boost, Gtk, etc.</span></p><p class=MsoNormal><o:p> </o:p></p><p class=MsoNormal><span lang=EN-GB>Let me be more precise, I’m comfort with Haskell at whole, but 1) I discussed Haskell with other people 2) I read opinion of other people in industry 2) I’m programmer since 97 and I have critical kind of the mind, so all of these allows me also to look from another POV. And I have been see how it’s similar to the fate of other languages which had good elegant ideas, they followed to one concept, abstraction only. This is the way to be marginalized, what happens with a lot of them. Actually, Haskell is already marginal: you can check how many programmers use it in the world, in most statistics it will not exist even. OK, I’m geek, in real life too, but IT industry is not a geek </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😊</span><span lang=EN-GB><o:p></o:p></span></p><p class=MsoNormal><o:p> </o:p></p></div></div></div><div><div><div><p class=MsoNormal><span lang=EN-GB>/Best regards</span></p><p class=MsoNormal><o:p> </o:p></p><div><div><p class=MsoNormal>On Sun, Jul 15, 2018 at 1:28 AM Paul <<a href="mailto:aquagnu@gmail.com" target="_blank">aquagnu@gmail.com</a>> wrote:</p></div><blockquote style='border:none;border-left:solid #CCCCCC 1.0pt;padding:0cm 0cm 0cm 6.0pt;margin-left:4.8pt;margin-right:0cm'><div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB>Hello Alex!</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB> </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB>> </span>A small disclaimer: none of the members of our team has an academic background. We all have different backgrounds: C#, Java, Ruby, Python, C, even Perl if I am not mistaken. Yet we ended up with FP first, and then with Haskell.</p><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB>> </span>We have switched to Haskell from Scala, which _is_ a multi-paradigm language borrowing bits and pieces from other languages/paradigms and mixing them together. It is an enormously hard work to do it and for that, I very much respect </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'> </p></div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB>Oh, my 1<sup>st</sup> question will be: did you try Eta, Frege? May be I’m wrong but Eta should support Haskell libraries as well as Java ones? They allow you to use libraries from the both world...</span></p><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB>> </span>As a result, the language becomes overly complicated and less useful.</p></div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB> </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB>Yes, this is another side. You know, anything has several sides: good and bad...</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'> </p></div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB>> </span>Your joke about how Haskell has been made misses one point: it was initially designed as a lazy language (at least as far as I know). Many features that Haskell has now are there because of laziness: if you want to be lazy, then you have to be pure, you have to sequence your effects, etc.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB>True. Laziness makes Haskell unique. I think Haskell makes laziness so popular in modern languages although it was known long ago (as data in “infinite streams”, etc). I think, Miranda was lazy, so Haskell is lazy too </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😊</span><span lang=EN-GB> And IMHO there was some lazy dialect of ML (may be, I’m not right).</span></p></div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'> </p></div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB>> </span>"Let's defer lambda, name it IO and let's call it Monad" - this bit isn't even funny. Monad isn't IO. IO happens to be a monad (as many things do, List as an example), but monad isn't IO and has nothing to do with IO. A horse is classified as Mammal, but Mammal doesn't mean horse _at all_.</p></div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB>Sure. I mean, the need of side-effects (and firstly I/O) led to the monads.</span></p></div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'> </p></div><div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB style='color:#212121'>> </span><span style='color:#212121'>In a context of a lazy language, you need to sequence your effects (including side effects), that's the first point. The second is that instead of disappearing from Haskell, monads (and other concepts) are making their way to other languages. Scala has them, F# has them, even C# has them (however indirectly). Try to take away List Monad from C# developers and they'll kill you ;)</span></p></div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span style='color:#212121'> </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB style='color:#212121'>Better IMHO to have less infrastructure code. Better is to hide all “machinery” in compiler.</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB style='color:#212121'> </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB style='color:#212121'>My point was that monads are workaround of Haskell problem, this was historically reason of their appearance. And if I have not such limitation in my language I don’t need any monads. What are the monad benefits in ML, for example? They are using in F#, but 1) comp. expressions are not monads but step forward, “monads++” and 2) they play different role in F#: simplifying of the code. And you <b>can</b> avoid them in all languages except Haskell. For example, Prolog can be “pure” and to do I/O without monads, also Clean can as well as F#. Monads have pros, sure, but they are not composable and workaround leads to another workaround – transformers. I’m not unique in my opinion: <a href="https://www.youtube.com/watch?v=rvRD_LRaiRs" target="_blank">https://www.youtube.com/watch?v=rvRD_LRaiRs</a> All of this looks like overengineering due to mentioned limitation. No such one in ML, F#. D has keyword “pure”, and didn’t introduce monads. Performance is very important feature of the language, that limitation is the reason #1 why Haskell has bad and unpredictable performance. “do”-block is not the same as “flat” block of C# statements and its performance is not the same. I can achieve Maybe effect with nullable+exceptions or ?-family operators, List with permutations/LINQ, guard with if+break/continue and to do it without sacrificing performance.. ListT/conduits – are just generators/enumerators. Benefit of monads IMHO is small, they are workaround of Haskell problem and are not needed in other languages. Sure, there are monads in Ocaml, Javascript, Python (as experimental libraries), but the reason is hype. Nobody will remember them after 5-10 years... </span></p></div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB>Actually this is very-very subjective IMHHHHO </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😊</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'> </p></div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB style='color:#212121'>></span><span style='color:#212121'> Lenses and generic lenses help, so be it. But I don't think that anything prevents Haskell from having it, and I don't think that Haskell as a language needs a dramatic change as you depict to make it happen. Just a feature.</span></p></div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB>When I have legacy code, there are a lot of types which fields are not starting with “_” prefix, so I need to create lenses explicitly... “Infrastructure” code. What is the business value of such code: nothing. For non-Haskell programmer it looks like you try to solve non-existing problem </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😊</span><span lang=EN-GB> (<i>very-very provocative point: all Haskell solutions looks very overengineering. The reason is: lambda-abstraction-only. When you try to build something big from little pieces then the process will be very overengineering. Imagine that the pyramids are built of small bricks</i>).</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'> </p></div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB style='color:#212121'>> </span><span style='color:#212121'>I don't agree that operators are noise. You certainly can write Haskell almost without operators if you wish.</span></p></div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB style='color:#212121'> </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB style='color:#212121'>Here I’m agree with D. Knuth ideas of literature programming: if code can not be easy read and understand on the hard-copy then used language is not fine. Haskell code needs help from IDE, types hints, etc. And I often meet a case when somebody does not understand what monads are in “do” blocks. Also there are a lot of operators in different libraries and no way to know what some operator means (different libraries, even different versions have own set of operators). </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB style='color:#212121'> </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB style='color:#212121'>> </span><span style='color:#212121'>As for extensions, I think that many more should be just switched on by default.</span></p></div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB> </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB>+1</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'> </p></div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB style='color:#212121'>> </span><span style='color:#212121'>You mean that conversion should happen implicitly? Thank you, but no, thank you. This is a source of problems in many languages, and it is such a great thing that Haskell doesn't coerce types implicitly. </span></p></div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB> </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB>No... Actually, I have not idea what is better. Currently there are a lot of conversions. Some libraries functions expect String, another - Text, also ByteString, lazy/strict, the same with the numbers (word/int/integer). So, conversions happen often.</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'> </p></div><div><p class=MsoNormal style='mso-margin-top-alt:auto;margin-bottom:12.0pt'><span lang=EN-GB style='color:#212121'>></span><span lang=EN-GB style='color:#212121'> </span><span style='color:#212121'>I don't understand this "no business value" statement. Value for which business? What does it mean "check types, no business value"? </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB style='color:#212121'>There are libraries which nothing do in run-time. Only types playing. Only abstractions over types. And somebody says: oh man, see how many libraries has Haskell. But you can compare libraries of Haskell, Java, C#, Javascript, Perl, Python </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif;color:#212121'>😊</span><span lang=EN-GB style='color:#212121'> All libraries of Java, Python... have business value. Real-world functionality. Not abstract play with types. But more important point is a case with installed Agda </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif;color:#212121'>😊</span><span lang=EN-GB style='color:#212121'> or alternative libraries which does the same/similar things. The reason is important: Haskell moves a lot of functionality to libraries which is not good design IMHO. This is the root of the problem. Better is to have one good solid library bundled with GHC itself (“batteries included”) and only specific things will live in libraries and frameworks. Monads and monads transformers are central thing in Haskell. They a located in libraries. There is standard parser combinators in GHC itself, but you will have in the same project another one (or more than 1!). Etc, etc...</span></p></div></div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB>Also installed GHC... Why is it so big!? IMHO it’s time to clear ecosystem, to reduce it to “batteries” </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😊</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'> </p></div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB style='color:#212121'>> </span><span style='color:#212121'>And then it falls into a famous joke: "The problem with Open Source Software is YOU because YOU are not contributing" :) Meaning that if we want more good libs then we should write more good libs :)</span></p><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'><span lang=EN-GB>Absolutely true </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😊</span></p></div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'> </p><div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto'>On Sat, Jul 14, 2018 at 5:05 PM Paul <<a href="mailto:aquagnu@gmail.com" target="_blank">aquagnu@gmail.com</a>> wrote:</p></div><blockquote style='border:none;border-left:solid #CCCCCC 1.0pt;padding:0cm 0cm 0cm 6.0pt;margin-left:4.8pt;margin-top:5.0pt;margin-right:0cm;margin-bottom:5.0pt'><div><div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB>I understand that my points are disputable, sure, example, multi-pardigm Oz – dead </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😊</span><span lang=EN-GB> Any rule has exceptions. But my point was that people don’t like elegant and one-abstraction languages. It’s my observation. For me, Smalltalk was good language (mostly dead, except Pharo, which looks cool). Forth – high-level “stack-around-assembler”, mostly dead (Factor looks abandoned, only 8<sup>th</sup> looks super cool, but it’s not free). What else? Lisp? OK, there are SBCL, Clojure, Racket... But you don’t find even Clojure in languages trends usually. APL, J – super cool! Seems dead (I don’t know what happens with K). ML, SML? By the way, Haskell role was to kill SML community, sure it is sad to acknowledge it, but it’s 100% true...</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB> </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB>Haskell try to be minimalistic and IMHO this can lead to death. Joachim, I’m not talking “it’s good/it’s bad”, “multiparadigm is good” or else... I don’t know what is right. It’s my observations only. Looks like it can happen.</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB>If we will look to Haskell history then we see strange curve. I’ll try to describe it with humour, so, please, don;t take it seriously </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😊</span><span lang=EN-GB> </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>Let’s be pure lambda fanatics!</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>Is it possible to create a big application?</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>Is it possible to compile and optimize it?!</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>Let’s try...</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>Wow, it’s possible!!! (sure, it’s possible, Lisp did it long-long ago).</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>Looks like puzzle, can be used to write a lot of articles (there were articles about combinators, Jay/Cat/Scheme, etc, now there are a lot of Haskell articles – big interesting in academia. But IMHO academia interest to language can kill it too: Clean, Strongtalk, etc)</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>Stop! How to do I/O? Real programming?!!</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>Ohh, if we will wrap it in lambda and defer it to top level (main::IO ()), it will have I/O type (wrapper is hidden in type)</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>Let’s call it... Monad!!</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>Wow, cool! Works! Anybody should use monads! Does not your language have monads? Then we fly to you! (everybody forgot that monads are workaround of Haskell limitation and are not needed in another languages. Also they lead to low-performance code)</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>But how to compose them???!?!</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>We will wrap/unwrap, wrap/unwrap.. Let’s call it... transformers!!! “Monad transformers” – sounds super cool. Your language does not have “lift” operation, right? Ugh...</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>How to access records fields... How... That’s a question. ‘.’ - no! ‘#’ - no! Eureka! We will add several language extensions and voila!</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>To be continued... </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😊</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB> </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB>I love Haskell but I think such curve is absolutely impossible in commercial language. With IT managers </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😊</span><span lang=EN-GB> To solve problem in a way when solution leads to another problem which needs new solution again and reason is only to keep lambda-abstraction-only (OK, Vanessa, backpacks also </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😉</span><span lang=EN-GB>) Can you imagine that all cars will have red color? Or any food will be sweet? It’s not technical question, but psychological and linguistic. Why native languages are not so limited? They even borrow words and forms from another one </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😊</span><span lang=EN-GB> </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB> </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB>Haskell’s core team knows how better then me, and I respect a lot of Haskell users, most of them <u>helped me A LOT</u> (!!!). It’s not opinion even, because I don’t know what is a right way. Let’s call it observation and feeling of the future.</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB> </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB>I feel: Haskell has 3 cases: 1) to die 2) to change itself 3) to fork to another language</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB>How I see commercial successful Haskell-like language:</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>No monads, no transformers</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>There are dependent types, linear types</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>There are other evaluation models/abstractions (not only lambda)</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>Special syntax for records fields, etc</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>Less operators noise, language extensions (but it’s very disputable)</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>Solve problems with numerous from/to conversions (strings, etc)</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>Solve problems with libraries</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB>Last point needs explanation:</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>There is a lot of libraries written to check some type concepts only, no any business value. Also there are a lot of libraries written by students while they are learning Haskell: mostly without any business value/abandoned</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>There is situation when you have alternative libraries in one project due to dependencies (but should be one only, not both!)</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'><span style='font-size:10.0pt;font-family:Symbol'>·</span><span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>Strange dependencies: I have installed Agda even! Why???!</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB>IMHO problems with libraries and lambda-only-abstraction lead to super slow compilation, big and complex compiler.</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB>So, currently I see (again, it’s my observation only) 2 big “camps”:</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'>1.<span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>Academia, which has own interests, for example, to keep Haskell minimalistic (one-only-abstraction). Trade-off only was to add language extensions but they fragmentizes the language</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:45.6pt'>2.<span style='font-size:7.0pt;font-family:"Times New Roman",serif'> </span><span lang=EN-GB>Practical programmers, which interests are different from 1<sup>st</sup> “camp”</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB>Another my observation is: a lot of peoples tried Haskell and switched to another languages (C#, F#, etc) because they cannot use it for big enterprise projects (Haskell becomes hobby for small experiments or is dropped off).</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB> </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB>Joachim, I’m absolutely agreed that a big company can solve a lot of these problems. But some of them have already own languages (you can compare measure units in Haskell and in F#, what looks better...).</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB> </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB>When I said about killer app, I mean: devs like Ruby not due to syntax but RoR. The same Python: sure, Python syntax is very good, but without Zope, Django, TurboGears, SQLAlchemy, Twisted, Tornado, Cheetah, Jinja, etc – nobody will use Python. Sure, there are exceptions: Delphi, CBuilder, for example. But this is bad karma of Borland </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😊</span><span lang=EN-GB> They had a lot of compilers (pascal, prolog, c/c++, etc), but... On the other hand after reincarnation we have C# </span><span lang=EN-GB style='font-family:"Segoe UI Emoji",sans-serif'>😊</span><span lang=EN-GB> Actually all these are only observations: nobody knows the future.</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB> </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB> </span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><span lang=EN-GB>/Best regards, Paul</span></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><div style='border:none;border-top:solid #E1E1E1 1.0pt;padding:3.0pt 0cm 0cm 0cm'><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><b>From: </b><a href="mailto:jo@durchholz.org" target="_blank">Joachim Durchholz</a><br><b>Sent: </b>13 июля 2018 г. 21:49<br><b>To: </b><a href="mailto:haskell-cafe@haskell.org" target="_blank">haskell-cafe@haskell.org</a><br><b>Subject: </b>Re: [Haskell-cafe] Investing in languages (Was: What is yourfavourite Haskell "aha" moment?)</p></div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>Am 13.07.2018 um 09:38 schrieb PY:</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> 1. Haskell limits itself to lambda-only. Example, instead to add other </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> abstractions and to become modern MULTI-paradigm languages,</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>"modern"?</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>That's not an interesting property.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>"maintainable", "expressive" - THESE are interesting. Multi-paradigm can </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>help, but if overdone can hinder it - the earliest multi-paradigm </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>language I'm aware of was PL/I, and that was a royal mess I hear.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> So, point #1 is limitation in </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> abstraction: monads, transformers, anything - is function. It's not </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> good.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>Actually limiting yourself to a single abstraciton tool can be good. </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>This simplifies semantics and makes it easier to build stuff on top of it.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>Not that I'm saying that this is necessarily the best thing.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> There were such languages already: Forth, Joy/Cat, APL/J/K... Most of</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> them look dead.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>Which proves nothing, because many multi-paradigm languages look dead, too.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> When you try to be elegant, your product (language) died.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>Proven by Lisp... er, disproven.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> This is not my opinion, this is only my observation. People like </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> diversity and variety: in food, in programming languages, in relations, </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> anywhere :)</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>Not in programming languages.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>Actually multi-paradigm is usually a bad idea. It needs to be done in an </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>excellent fashion to create something even remotely usable, while a </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>single-paradigm language is much easier to do well.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>And in practice, bad language design has much nastier consequences than </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>leaving out some desirable feature.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> 2. When language has killer app and killer framework, IMHO it has more </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> chances. But if it has _killer ideas_ only... So, those ideas will be </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> re-implemented in other languages and frameworks but with more simple </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> and typical syntax :)</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>"Typical" is in the eye of the beholder, so that's another non-argument.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> It's difficult to compete with product, </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> framework, big library, but it's easy to compete with ideas. It's an </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> observation too :-)</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>Sure, but Haskell has product, framework, big library.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>What's missing is commitment by a big company, that's all. Imagine </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>Google adopting Haskell, committing to building libraries and looking </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>for Haskell programmers in the streets - all of a sudden, Haskell is </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>going to be the talk of the day. (Replace "Google" with whatever </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>big-name company with deep pockets: Facebook, MS, IBM, you name it.)</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> language itself is not argument for me.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>You are arguing an awful lot about missing language features </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>("multi-paradigm") to credibly make that statement.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> Argument for me (I </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> am usual developer) are killer apps/frameworks/libraries/ecosystem/etc. </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> Currently Haskell has stack only - it's very good, but most languages </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> has similar tools (not all have LTS analogue, but big frameworks are the </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>> same).</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>Yeah, a good library ecosystem is very important, and from the reports I </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>see on this list it's not really good enough.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>The other issue is that Haskell's extensions make it more difficult to </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>have library code interoperate. Though that's a trade-off: The freedom </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>to add language features vs. full interoperability. Java opted for the </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>other opposite: 100% code interoperability at the cost of a really </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>annoying language evolution process, and that gave it a huge library </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>ecosystem.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>But... I'm not going to make the Haskell developers' decisions. If they </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>don't feel comfortable with reversing the whole culture and make </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>interoperability trump everything else, then I'm not going to blame </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>them. I'm not even going to predict anything about Haskell's future, </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>because my glass orb is out for repairs and I cannot currently predict </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>the future.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>Regards,</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>Jo</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>_______________________________________________</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>Haskell-Cafe mailing list</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>To (un)subscribe, modify options or view archives go to:</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'><a href="http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe" target="_blank">http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe</a></p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'>Only members subscribed via the mailman list are allowed to post.</p><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:9.6pt'> </p></div></div></blockquote></div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:4.8pt'>_______________________________________________<br>Haskell-Cafe mailing list<br>To (un)subscribe, modify options or view archives go to:<br><a href="http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe" target="_blank">http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe</a><br>Only members subscribed via the mailman list are allowed to post.</p></div></div></blockquote></div></div></div></div></div><p class=MsoNormal style='mso-margin-top-alt:auto;mso-margin-bottom-alt:auto;margin-left:4.8pt'> </p><p class=MsoNormal><o:p> </o:p></p></div></body></html>