1. 8

    As someone who is a total stranger to Elm, its dev and its community, but was interested for a long time in learning this language, I wonder if this opinion reflects the feeling of the “great number” or not.

    1. 20

      I have to say that I personally can very much see where he’s coming from. GitHub contributions are dealt with in a very frustrating way (IMO they’d do better not allowing issues and PRs at all). There’s a bit of a religious vibe to the community; the inner circle knows what’s good for you.

      That said, they may very well be successful with their approach by a number of metrics. Does it hurt to loose a few technically minded independent thinkers if the language becomes more accessible to beginners?

      Where I see the largest dissonance is in how Elm is marketed: If the language is sold as competitive to established frameworks, you’re asking people to invest in this technology. Then turning around and saying your native modules are gone and you shouldn’t complain because no one said the language was ready feels a bit wrong.

      1. 7

        Yeah when I look at the home page, it does seem like it is over-marketed: http://elm-lang.org/

        At the very least, the FAQ should probably contain a disclaimer about breaking changes: http://faq.elm-community.org/

        Ctrl-F “compatibility” doesn’t find anything.

        It’s perhaps true that pre-1.0 software is free to break, but it seems like there is a huge misunderstanding in the community about compatibility. The version number doesn’t really mean much in my book – it’s more a matter of how many people actually rely on the software for production use, and how difficult their upgrade path is. (Python 3 flauted this, but it got by.)

        I think a lot of the conflict could be solved by making fewer promises and providing some straightforward, factual documentation with disclaimers.

        I watched the “What is Success?” talk a couple nights ago and it seemed like there is a lot of unnecessary conflict and pain in this project. It sounds like there is a lot to learn from Elm though – I have done some stuff with MUV and I like it a lot. (Although, while the types and purity probably help, but you can do this in any language.)

        1.  

          I watched the “What is Success?” talk a couple nights ago and it seemed like there is a lot of unnecessary conflict and pain in this project

          I watched the talk also, after another… Lobster(?)… Posted it in another thread. My biggest takeaway was that Evan really doesn’t want to deal with an online community. People at IRL meetups, yes. Students in college, yes. People/companies online trying to use the language? No. His leading example of online criticism he doesn’t want to deal with was literally “Elm is wrong” (he quoted without any context, which isn’t that helpful. But maybe that was all of it.)

          That’s fine. He’s the inventor of the language, and the lead engineer. He probably does have better things to do. But as an outsider it seems to me that someone has to engage more productively with the wider community. Our, just come out and say you don’t care what they think, you’ll get what you’re given, and you can use it if you choose. But either way communicate more clearly what’s going on, and what to expect.

      2. 13

        I’ve shipped multiple production applications in Elm and attempted to engage with the community and I can say that their characterization perfectly matches mine.

        Native modules being removed in particular has caused me to no longer use Elm in the future. I was always ok with dealing with any breakage a native module might cause every release, and I’m even ok with not allowing them to be published for external consumption, but to disallow them completely is unreasonable. I’m sure a number of people feel the same way as I do, but it feels impossible to provide meaningful feedback.

        1. 9

          I work for a company that began using Elm for all new projects about a year and a half ago. That stopped recently. There are several reasons that people stopped using Elm. Some simply don’t like the language. And others, like the author of this post, want to like the language but are put off by the culture. That includes me. This article closely resembles several conversations I’ve had at work in the past year.

        1. 4

          What a curious way to announce this much awaited new Elm release. Does anyone here know more about the ideas behind that? I’d have expected some kind of public beta and a proper release announcement…

          1. 4

            Yeah, it’s a bit…different, but it looks like picking and highlighting one feature is what was done for previous releases as well: http://elm-lang.org/blog

            1. 2

              Especially given the “is Elm dead?” questions that have been popping up in the past few months. I guess it’s better to be head-down working on the next release, but I think just a little more communication or visibility into the project might have helped alleviate some of the concerns.

              1. 3

                This topic was addressed by Evan (creator of Elm) in his recent talk at Elm Europe 2018 titled: “What is success?”

                1. 2

                  So I watched the video, and this is addressed around the 41 minute mark: “There’s pressure on me to be always be saying everything that’s going on with Elm development, and the trouble is that it’s not always very interesting… it’s like… ‘still working’”.

                  I think “still working” would have been better, though. I don’t think anyone expected weekly updates. Every 2 months updating the Github readme with “still working” would have been fine. And the fear that saying you’re working on X and then it doesn’t pan out, so better to not say anything at all, seems like the worse option.

                  I also think the talk is a little dismissive of Javascript, and the community. Sure, the number of packages is by no means the be-all of a good language ecosystem, but it says something about the platform and its viability. If nothing else, it means there are alternatives within the ecosystem. People have limited time, and very limited time to invest in learning brand new things, so they naturally look for some way to compare the opportunities they have. Is looking at numbers the ideal behaviour? Maybe not, but if I want to sell Elm to my boss and she asks me when the last release was and I say “18 months ago” and she asks if I know when the next one will be and I say “no”… that’s how languages don’t get adopted and ecosystems don’t grow.

                  As a complete outsider, but also as someone who wants Elm to succeed, I think community management is something they need to take really seriously. It seems like Evan really doesn’t want to do it, so fine, have someone else do it. You can dislike that there are persistent questions about the future of your project, but they’re best addressed at the time, not left unanswered.

                  1. 3

                    Personally, I’m not really convinced by those arguments.

                    I especially don’t understand why 18 months since last release, and no known date of new release, are arguments against adoption of the language. Take C or C++ — they rarely have new releases. Is this an argument against adoption? I don’t think so; actually, more like for adoption in my opinion! Slow pace of releases can mean that the languages are mature and stable. I’d be really surprised and annoyed by a boss who would think otherwise.

                    It now occurred to me, that maybe Lua is a good example of a language having a similar development mode as Elm. It’s also evolved behind super tightly closed doors. And new versions are usually dumped on the community out of the blue; though usually with public betas & RCs. But those are published only for fleshing out bugs; language design input is mostly not taken into account. AFAIK, the community is generally OK with this. And the language is totally used and relied upon in numerous niches in the industry (including a large one in game development)!

                    1. 5

                      “Elm” includes the language specification and the compiler.

                      The C language specification rarely has new releases, but the C compiler, gcc, has 4 releases per year. There would be major concern from the community and your boss if gcc activity was perceived as drying up.

                      1. 1

                        Ah; good one, never thought of it this way; big thanks for pointing this out to me!

                      2. 2

                        Take C or C++ — they rarely have new releases

                        C and C++ have been mature and in very wide use for decades, where Elm is a very young language - just a few years old. Same with Lua, it’s been in widespread use for, what, 10 years or more? I think that’s the difference. Elm is still much more of an unknown quantity.

                        Slow pace of releases can mean that the languages are mature and stable

                        Sure - when the language is mature and stable. I don’t think anyone would consider Elm to be that way: this new release, if I understand correctly, breaks every package out there until they’re upgraded by their maintainer.

                        1. 3

                          Personally, after some initial usage, I currently actually have a surprising impression of Elm being in fact mature. It kinda feels to me as an island of sanity and stability in the ocean of JS ecosystem… (Again, strictly personal opinion, please forgive me should you find this offensive.) I didn’t realize this sentiment so strongly until writing these words here, so I’m also sincerely curious if this could be a sign of me not knowing Elm well enough to stumble upon some warts? Hmh, and for a somewhat more colourful angle, you know what they say: old doesn’t necessarily mean mature, and converse ;P

                          And — by the way — notably, new releases of Lua actually do also infamously tend to break more or less every package out there :P Newbies tend to be aggravated by this, veterans AFAIU tend to accept it as a cost that enables major improvements to the language.

                          That said, I think I’m starting to grasp what you’re trying to tell me. Especially the phrase about “unknown quantity”. Still, I think it’s rare for a language to become “corporate grade non-risky”. But then, as much as, say C++ is a “known quantity”, to me it’s especially “known” for being… finicky

                  2. 2

                    Yeah the last release was in Nov 2016.

                    1. 1

                      The devs are active on https://discourse.elm-lang.org/, which might help people see the project activity.

                    2. 1

                      since they recently disallowed using javascript in elm packages, it only makes sense that they’d lead with what that had won them, i.e. function level dead code elimination.

                    1. 4

                      Interesting. There’s a JavaScript demo to play around with the syntax at https://eno-lang.org/demo/. Would be neat to get some kind of generic parse tree (JSON?) for an eno document.

                      I’m a bit unclear on what it means that “all whitespace is optional”, and how to deal with whitespace in values. It appears that leading and trailing whitespace in a field like

                      Greeting: Hello World
                      

                      is stripped. It seems that to encode leading whitespace, you need a block:

                      ---Greeting
                      Hello World
                      ---Greeting
                      

                      (This is relevant to me as this seems like a possible alternative to YAML that requires less painful indentation while offering raw multi-line blocks. I’m currently using YAML as a format for puzzles, but it’s not perfect, compare puzzle-draw.)

                      1. 3

                        For the generic JSON-like parse tree you can use https://eno-lang.org/javascript/#Section-raw, note however that this debug output tree only contains strings (the parser does not know about your types) and as most elements can be turned into arrays by repetition in eno, most elements are wrapped as such in the raw inspection format by default (here again the parser cannot know :)).

                        Regarding whitespace you are correct - leading and trailing whitespace is always stripped, except in blocks, where all whitespace is retained verbatim, and your usecase is exactly the thing this mechanism is designed for, would be happy to hear about your experience in case you do try eno to store your puzzles! (Also feel free to get in contact in case of questions or if anything in the documentation can be improved)

                        1. 3

                          Looks like line continuations or escaping might work for including whitespace: https://eno-lang.org/advanced/

                          1. 2

                            Leading and trailing whitespace removal also happens for line continuations (except for the space separator itself which is added in by the parser), escaping only exists for keys, no value in eno ever has to be escaped, that is one of the design principles in the language to keep non-technical users from running into unpredictable and for them often unsolvable behavior. :)

                            Thanks a lot for helping out! - I’ll take the fact that not everything is clear yet as a nudge for myself to improve documentation in the coming weeks and months! ;)

                        1. 1

                          Here’s their humans.txt: http://humanstxt.org/humans.txt

                          1. 2

                            Very helpful hands-on optimization exercise, thank you!

                            At one point, they switch from lists to vectors for a slow-down, then get to an overall improvement by refactoring to not use fixM hence avoid expensive equality checks. I’m curious what the effect of the latter refactoring would have been while staying with lists.

                            1. 3

                              The link is to a very useless spam quora question. The email provider does exist (see wikipedia: https://en.wikipedia.org/wiki/Tutanota), but there’s no indication it’s particularly a Gmail alternative rather than just another mail provider.

                              1. 2

                                The link provides a good rationale for how the company operates and what their goals are. Their product is open source, and can be self-hosted, which is quite a bit more than just being another email provider in my opinion.

                              1. 6

                                This would be more convincing with a bit more attention to detail with respect to the readability of the article. E.g., there’s a couple of missing spaces between words/sentences, and the <h3> are barely distinguishable from the rest of the text.

                                (And, yes, Medium…)

                                1. 0

                                  This is good to know, but having news of outages here is not going to increase the quality of Lobsters.

                                  1. 12

                                    I find this to be valuable information. I was not aware that by sharing source code on github/gitlab, I might be excluding people from the listed countries from accessing my code. Similarly, this seems to be relevant news for any lobste.rs users from those countries. (Or does lobste.rs not allow readers from Iran or Cuba itself?)

                                    Certainly labelling this as an “outage” is disingenuous.

                                    1. 12

                                      this isn’t about outages

                                      1. 14

                                        It three things:

                                        1. A business announcement saying they’ll get some benefits switching cloud providers. People change providers all the time for arbitrary reasons.

                                        2. A warning about a planned outage of some services during a maintenance window. These are common during big changes. Gitlab’s customers should be following their site for such information.

                                        3. A reminder some freedom/crypto-hating, police states might block some software (eg theirs). Like they always do.

                                        I agree with friendlysock. Just noise. This prior submission is an example for Gitlab of a write-up with more technical depth that teaches us stuff we might use. That kind of stuff is our differentiator here.

                                        1. 5

                                          If a service stops being available it’s an outage–whether due to legal reasons or not.

                                          If we had a submission here every time a law threatened a services availability we’d have no time for the sort of content that’s usually here.

                                          1. 9

                                            […] we’d have no time for the sort of content that’s usually here.

                                            I don’t know your perspective of lobste.rs’ typical content, but recently my usual experience here is that whenever I enter a comment thread for a topic that interests me, there is a comment by you claiming that this sort of content doesn’t belong on this site.

                                            1. 5

                                              We had a discussion to define what the site was about. There were a lot of opinions. I thought friendlysock had the best baseline here. As said in that comment, people wanting those kinds of articles and discussions have plenty of places to get them. Hacker News and Reddit often have the same ones. Lobsters can copycat them with all their strengths and weaknesses or have its own strengths and weaknesses.

                                              We often have more technical depth with low noise here than most other places I see. We occasionally get management, academic, or political stuff that’s actionable with detailed analyses, too. I say we stay on that instead of fluff that other sites have. Even if it’s important to you, it’s redundant: you can just get that stuff from places where it’s already at with Lobsters adding something different to your overall set of feeds.

                                              1. 3

                                                If you’d like to share with the rest of us in a top-level comment what you found interesting about this submission, I would hope it would generate some positive discussion.

                                                What did you find interesting about this topic?

                                              2. 3

                                                I think the two comments you made here would be better if you had combined them in to a single comment and spent more time describing your claim of this submission being off-topic. I’d also have welcomed you dwelling longer on the quality of the content that’s usually here.

                                            1. 2

                                              I’ve done a quite small (47 LOC) Haskell solution for this a couple of years ago. Turns out solving Sudokus is quite simple. Blogpost/Code. The basis is just going over the whole grid, pruning possibilities per field, filling in the ones with just one possible solution. Rinse and repeat until you’re done. Very fun exercise to learn a new language as well.

                                              1. 3

                                                Um, resolving single candidates is not enough to solve most Sudoku puzzles.

                                                1. 2

                                                  Yeah generally on “hard” boards you’ll have to randomly pick a value for a couple, then do a DFS on that choice and subsequent choices.

                                                  1. 2

                                                    Depends on the level of inference one is willing to implement.

                                                    Full inference for each row/column/square individually plus something called shaving/singleton arc consistency/several other names which means to do the hypothesis test for each square/value pair “If this square was assigned this value, would that lead to an inconsistency?” is enough to solve all 9x9 Sudokus without search empirically. For details, see Sudoku as a Constraint Problem by Helmut Simonis.

                                                    1. 1

                                                      That just sounds hugely frustrating. I usually just solve them by elimination, but I don’t really do super hard ones.

                                                1. 21

                                                  I detest paying for software except when it occupies certain specialized cases or represents something more akin to work of art, such as the video game Portal.

                                                  I detest this attitude. He probably also uses an ad blocker and complains about how companies sell his personal information. You can’t be an open source advocate if you detest supporting the engineers that build open source software.

                                                  But only when it’s on sale.

                                                  I’m literally disgusted.

                                                  1. 8

                                                    It’s reasonable to disagree with the quote about paying for software. But how on earth does this defense of the advertising industry come in?

                                                    Certainly it’s possible to be an open source advocate and use an ad blocker and oppose the selling of personal information.

                                                    1. 2

                                                      Certainly. Actually, I would describe myself in that way. But you can’t believe that, and also believe you’re entitled to free-as-in-beer software. Especially high quality “just works” software the author describes. It’s a contradiction.

                                                      Alternative revenue streams like advertising exist to power products people won’t pay for. I don’t know many software engineers that want to put advertising in their products, rather they have to in order to avoid losing money. That’s why I happily pay for quality software like Dash and Working Copy, and donate to open source projects.

                                                      1. 1

                                                        But you can’t believe that, and also believe you’re entitled to free-as-in-beer software.

                                                        I don’t get that sort of vibe from this article. He doesn’t seem to be entitled at all.

                                                    2. 4

                                                      “free as in free beer”!

                                                      1. 1

                                                        I can’t afford to have a different attitude.

                                                        1. 16

                                                          Meh, what’s a factor 10 when you’re still under a request per second? Does this actually matter?

                                                          I’m curious whether any attempt was made to contact the Bing team before the change & post.

                                                          1. 3

                                                            Seems very unnecessarily frequent. If you had multiple search engines checking in this frequently it’d add up quickly

                                                          1. 4

                                                            Wikipedia on ROP: https://en.wikipedia.org/wiki/Return-oriented_programming

                                                            Return-oriented programming (ROP) is a computer security exploit technique that allows an attacker to execute code in the presence of security defenses such as executable space protection and code signing.

                                                            1. 5

                                                              See Vala (programming language) on Wikipedia. It’s a language for GNOME that’s C#-like and compiles to C. I would like to recommend to the author to ask a native speaker to proof-read the book. It’s quite readable, but the lack of articles is a bit distracting (I know this is hard).

                                                              1. 2

                                                                Also worth noting is that it compiles to C with GObject at the center of it’s object system. It has it’s benefits like quite easy interfacing with dynamic languages, but for me GObject is too crazy. Maybe I’m prejudiced, but it’s like painfully manual C++ although more dynamic. At this point for me it would be better idea to just write in C++.

                                                                However Vala hides all this, so mostly one sees good parts.

                                                                1. 1

                                                                  Yes, but I don’t want to throw technical details at first without even writting a simple hello, world program.

                                                                  Yes. Hence I submitted link over here. Someone who has good experience with Vala can take a look.

                                                                1. 2

                                                                  Regarding the IDE side of things, it seems there would be some value to having the parser depend on the previous parse. E.g. if the user is editing in one “block”, cut that block out and parse it individually in some way, so unbalanced parentheses or string literals don’t affect the whole file.

                                                                  (Why is this tagged haskell?)

                                                                  1. 1

                                                                    I’ve seen parsers implemented as monoids, where you cut the source at semicolons or matched braces or whatever is your chosen chunk delimiter. Seems to work pretty well.

                                                                    While your suggestion of depending on previous successful parses sounds like a bunch of work, I can see where it would be very powerful. You could find where the previous source is the same and incrementally parse changes and that kind of thing.

                                                                    Also, I think it’s tagged haskell because the blog post uses Haskell syntax? Probably not enough reason for the tag though.

                                                                    1. 5

                                                                      This seems like a step in the right direction, with a more accessible user interface.

                                                                      What does “released” mean, though? How do I upgrade my existing nix install? nix-channel --update ; nix-env -i nix doesn’t get me 2.0.

                                                                      1. 4

                                                                        Did some more digging. I am on nixpkgs-unstable (not on NixOS though). But it seems nixpkgs-unstable didn’t get the 2.0-release of nix yet, either. There’s nixUnstable though, which is at version 2.0pre5968_a6c0b773: https://hydra.nixos.org/build/69873027.

                                                                        Digging further, it’s just not in nixpkgs yet: https://github.com/NixOS/nixpkgs/commits/master/pkgs/tools/package-management/nix. And the relevant PR for switching nixpkgs’s nix to 2.0: https://github.com/NixOS/nixpkgs/pull/34636

                                                                        (And as an aside, this kind of need to dig to figure out the answer to a pretty straightforward question is typical for my nix experience – it always ends up making sense in some way, but you need so much knowledge and have to dig so deep to find out how/what/why. git grep in a nixpkgs clone seems part of the required tool set for a nix user.)

                                                                        1. 1

                                                                          Yeah, I think there have been great strides on documentation over the past year, but there’s a long distance still to go.

                                                                        2. 2

                                                                          I’ll keep talking to myself here. Following a suggestion from the announcement post on news.ycombinator, I got the new nix:

                                                                          $ git clone https://github.com/nixos/nixpkgs
                                                                          $ cd nixpkgs
                                                                          $ git checkout origin/nix-2.0
                                                                          $ nix-env -i $(nix-build --no-out-link . -A nix)
                                                                          

                                                                          Which… doesn’t seem to know about nixpkgs? At least nix search doesn’t find anything. And nix log nixpkgs.hello doesn’t find nixpkgs.

                                                                          1. 1

                                                                            Hey, that was my suggestion, so I perhaps should also mention that nix log nixpkgs.hello depends on you having something like NIX_PATH=nixpkgs=/path/to/your/nixpkgs/checkout.

                                                                          2. 2

                                                                            Nix ≠ NixOS. But in NixOS, Nix 2.0 would be present in 18.03 release, which would be released in March this year. But you can also freely upgrade to their “unstable” channel (I forgot the proper name though) which has these all nice things with cutting edge versions available.

                                                                          1. 0

                                                                            Yet, this issue is still open? https://github.com/NixOS/nixpkgs/issues/18995

                                                                            1. 2

                                                                              This is a new release of nix the package manager, not nixpkgs the repository of packages. It doesn’t seem like that bug is a bug in the package managing part, or is it?

                                                                              1. 2

                                                                                I was responding to this question:

                                                                                have you ever used a Nix as a sole package/environment manager, or NixOS as a Linux distribution (production, desktop…)? Do you have any stories or opinions related to it?

                                                                                I stopped using nixpkg and went back to pkgsrc because of that particular issue.

                                                                            1. 4

                                                                              They should have used canonical S-expressions instead of JSON: they are simpler to parse & emit; they are better-suited to handing encryption; and they readily handle binary data.

                                                                              It’s a matter of taste, but I also think that they’re a lot more attractive:

                                                                              (request
                                                                               (using ietf.org/rfc/smap-core ietf.org/rfc/smap-mail)
                                                                               (method-calls
                                                                                (method1 ((arg1 arg1data) (arg2 (arg2data))) "#1")
                                                                                (method2 ((arg1 arg1data)) "#2")
                                                                                (method3 () "#3")))
                                                                              

                                                                              vs.:

                                                                              {
                                                                                "using": [ "ietf.org/rfc/jmap-core", "ietf.org/rfc/jmap-mail" ],
                                                                                "methodCalls": [
                                                                                  ["method1", {"arg1": "arg1data", "arg2": "arg2data"}, "#1"],
                                                                                  ["method2", {"arg1": "arg1data"}, "#2"],
                                                                                  ["method3", {}, "#3"]
                                                                                ]
                                                                              }
                                                                              
                                                                              1. 2

                                                                                Any particular reason not to go for ... (method1 (arg1data arg2data) "#1") ...?

                                                                                Then, the attractiveness thing sort of gets lost when you go for actual canonical S-expressions with binary data, doesn’t it? No more looking at the raw expressions in a text editor.

                                                                                And is JSON really that hard to parse?

                                                                                1. 1

                                                                                  Any particular reason not to go for ... (method1 (arg1data arg2data) "#1") ...?

                                                                                  I was just following the original style directly. Certainly a more common way to write that in a Lisp would be the way you indicated.

                                                                                  Then, the attractiveness thing sort of gets lost when you go for actual canonical S-expressions with binary data, doesn’t it? No more looking at the raw expressions in a text editor.

                                                                                  I dunno, this looks pretty good to me:

                                                                                  (cert
                                                                                       (issuer (hash sha1 |TLCgPLFlGTzgUbcaYLW8kGTEnUk=|))
                                                                                       (subject (hash sha1 |Ve1L/7MqiJcj+LSa/l10fl3tuTQ=|))
                                                                                       …
                                                                                       (not-before "1998-03-01_12:42:17")
                                                                                       (not-after "2012-01-01_00:00:00"))
                                                                                  

                                                                                  The only bits which are binary are the hashes, and the rest of the expression is fine. The whole thing can be edited in a text editor, if necessary.

                                                                                  And is JSON really that hard to parse?

                                                                                  No, not really — but it’s still more complex than S-expressions.