1. 1

    This graph is missing one of its bars (“Less than high school diploma”): https://taylor.fausak.me/2018/11/18/2018-state-of-haskell-survey-results/#question-100

    1. 1

      That’s intentional. Many of the graphs only show a subset of the possible answers in order to keep things legible. The full results are always included in the table below the chart. You can see exactly how this was done in this script.

      1. 2

        Seems rather arbitrary, at least for the specific graph I mentioned (It’s close in value to two other categories, both of which are shown). Doesn’t excluding arbitrary values without justification essentially render all these graphs meaningless?

        If I can’t look at a graph and learn something without first checking the graph against the data table to see what’s missing, then the graph is at best useless, at worst misleading.

    1. 4

      I am excited to announce the 2018 State of Haskell Survey! This is the second annual State of Haskell survey. I am happy to say that this year the survey is co-sponsored by Haskell Weekly and Haskell.org.

      The goal of the survey is to better understand what people think of the Haskell programming language, together with its ecosystem and community. Whether you have never used Haskell or you use it every day, we want to hear from you!

      The survey opens today, November 1st, and stays open for two weeks. It closes on November 15th.

      Please take a few minutes to fill out the survey! We want an accurate picture of the Haskell community, so please share this link to help us out: https://bit.ly/haskell2018. Thanks!

      1. 28

        That is a very reductionist view of what people use the web for. And I am saying this as someone who’s personal site pretty much matches everything prescribed except comments (which I still have).

        Btw, Medium, given as a positive example, is not in any way minimal and certainly not by metrics given in this article.

        1. 19

          Btw, Medium, given as a positive example, is not in any way minimal and certainly not by metrics given in this article.

          Chickenshit minimalism: https://medium.com/@mceglowski/chickenshit-minimalism-846fc1412524

          1. 13

            I wouldn’t say medium even gives the illusion of simplicity (For example, on the page you linked, try counting the visual elements that aren’t blog post). Medium seems to take a rather contrary approach to blogs, including all the random cruft you never even imagined existed, while leaving out the simple essentials like RSS feeds. I honestly have no idea how the author of the article came to suggest medium as an example of minimalism.

            1. 8

              Medium started with an illusion of simplicity and gradually got more and more complex.

              1. 3

                I agree with your overall point, but Medium does provide RSS feeds. They are linked in the <head> and always have the same URL structure. Any medium.com/@user has an RSS feed at medium.com/feed/@user. For Medium blogs hosted at custom URLs, the feed is available at /feed.

                I’m not affiliated with Medium. I have a lot of experience bugging webmasters of minimal websites to add feeds: https://github.com/issues?q=is:issue+author:tfausak+feed.

            2. 3

              That is a very reductionist view of what people use the web for.

              I wonder what Youtube, Google docs, Slack, and stuff would be in a minimal web.

              1. 19

                Useful.

                algernon hides

                1. 5

                  YouTube, while not as good as it could be, is pretty minimalist if you disable all the advertising.

                  I find google apps to be amazingly minimal, especially compared to Microsoft Office and LibreOffice.

                  Minimalist Slack has been around for decades, it’s called IRC.

                  1. 2

                    It is still super slow then! At some point I was able to disable JS, install the Firefox “html5-video-everywhere” extension and watch videos that way. That was awesome fast and minimal. Tried it again a few days ago, but didn’t seem to work anymore.

                    Edit: now I just “youtube-dl -f43 ” directly without going to YouTube and start watching immediately with VLC.

                    1. 2

                      The youtube interface might look minimalist, but under the hood, it is everything but. Besides, I shouldn’t have to go to great lengths to disable all the useless stuff on it. It shouldn’t be the consumer’s job to strip away all the crap.

                    2. 2

                      That seems to be of extreme bad faith though.

                      1. 11

                        In a minimal web, locally-running applications in browser sandboxes would be locally-running applications in non-browser sandboxes. There’s no particular reason any of these applications is in a browser at all, other than myopia.

                        1. 2

                          Distribution is dead-easy for websites. In theory, you have have non-browser-sandboxed apps with such easy distribution, but then what’s the point.

                          1. 3

                            Non-web-based locally-running client applications are also usually made downloadable via HTTP these days.

                            The point is that when an application is made with the appropriate tools for the job it’s doing, there’s less of a cognitive load on developers and less of a resource load on users. When you use a UI toolkit instead of creating a self-modifying rich text document, you have a lighter-weight, more reliable, more maintainable application.

                            1. 3

                              The power of “here’s a URL, you now have an app running without going through installation or whatnot” cannot be understated. I can give someone a copy of pseudo-Excel to edit a document we’re working together on, all through the magic of Google Sheet’s share links. Instantly

                              Granted, this is less of an advantage if you’re using something all the time, but without the web it would be harder to allow for multiple tools to co-exist in the same space. And am I supposed to have people download the Doodle application just to figure out when our group of 15 can go bowling?

                              1. 4

                                They are, in fact, downloading an application and running it locally.

                                That application can still be javascript; I just don’t see the point in making it perform DOM manipulation.

                                1. 3

                                  As one who knows JavaScript pretty well, I don’t see the point of writing it in JavaScript, however.

                                  1. 1

                                    A lot of newer devs have a (probably unfounded) fear of picking up a new language, and a lot of those devs have only been trained in a handful (including JS). Even if moving away from JS isn’t actually a big deal, JS (as distinct from the browser ecosystem, to which it isn’t really totally tied) is not fundamentally that much worse than any other scripting language – you can do whatever you do in JS in python or lua or perl or ruby and it’ll come out looking almost the same unless you go out of your way to use particular facilities.

                                    The thing that makes JS code look weird is all the markup manipulation, which looks strange in any language.

                                    1. 3

                                      JS (as distinct from the browser ecosystem, to which it isn’t really totally tied) is not fundamentally that much worse than any other scripting language

                                      (a == b) !== (a === b)

                                      but only some times…

                                      1. 3

                                        Javascript has gotchas, just like any other organic scripting languages. It’s less consistent than python and lua but probably has fewer of these than perl or php.

                                        (And, just take a look at c++ if you want a faceful of gotchas & inconsistencies!)

                                        Not to say that, from a language design perspective, we shouldn’t prize consistency. Just to say that javascript is well within the normal range of goofiness for popular languages, and probably above average if you weigh by popularity and include C, C++, FORTRAN, and COBOL (all of which see a lot of underreported development).

                                2. 1

                                  Web applications are expected to load progressively. And that because they are sandboxed, they are allowed to start instantly without asking you for permissions.

                                  The same could be true of sandboxed desktop applications that you could stream from a website straight into some sort of sandboxed local VM that isn’t the web. Click a link, and the application immediately starts running on your desktop.

                                3. 1

                                  I can’t argue with using the right tool for the job. People use Electron because there isn’t a flexible, good-looking, easy-to-use cross-platform UI kit. Damn the 500 mb of RAM usage for a chat app.

                                  1. 4

                                    There are several good-looking flexible easy to use cross-platform UI kits. GTK, WX, and QT come to mind.

                                    If you remove the ‘good-looking’ constraint, then you also get TK, which is substantially easier to use for certain problem sets, substantially smaller, and substantially more cross-platform (in that it will run on fringe or legacy platforms that are no longer or were never supported by GTK or QT).

                                    All of these have well-maintained bindings to all popular scripting languages.

                                    1. 1

                                      QT apps can look reasonably good. I think webapps can look better, but I haven’t done extensive QT customization.

                                      The bigger issue is 1) hiring - easier to get JS devs than QT devs 2) there’s little financial incentive to reduce memory usage. Using other people’s RAM is “free” for a company, so they do it. If their customers are in US/EU/Japan, they can expect reasonably new machines so they don’t see it as an issue. They aren’t chasing the market in Nigeria, however large in population.

                                      1. 5

                                        Webapps are sort of the equivalent of doing something in QT but using nothing but the canvas widget (except a little more awkward because you also don’t have pixel positioning). Whatever can be done in a webapp can be done in a UI toolkit, but the most extreme experimental stuff involves not using actual widgets (just like doing it as a webapp would).

                                        Using QT doesn’t prevent you from writing in javascript. Just use NPM QT bindings. It means not using the DOM, but that’s a net win: it is faster to learn how to do something with a UI toolkit than to figure out how to do it through DOM manipulation, unless the thing that you’re doing is (at a fundamental level) literally displaying HTML.

                                        I don’t think memory use is really going to be the main factor in convincing corporations to leave Electron. It’s not something that’s limited to the third world: most people in the first world (even folks who are in the top half of income) don’t have computers that can run Electron apps very well – but for a lot of folks, there’s the sense that computers just run slow & there’s nothing that can be done about it.

                                        Instead, I think the main thing that’ll drive corporations toward more sustainable solutions is maintenance costs. It’s one thing to hire cheap web developers & have them build something, but over time keeping a hairball running is simply more difficult than keeping something that’s more modular running – particularly as the behavior of browsers with respect to the corner cases that web apps depend upon to continue acting like apps is prone to sudden (and difficult to model) change. Building on the back of HTML rendering means a red queen’s race against 3 major browsers, all of whom are changing their behaviors ahead of standards bodies; on the other hand, building on a UI library means you can specify a particular version as a dependency & also expect reasonable backwards-compatibility and gradual deprecation.

                                        (But, I don’t actually have a lot of confidence that corporations will be convinced to do the thing that, in the long run, will save them money. They need to be seen to have saved money in the much shorter term, & saying that you need to rearchitect something so that it costs less in maintenance over the course of the next six years isn’t very convincing to non-technical folks – or to technical folks who haven’t had the experience of trying to change the behavior of a hairball written and designed by somebody who left the company years ago.)

                                      2. 1

                                        I understand that these tools are maintained in a certain sense. But from an outsider’s perspective, they are absolutely not appealing compared to what you see in their competitors.

                                        I want to be extremely nice, because I think that the work done on these teams and projects is very laudable. But compare the wxPython docs with the Bootstrap documentation. I also spent a lot of time trying to figure out how to use Tk, and almost all resources …. felt outdated and incompatible with whatever toolset I had available.

                                        I think Qt is really good at this stuff, though you do have to marry its toolset for a lot of it (perhaps this has gotten better).

                                        The elephant in the room is that no native UI toolset (save maybe Apple’s stack?) is nowhere near as good as the diversity of options and breadth of tooling available in DOM-based solutions. Chrome dev tools is amazing, and even simple stuff like CSS animations gives a lot of options that would be a pain in most UI toolkits. Out of the box it has so much functionality, even if you’re working purely vanilla/“no library”. Though on this points things might have changed, jQuery basically is the optimal low-level UI library and I haven’t encountered native stuff that gives me the same sort of productivity.

                                        1. 3

                                          I dunno. How much of that is just familiarity? I find the bootstrap documentation so incomprehensible that I roll my own DOM manipulations rather than using it.

                                          TK is easy to use, but the documentation is tcl-centric and pretty unclear. QT is a bad example because it’s quite heavy-weight and slow (and you generally have to use QT’s versions of built-in types and do all sorts of similar stuff). I’m not trying to claim that existing cross-platform UI toolkits are great: I actually have a lot of complaints with all of them; it’s just that, in terms of ease of use, peformance, and consistency of behavior, they’re all far ahead of web tech.

                                          When it comes down to it, web tech means simulating a UI toolkit inside a complicated document rendering system inside a UI toolkit, with no pass-throughs, and even web tech toolkits intended for making UIs are really about manipulating markup and not actually oriented around placing widgets or orienting shapes in 2d space. Because determining how a piece of markup will look when rendered is complex and subject to a lot of variables not under the programmer’s control, any markup-manipulation-oriented system will make creating UIs intractably awkward and fragile – and while Google & others have thrown a great deal of code and effort at this problem (by exhaustively checking for corner cases, performing polyfills, and so on) and hidden most of that code from developers (who would have had to do all of that themselves ten years ago), it’s a battle that can’t be won.

                                          1. 5

                                            It annoys me greatly because it feels like nobody really cares about the conceptual damage incurred by simulating a UI toolkit inside a doument renderer inside a UI toolkit, instead preferring to chant “open web!” And then this broken conceptual basis propagates to other mediums (VR) simply because it’s familiar. I’d also argue the web as a medium is primarily intended for commerce and consumption, rather than creation.

                                            It feels like people care less about the intrinsic quality of what they’re doing and more about following whatever fad is around, especially if it involves tools pushed by megacorporations.

                                            1. 2

                                              Everything (down to the transistor level) is layers of crap hiding other layers of different crap, but web tech is up there with autotools in terms of having abstraction layers that are full of important holes that developers must be mindful of – to the point that, in my mind, rolling your own thing is almost always less work than learning and using the ‘correct’ tool.

                                              If consumer-grade CPUs were still doubling their clock speeds and cache sizes every 18 months at a stable price point and these toolkits properly hid the markup then it’d be a matter of whether or not you consider waste to be wrong on principle or if you’re balancing it with other domains, but neither of those things are true & so choosing web tech means you lose across the board in the short term and lose big across the board in the long term.

                          2. 1

                            Youtube would be a website where you click on a video and it plays. But it wouldn’t have ads and comments and thumbs up and share buttons and view counts and subscription buttons and notification buttons and autoplay and add-to-playlist.

                            Google docs would be a desktop program.

                            Slack would be IRC.

                            1. 1

                              What you’re describing is the video HTML5 tag, not a video sharing platform. Minimalism is good, I do agree, but don’t mix it with no features at all.

                              Google docs would be a desktop program.

                              This is another debate around why using the web for these kind of tasks, not the fact that it’s minimalist or not.

                        1. 5

                          I’m not sure why fewer than 200 people said they use Haskell at work in the previous question but more than 600 said they use Haskell at work at least some of the time in this question.

                          Was the question “Where do you use Haskell?” multiple choice, or was the survey using radio buttons? Could be the source of the discrepancy.

                          1. 5

                            The “where do you use Haskell” question was multiple choice (check boxes). The “do you use Haskell at work” question was single choice (radio buttons).

                            1. 3

                              I had this same problem with State of Elm. The first go ‘round people told me that the binary yes-or-no was unclear because they felt they had to be using it in production. But that wasn’t my intent, so this year I tried to fix it by making the “where are you using Elm” question have the following choices:

                              • I’m just tinkering
                              • Don’t feel ready for production
                              • No code in staging or production but feel capable
                              • In development towards production
                              • In production on a side project
                              • In production at work (internal)
                              • In production at work (user-facing)

                              Next year I’m going to break it down even more. It turns out that a lot of things I thought were yes/no initially are actually sliding scales. (Except for “can I have your email” or really really specific and leading questions.)

                              1. 1

                                That is actually quite interesting, I’ve been tinkering with both Haskell and Elm at work but haven’t used them on any project meant for production.

                                I usually experiment with a lot of languages for smaller side projects and when architecting a new product and evaluating tech choices, many of these are never put into production usage while some do.

                          1. 15

                            I was disappointed that there were no demographic questions - that’s a vital area which the Rust survey creators put a lot of work into. I expect it was due to the survey creators not seeing it as important enough to justify the effort of doing it right, which I know is considerable. I understand that decision, but it’s frustrating, because it’s very important to some of us.

                            1. 16

                              I agree that demographics are important! I definitely want to include them in next year’s survey. This is the first survey I’ve ever published. I didn’t want to get the demographic questions wrong or otherwise mishandle them. That’s why I decided to focus on the technical questions. The survey was developed in the open (see this issue); next year’s will be too. I would be delighted to have you help out with the demographic questions.

                              1. 13

                                Just copy ours :).

                                Jest aside, we’re cool with anyone taking these questions like all our other open source output.

                                Also, there’s a huge problem currently: most languages don’t run these kinds of surveys and then many don’t share a common core. It’s hard to read a lot from them.

                                In case of Rust, we’re in the lucky position to actually have run two of them, so we can at least put this year’s number in relationship to last year’s.

                                But for the rest? Are we doing better then language X? Worse? Only gut feeling.

                                I don’t see this as a competition, there’s rarely been a structured approach to mapping communities.

                                In any case, if you’d like to exchange experiences, please feel free to contact community-team@rust-lang.org

                                1. 8

                                  I’m happy to hear that! And I’m also happy to be contacted to comment on concrete proposals, when next year’s survey is at that stage; I don’t have the bandwidth to be involved more than that.

                                  I suspect the team that did the Rust survey will also be happy to advise about these topics. I know they’ve talked about it a bunch here on lobste.rs, and those old discussions are still in the archives somewhere.

                                2. -2

                                  You mean the part about “underrepresented groups” or whatever on the Rust survey? Why do you think that is important?

                                  One of my favorite things about the Haskell community is that everyone is too busy doing actual technically impressive stuff to worry about e.g. how many gay people happen to be using it.

                                  To be blunt, I think that sort of thinking (obsessing over whether an organic community follows one’s arbitrarily constructed ideals for what it should look like) is a cancerous mind-suck that detracts from actually productive work.

                                  To be a little more blunt, I think the fact that Haskell has a reputation as being extremely technical has actually helped the community a great deal, at least just by virtue of the fact that it scares away people who are primarily involved in software as a means to push some political agenda.

                                  Late edit: feel free to respond instead of just downvoting, would be happy to be wrong here.

                                  1. 33

                                    This is downvoted already, I’ll bite anyways. First of all, I think your comment shows that you have no idea what we are doing there.

                                    Gathering demographics questions is much more then what you narrow it down to. It’s telling that the only thing you can come up with is “how many gay people happen to be using it”? It’s also: where do people live, would they want to travel to a conference, etc… It cuts out the guesswork. You know what? When you measure, you also sometimes find out that things are just okay. No need to do something. Great! Sometimes, you find something odd. Then you might want to investigate. It’s a community survey. We want to know about people, not about technology. But social groups are also a thing to check.

                                    The Rust community also does production user surveys, which are die-hard technical and very detailed, usually specific in certain areas like embedded and or gaming. We seek out users willing to do that and set up meetings to figure out the issues.

                                    To be blunt, I think that sort of thinking (obsessing over whether an organic community follows one’s arbitrarily constructed ideals for what it should look like) is a cancerous mind-suck that detracts from actually productive work.

                                    To be blunt too: It’s shit that you call my work “not productive”. Here’s a thing: I don’t want to contribute to rustc or Servo. Why? I code all day, I don’t want to code at night. I’m happy that other people want to. I still want to contribute to FOSS. In the last 5 years, I’ve set up 2 foundations, 11 conferences and managed around 250000 Euros to run all these things. I signed leases that could have bankrupted me. I managed to find ways to run 2-days conferences that cost 100EUR and still cover all expenses of speakers, attendees and those that cannot pay 100 Euros. I love that work. People are indeed very fair about this. Those that have more give, those that don’t, don’t. And I want everyone to benefit from that. My whole work revolves around the question “Who’s not here, and why?”. It’s my hack. Nothing of that is fundamentally special, other people could have done it.

                                    And you know what? We measure. We don’t go out “hey, please do X because I think it works”. No, we go “hey, we did X and metric Y improved”.

                                    It’s also amazing how many people just need a “have you considered programming might be something for you?” and then just head of and learn it. But the question needs to be asked a couple of times.

                                    It’s shitty to go on an concern troll around people doing precisely that to better do “productive work”.

                                    There’s no way to get me to work on other things without paying me. And you know what I like about the Rust community? They don’t concern troll me. They go: cool, if that’s what you want to do, please do it for us. It’s not like I bind a lot of resources. Community work works best if you don’t have many cycles. We align on a goal and then we do a lot of footwork.

                                    Sure, there are cases where issues arise and social work becomes focus, but that’s fine. Interestingly, the work of community workers is often to talk about issues before they come a trashfire, go to reddit and subsequently to 4chan.

                                    There’s also the “fixed cake” fallacy at work here: The belief that if we expand our community beyond a certain group, another group has to take the impact. That isn’t the case. The cake is not fixed. The market for programming languages is growing in absolute terms, also our communities are growing in absolute terms. These are effect to be appreciated and taken into consideration.

                                    Different folk need to be addressed in different fashion and thats fine. These surveys give us a bearing in where we want to invest our time or where things just work.

                                    If you absolutely want to talk in programming terms, we’re profiling our work. I find it amazing that there is so much pushback when we actually check on our successes.

                                    It’s shitty of people to devalue that work. A work, which has to be said, is more often done by women and people of color in many communities. Many of which are masters of it.

                                    There’s two options here: I do this work within a community or I don’t. It’s as simple as that. No “more productive” trolling.

                                    I structured work on these issues is still “cancerous mind-suck” for you, then go ahead. But say it to my face when you meet me.

                                    To be a little more blunt, I think the fact that Haskell has a reputation as being extremely technical has actually helped the community a great deal, at least just by virtue of the fact that it scares away people who are primarily involved in software as a means to push some political agenda.

                                    I just leave this here:

                                    So I just met Simon Peyton Jones (creator of Haskell) and chatted with him for a bit. Asked him his thoughts on Rust and he said he thinks it seems exciting and he was jealous of the great community we have. Just thought I would let you guys know :)

                                    (From: https://www.reddit.com/r/rust/comments/5yo24a/meta_rust_jealousy/)

                                    This was, by the way, the best compliment I ever saw, I respect Simon very much.

                                    We have an awesome many people primarily interested in software working in the Rust community. But they don’t throw the community workers under the bus like you do. That’s why I run a 6-monthly Rust conference and not a 6-monthly Haskell conference.

                                    I love Haskell, but there’s reasons I’m not active there. Still, for anyone that wants to learn techniques and procedures, by all means get in touch.

                                    Communities don’t happen at random. They work through network effects and feedback and these can be moderated and improved.

                                    Finally, to be very blunt: you just cost me 45 minutes of community work, which I’d have preferred to fill with something productive.

                                    But I also think it’s worth putting it out for others to read.

                                    EDIT: I’d also like to state that I know quite some people in the Haskell community caring very deeply about this. haskell-cafe is still one of my inspirations for a cool space to make. But that space is intentional, not organic.

                                    1. 10

                                      Thank you very much for writing this. It will serve as a great resource the next time I spot a similar comment in the wild.

                                      1. 4

                                        Found this thread late, but wanted to say thanks @skade for the consistently insightful commentary on community here, and for you work in the Rust community. I don’t work with Rust much, but on the occasions when I’m working on community-building, the Rust community is one of the first places I go to for examples of how to do it well.

                                        1. 1

                                          Thanks for responding.

                                          It’s telling that the only thing you can come up with is “how many gay people happen to be using it”?

                                          That’s the only demo data you put on https://blog.rust-lang.org/2017/09/05/Rust-2017-Survey-Results.html

                                          Please, tell me how you thought that was “telling”.

                                          But social groups are also a thing to check.

                                          Check and… what?

                                          The Rust community also does production user surveys,

                                          Do you see me objecting to those?

                                          To be blunt too: It’s shit that you call my work “not productive”.

                                          Sorry you feel that way. I think a lot of things aren’t productive, including some things I do, so you shouldn’t take it personally.

                                          In the last 5 years, I’ve set up 2 foundations…

                                          Cool, but you don’t need to justify your relevance because I called one of your interests into question.

                                          It’s shitty to go on an concern troll around people doing precisely that to better do “productive work”.

                                          Actually, I wouldn’t say anything if I just thought you were just wasting your own time; further than that, I think obsessing over demos is actively counterproductive. The utility to the community is negative, not zero.

                                          There’s also the “fixed cake” fallacy at work here: The belief that if we expand our community beyond a certain group, another group has to take the impact.

                                          It’s not so much “taking the cake” as “ruining the cake”. If you “expand your community” to include demo-obsessed identity politicians, the community is going to become actively worse.

                                          A work, which has to be said, is more often done by women and people of color in many communities.

                                          Why did you feel this comment was relevant to the conversation? I have several hypotheses, but I’d prefer not to assume your motivations.

                                          I structured work on these issues is still “cancerous mind-suck” for you, then go ahead. But say it to my face when you meet me.

                                          Sure. I don’t have an aversion to arguing about the social costs of different activities in person any more than I do online.

                                          That’s why I run a 6-monthly Rust conference and not a 6-monthly Haskell conference.

                                          Right, that’s what I said earlier; something about Haskell pushes away people with demographic planning aspirations, which I like a lot.

                                          Communities don’t happen at random… these can be moderated and improved.

                                          This is just fundamentally untrue; most of the best communities are more or less spontaneous. Many communities I love (such as lobsters) are good precisely because they’re minimally moderated.

                                          haskell-cafe is still one of my inspirations for a cool space to make. But that space is intentional, not organic.

                                          The list is, afaik, unmoderated, and the Haskell IRC (one of the best chats on freenode) is also totally unmoderated. Your example is evidence against your claims.

                                          1. 6

                                            Communities don’t happen at random. They work through network effects and feedback and these can be moderated and improved.

                                            This is just fundamentally untrue; most of the best communities are more or less spontaneous. Many communities I love (such as lobsters) are good precisely because they’re minimally moderated.

                                            This is false for Lobsters, both historically and currently.

                                            Speaking historically, you cut out the key phrase “network effects” from the quote. The Lobsters of early 2014 was a very different, nearly empty place. The current state of Barnacles is quite similar: low activity by any metric you care to measure (traffic, stories posted, comments, votes, etc.) and a negligible sense of community. Online communities start as failures and have to overcome the chicken-and-egg problem that it’s a waste of an individual’s time to participate until quite a lot of other people are already participating.

                                            And on an ongoing basis, Lobsters requires daily attention to moderation and maintenance. Most of it is design, small edits, comments, and private messages. The rare, exciting things like deleted comments and banned users are the tip of an iceberg. It’s all the small, constant attention that keeps the positive feedback loops working to power a successful community instead of killing it. This is also true of Haskell-cafe.

                                            The theme I take from your comments seems to be that the work you are unaware of doesn’t exist and, if it does, it must be worthless. I don’t understand that dismissive cynicism well enough to respond meaningfully to it, so all I can do is point out these surface-level inaccuracies.

                                            1. 2

                                              Lobsters requires daily attention to moderation and maintenance.

                                              I seem to recall jcs saying that he never deleted anything if he could avoid it, and indeed that seemed to be the case. It seems that you are now taking a somewhat more active stance, but historically lobsters has had very little/none of what I would call active moderation.

                                              Most of it is design, small edits, comments, and private messages… This is also true of Haskell-cafe.

                                              SPJ sending out an email about being nice isn’t community moderation or management. Neither is general site maintenance. I’m not sure how you would conclude that I disagreed with any of these things unless we’re using very different definitions for a number of words.

                                              The theme I take from your comments seems to be that the work you are unaware of doesn’t exist

                                              I’m aware of all the examples you gave; they just aren’t the kind of obsessive, inorganic micromanagement I was objecting to.

                                            2. 4

                                              That’s the only demo data you put on https://blog.rust-lang.org/2017/09/05/Rust-2017-Survey-Results.html

                                              I don’t get it. That page contains a bar chart with all sorts of demographic categories on it, just above “Diversity and inclusiveness continue to be vital goals for the Rust project at all levels.”

                                              1. -2

                                                Me:

                                                e.g. how many gay people happen to be using it.

                                                Guy who responded to me:

                                                where do people live, would they want to travel to a conference, etc…

                                                What kind of demo data do you see them sharing on that page? I’m not really sure what you’re confused about; you seem to be agreeing with me.

                                                1. 7

                                                  The blog post is an editorialised overview, the 2016 one covers that. https://blog.rust-lang.org/2016/06/30/State-of-Rust-Survey-2016.html#survey-demographics

                                                  There have not been notable changes, so it wasn’t mentioned again.

                                              2. 4

                                                As the person who started the Haskell IRC channel and as an active moderator of said channel, moderation happens often. There’s a team of motivated users on the #haskell-ops IRC channel and we have to step in more than I’d prefer.

                                                Good communities require much work and regular feedback.

                                        1. 4

                                          So far the comments I’ve shown have been personal attacks

                                          Only 2 of the 6 comments up to the point this comment is made have anything personal in them. They seem to be “attacking” the concepts, not the person.

                                          1. 6

                                            Hi! Author here. Now that I’ve had some time to mellow, I wouldn’t call those “personal attacks”. At the time I was excited about functional pipelines (probably thanks to Elixir). No Haskell libraries provided the (|>) pipeline operator. I created Flow to fill that gap. I shared it on Reddit because I wanted to know why pipelines weren’t popular in the Haskell community. It got over 100 comments, which is huge for r/haskell. In my opinion, most of the comments were negative. They derided the library by calling it “backwards” or a “hurdle” or a “crutch” or “exactly what functional programming is trying to avoid”. I took those comments personally when I shouldn’t have.

                                            These days I just import Data.Function ((&)) and wince a little every time I write (&) instead of (|>). It’s definitely not as popular as ($) and (.), but it’s hard to call it non-standard when it’s in the base package.

                                            1. 2

                                              I’ve always found the “backwards” notation of & a bit odd, but as you say in your post, different notations have different uses or people who prefer them. I know haskellforall has done some stuff with & around the “make Haskell look like OOP” experiments.

                                              I mean, >>= is in this direction as the “default” so that’s not uncommon at all. I wonder if you could do some fun stuff with >>= and Identity

                                              1. 2

                                                I usually prefer (&) because it encourages iterative development. Start with some value, transform it, and keep doing that until you have the result you want. That’s how I usually work in GHCi. The alternative is to start at the “outside” and keep working in until you’re at the bottom. I find that way of developing to be better when I already have the type signature and I’m filling in typed holes.

                                                Fun fact: You can use do notation with pure computations in Haskell.

                                                f :: Int -> Int
                                                f x = do
                                                  let y = x + 2
                                                  let z = x * 2
                                                  y + z
                                                
                                                1. 2

                                                  Yes, you can have non-recursive let!

                                                  test = runIdentity $ do
                                                       (x,s) <- return $ foo 1 []
                                                       (y,s) <- return $ bar x s
                                                       (z,s) <- return $ baz x y s
                                                       return (z,s)
                                                  
                                                  1. 2

                                                    I don’t understand what the big deal is, we read from left to right not right to left. It’s just a notational convenience I really don’t understand how people could get so conservative that they can’t even handle a different direction of function composition. If you wrote right to left, I could see that being a serious inconvenience though.

                                              1. 4

                                                I’m the author. Thanks for posting this! It’s not super useful right now because there are no GHC release candidates to test. But the general idea should be applicable when the GHC 8.2.2 release candidates roll around.

                                                  1. 4

                                                    While I don’t have a particular problem with these newsletters, I have heard feedback before that it isn’t appropriate to post them on a regular basis.

                                                    1. 7

                                                      I hear you! The last one of these I posted was issue 32, which was 24 weeks ago. I’d hardly call that regular ;)

                                                    1. 5

                                                      For example doing this explicitly in Python is cumbersome:

                                                      data = {"a": 1, "b": 2}
                                                      
                                                      if data["a"] is not None:
                                                          return data["a"]
                                                      else:
                                                          return 0 # default return value    
                                                      

                                                      This is not how we do it in Python. if data["a"] is None is going to break if “a” is not in the dictionary, so instead we do:

                                                      data = {"a": 1, "b": 2}
                                                      return data.get("a", 0)
                                                      

                                                      … which returns the default if the key is absent and only does one look up.

                                                      1. 4

                                                        I was going to point this out as well. Unfortunately even get with a default value can still return None. For example, {'a':None}.get('a',0) is None, not 0.

                                                        1. 2

                                                          Ah thanks, I haven’t done Python in a while. I’ll update the article.

                                                        1. 14

                                                          I write Haskell for a living and prefer to use hspec. Less boilerplate, seems to incorporate different types of tests (unit, property, etc.) with less ceremony and hassle.

                                                          1. 2

                                                            I also prefer Hspec. I tried to use Tasty for a while because conceptually I like it better. Having separate providers (Hspec, QuickCheck, golden, …) and “ingredients” (formatters and runners) feels nice. Ultimately Hspec does everything I want and has better ergonomics.

                                                            1. 1

                                                              hspec is my favorite, too

                                                            1. 5

                                                              Can you guess Haskell’s type with the next shortest name (hint: three letters)?

                                                              Pedant note: actually, there’s another two-character type, which is ->, i.e. a -> b is (->) a b.

                                                              1. 5

                                                                There’s also ().

                                                                1. 5

                                                                  Yep. And IO, ST.

                                                                2. 4

                                                                  Nowadays, you might also consider *.

                                                                1. 6

                                                                  The very same test, written in Haskell, wouldn’t compile!

                                                                  That’s because the author used shouldBe, which (as they noted) is pure. If they wanted to do the same thing as the Python version, they could have used shouldReturn.

                                                                    1. 9

                                                                      So… a schism? A fork? A squabble?

                                                                      Something is rotten in the State of Haskell?

                                                                      Is this about people arguing about the website design or about cabal vs Stack?

                                                                      1. 7

                                                                        The sponsors are FP Complete and the Commercial Haskell Group, which are responsible for Stack and other industry docs/tools. The site announcement says:

                                                                        In the opinion of the team behind haskell-lang.org, the tooling story and general ecosystem infrastructure for the Haskell community has accumulated enough baggage that a clean break is the best use of everybody’s time. We intend to streamline the on-boarding process for new developers, move away from infrastructure that is showing its age, and embrace newer approaches to facilitate open collaboration. Similar decisions have already been made in creating the Stack build tool and Stackage.

                                                                        For the subreddit, one site creator writes:

                                                                        Because /r/haskell has become a place of constant flamewars. We need a clean break. A new subreddit provides a fresh start allowing to mold a new community based on better principles. Everyone who wants to be part of the new community is invited to join the new Haskell movement. Troublemaker will hopefully stay behind

                                                                        But earlier another said:

                                                                        Just to give one concrete example to hopefully clarify a bit: the new subreddit is intended as a place to discuss topics specific to haskell-lang.org. I have full intentions of still being a participating member of /r/haskell, and (AFAIK) everyone else on the haskell-lang team feels the same way.

                                                                        There’s some older conversation here, plus a current reddit thread and YC news thread.

                                                                        1. 3
                                                                          1. 2

                                                                            I was confused by the confusingly similar name, shit. I can’t edit the post or I would. I’m sorry to anyone misled by my mistake.

                                                                            Thank you for the correction.

                                                                            1. 2

                                                                              Rabble_of_One ain’t me. I asked them why they chose a name similar to one I use.

                                                                              I didn’t make the site either.

                                                                      1. 5

                                                                        Is an ADT the same as a GADT?

                                                                        1. 11

                                                                          GADTs are what you get when you add non-syntactic type equalities to ADTs.

                                                                          Normal equality on types is generally considered to be syntactical equivalence modulo beta-reduction. Beta-reduction is the reduction rule (λx. e) e' → e[x/e'], aka function application. So for example, the types list a and list a are equivalent. So are the types (λx. list x) a and list a.

                                                                          Non-syntactic type equality is when the context influences type equalities. Let’s say in our scope we have a variable co with type (a ~ b), and we want to know if list a and list b are equivalent. The answer is yes, because we can use co to rewrite a to b. Types like (a ~ b) are called coercions, and if you have one in scope, that is proof of a particular equality.

                                                                          Here is an example from the link that @taylorfausak posted:

                                                                          data Expr a where
                                                                              I   :: Int  -> Expr Int
                                                                              B   :: Bool -> Expr Bool
                                                                              Add :: Expr Int -> Expr Int -> Expr Int
                                                                              Mul :: Expr Int -> Expr Int -> Expr Int
                                                                              Eq  :: Expr Int -> Expr Int -> Expr Bool
                                                                          

                                                                          This is syntactic sugar for the following:

                                                                          data Expr a = I Int (a ~ Int)
                                                                                      | B Bool (a ~ Bool)
                                                                                      | Add (Expr Int) (Expr Int) (a ~ Int)
                                                                                      | Mul (Expr Int) (Expr Int) (a ~ Int)
                                                                                      | Eq (Expr Int) (Expr Int) (a ~ Bool)
                                                                          

                                                                          That is, when you create an I, you have to supply a proof that the type variable a is Int. When you create a B, you have to supply a proof that the type variable a is Bool. Etc. When you perform a case on an Expr a you then get the appropriate coercions in scope for rewriting. This is how the evaluator from the link works:

                                                                          eval :: Expr a -> a
                                                                          eval (I n) = n
                                                                          eval (B b) = b
                                                                          eval (Add e1 e2) = eval e1 + eval e2
                                                                          eval (Mul e1 e2) = eval e1 * eval e2
                                                                          eval (Eq  e1 e2) = eval e1 == eval e2
                                                                          

                                                                          When we perform a pattern match and the case is I n, we return the Int n. But, we needed to actually return an a, per the type signature! No problem, we have a coercion from a ~ Int handy in our scope, and can use that to rewrite, and thus make the example type check. The other cases work similarly.

                                                                          Misc facts:

                                                                          • You can build coercions in languages with higher-kinded polymorphism. a ~ b can be represented using a Leibniz equality ∀f : ⋆ → ⋆. f a → f b.

                                                                          • Adding coercions to the type system makes type inference undecidable. This is why you generally have to supply a type signature on a function that uses GADTs.

                                                                          • Proving that two types are equivalent modulo a context is undecidable in the general case. Consider equalities between type functions, or, equivalently, between polymorphic types (a proof that ∀x. e = ∀x. e' isn’t much different than a proof λx. e = λx. e')

                                                                          For more information, System F with Type Equality Coercions may be useful.

                                                                          1. 4

                                                                            GADTS are Generalised ADTs, so they’re a more flexible version of the same idea.

                                                                            I’d like to do a follow-up on GADTs, but I want to find a good concrete example first. (One that isn’t a parser!)

                                                                            1. 1

                                                                              Heh… Every example I can think of is a parser. :)

                                                                            2. 3

                                                                              I can’t say I fully grok GADTs, but conceptually they seem similar. This page does a good job explaining the differences between ADTs and GADTs in terms of a concrete example.

                                                                              1. 1

                                                                                The way I understand it, all the “cases” in a regular ADT all have the same type. A GADT lets you define the “cases” such that different cases might appear differently to the type system, which allows you to make stronger guarantees (since you can, for example, abstract over subsets of the cases).

                                                                                For example, in @cmm’s expression example, you can tell the type system that a particular Expr “case” can only be built out of other Expr cases parameterized upon Int, rather than accepting any Expr case (and hoping for the best).

                                                                              1. 6

                                                                                I like that Jasper classified avoiding language extensions as a mistake. As he mentions, GHC is the de facto standard. And many of the useful extensions, like OverloadedStrings, are basically source transformations. My only complaint is that the Haskell language standard hasn’t kept up with the extensions, so you have to enable a lot to work in a comfortable environment. As Gabriel says:

                                                                                An idiomatic Haskell program is 20 lines of imports, 6 language extensions, and 1 line of Perl.

                                                                                1. 17

                                                                                  they are still shipping a version of my software that I released in 2014

                                                                                  That’s… not that old? Especially for a screen saver program. That’s been around since 1992.

                                                                                  1. 9

                                                                                    If memory serves, in the last year or so, there was at least one bug in the lock dialog that was fixed.

                                                                                    When software has a critical vulnerability that is patched in a newer release, it becomes old instantly.