1. 1

    This is not the fully edited and final version of the text btw. Still usable, just be aware that there are errors.

    e.g. Efficient compilation of pattern-matching and Transforming the enriched Lambda Calculus in the table of contents have the same number 5 leading them.

    1. 4

      That copy is a highly compressed djvu to pdf conversion and that error is actually a compression artifact from the djvu version, see: https://en.wikipedia.org/wiki/JBIG2#Disadvantages

      For a copy without the compression artifact (but also uncropped), see: https://www.microsoft.com/en-us/research/publication/the-implementation-of-functional-programming-languages/

      1. 1

        That’s really interesting, I had no idea! Thank you.

    1. 1

      I mean, there are enough Linux distributions trying to be Solaris already. A different take would be welcome.

      1. 9

        If we’re gonna open that can of worms I’d also assert that rather than creating new distributions it’d be awesome if folks would pour their efforts into improving one of the umpteen skittledezillion that already exist.

        However, that’s the beauty of open source right?

        1. 5

          The beauty and the tragedy of open source.

          1. 4

            I don’t like distro proliferation, either.

            But this doesn’t fit the “New DE with distro centered around it” pattern nor the “Let’s make another Debian/Arch derivative and market it as user friendly so that some suckers donate to us” pattern.

            This one seems to have some merit to it, by going llvm/libc++/musl.

            1. 1

              Why not, say, an Ubuntu variant though? Or a spin of Fedora?

              SOMETHING to help these new developments broaden an existing community.

          2. 2

            Which ones? I’m curious.

            1. 1

              That was poorly phrased. I was thrashing around for the idea that they’re a lot of distributions trying to do the same thing, not so much that they’re trying to be like Solaris.

          1. 48

            I saw this described on the IRC channel as ‘what-color-are-your-underpants threads’ - lots of easy engagement stuff, crowding more interesting stuff off the front page. My perception is that there is now a lot less of the stuff that differentiated lobste.rs from the other hundredty-dillion tech sites - it was good at bridging computer-science-proper topics and real applications, e.g. someone’s experience report of using formal verification in a real product, or how property testing uncovered some tasty bug in some avionics, or how to synthesize gateware with Z3. That sort of thing.

            It doesn’t have to be the case that underwear-threads exist at the cost of quickcheck threads, but as they increasingly crowd the front page and stay there, it means the slightly more cerebral stuff has less chance to be seen, and new people get a different perception of what lobste.rs is about, and so the tone of the place gradually shifts. Some people might think that’s fine, I think it’s a shame. Differentiation is good.

            As for ‘if it gets upvotes then by definition it belongs’, I’ve always thought that ‘just leave it to the market’ attitude is total and utter cow-dung. Of course there should be regulation. If you applied that confusion everywhere you’d have sport be replaced by gladiatorial combat, McDonalds purchasing every farm until that was all you could eat, and other kinds of dystopia that unfortunately some americans are beginning to suffer a flavor of (choosing between insulin and death, $1000 toilet roll…). There is nothing inevitable about letting upvotes decide the tone of the site, it’s not a fundamental physical force. You’re allowed to intervene, complain, and so on. It should be encouraged, I think.

            1. 21

              crowding more interesting stuff off the front page

              Come on, there’s very rarely more than one of these threads on the front page, how is that crowding?

              1. 7

                Well I counted three at one point today, which is over 10% of the front page. I’d like to nip this virus in the bud! It’s too facile to make corona references but regardless, we can go from ‘15 deaths out of 300 million people, no big deal’ to We Have A Problem is a fairly short space of time.

                One of the more useful and formative talks I watched when helping to start my business was Ed Catmull [computer graphics pioneer and former Pixar president]’s talk entitled ‘Keep your crises small’*in which he makes the case that businesses are fundamentally unstable and it’s especially hard to notice the bad stuff during periods of high growth or profitability. He contends that you must always have your hand on the tiller and make steering corrections before problems get too big. I see an analogous situation on lobste.rs.

                Look at my posting history here. It’s crap. I am a consumer and not a contributor. I have no right to voice my opinion really because I have not done my bit to try and steer lobsters in the direction I want. I am a mechanical engineer with no formal CS background and I stayed here merely because I learned a great deal, and my industry is one built on MScs and PhDs committing abominations in Excel and Matlab, in which a bit of solid CS and solid industrial best-practice would reduce the friction in aerospace R&D by an order of magnitude. It took me five years to get one of my customers to switch to python. Now one of them is using Hypothesis (!) and advocating its usage more widely in a reasonably large aerospace company. I am a True Believer in the value of Advocating the fruits of Computer Science in a field where most participants think the low hanging fruit lies elsewhere. All I’ve been doing is sharing the good stuff that lobsters introduced me to. And this is why I lament the fact that it’s being muscled out by what vim colorscheme do we all prefer, and why I therefore am moved to leave a comment like the grandparent.

                Yes, I will make more effort to upvote and comment on the bits of lobsters I value from now on.

              2. 11

                is that there is now a lot less of the stuff that differentiated lobste.rs from the other hundredty-dillion tech sites

                There is and it’s due to less demand. What the audience wants has changed. I was still doing submissions like you described. They rarely hit the front page. The things getting upvoted were a mix of Lobsters-like content and stuff that gets high votes on other sites. Sometimes cross-posted from those sites. I stopped submitting as much for personal reasons (priority shift) but lack of demand/interest could’ve done it by itself.

                1. 8

                  I stopped submitting as much for personal reasons (priority shift)…

                  For what it’s worth, I noticed that you have been posting less. Hope all is well.

                  1. 12

                    I’ll message you the details if you want. It’s been a trip with me back to the Lord, surviving some Gone Girl shit, and facing COVID workload right after. Right now, Im focused on fighting COVID and problems it causes however I can. City-wide shortage on toilet paper, soap, cleaners, etc and nurses having no alcohol/masks made me source them first. Gotta block hoarders and unscrupulous resellers, though.

                    Gonna have to find some web developers who can build a store or subscription service. Plan to let people pick up limited quantities that I order in bulk and resell just over cost. Might also scan what’s in local stores to reduce people’s time in them. After that, maybe a non-profit version of InstaCart with advantages that may or may not be easy to code. Got an anti-microbial scanner on the way for whatever.

                    Once everything settles, I’ll get back to my security projects. I just go where needed the most. Worse, people arent social distancing here: enveloping around me constantly. COVID can kill me. So, Im tired after work from holding my breath and dodging people up to 14hrs a day. Had no energy for doing CompSci papers either.

                    So, there’s a brief summary of some things Ive been up to for anyone wondering.

                    1. 4

                      I’m sorry to hear that. I assumed that you must be busy with other stuff or taking a break, but I wouldn’t have guessed how hard of a time you were having. I hope that things start looking up for you soon.

                      1. 4

                        I really appreciate it. Everyone supporting these comments, too, more than I thought I’d see. I’m good, though. (taps heart) Good where I need to be.

                        The possibilities and challenges do keep coming, though. Hope and pray those of us fighting this keep making progress both inside ourselves and outside getting things done in the real world. I’ll be fine with that result. :)

                  2. 2

                    Speaking of which, where do you find your papers?

                    1. 6

                      I applied old-school methods of using search engines to paper discovery. I pay attention to good papers that cite other work. Each sub-field develops key words that are in most of the papers. I type them into DuckDuckGo and/or Startpage with quotation marks followed by a year. Maybe “pdf” with that. This produces a batch of papers. I open all of them glancing at abstracts, summaries, and related work. I’ll go 5-10 pages deep in search results. I repeat the process changing the terms and years to get a batch for that sub-field. Then, I used to post the better ones one by one over a week or two. Then, do a different sub- or sub-sub-field next.

                      The Lobsters didn’t like seeing it that way. Too much on the same topic. So, I started getting the batches, saving them in a file, batch another topic when I have time/energy, and trickling out submissions over time with varying topics. So, I might have 50-100 papers across a half dozen to a dozen topics alternating between them. I just pick one, submit it, and mark it as submitted. Eventually, when there’s not much left, I would just grab some more batches.

                      1. 2

                        Wow that’s amazing! Thank you so much for doing this! I’ve seen some really nice papers here but I didn’t realize there would be this kind of work behind the posting.

                        1. 2

                          I thought people like you just happened to read extremely much.

                          Equally impressed now, just for a different reason.

                    2. 2

                      I get the idea of that. I think that what makes the distinction between good and not-so-good ask threads is the length of the responses. For share your blog - what is there to say except a link to your blog? I didn’t bother looking at that one. On the other hand, the distro question generated a ton of long responses about various Linux distros and the pros and cons thereof, interesting stuff. I wonder if there’s some way we could discourage short responses on ask threads, or ask thread topics that tend to generate short responses.

                      1. 1

                        Of course there should be regulation. If you applied that confusion everywhere you’d have sport be replaced by gladiatorial combat, McDonalds purchasing every farm until that was all you could eat, and other kinds of dystopia that unfortunately some americans are beginning to suffer a flavor of (choosing between insulin and death, $1000 toilet roll…).

                        It’s not that I’m looking forward to opening a discussion about this topic, but are you sure this would be the case? Lots of pathological actions done by monopolies are the result of regulating the market in a way which effectively removes competition, leaving the power to the monopolies (in fact, lots of megacorporations that exist nowadays wouldn’t be able to grow to such sizes if it wasn’t for the help from the government). I wouldn’t be so sure that the lack of regulations is the main problem.

                      1. 11

                        It’s curious how of the successful Haskell projects in the wild, few if any go crazy with the type system.

                        (This observation is based primarily on PostgREST and Pandoc, and now ShellCheck. GHC might be a counter-example.)

                        1. 3

                          It’s curious how of the successful Haskell projects in the wild, few if any go crazy with the type system.

                          Considering how popular e.g. lens, servant, and aeson are, I’m not sure this follows. What is your criteria for being a “successful Haskell project in the wild?” What’s your definition of “go crazy with the type system?”

                          1. 6

                            Those are librairies though. PostgREST, Pandoc and ShellCheck are not meant to be used only by Haskell developers.

                            1. 0

                              So, let’s say “user-facing apps” then. Now what was meant by “go crazy with the type system” I wonder?

                            2. 4

                              In what sense does Aeson go crazy with the type system?

                          1. 65

                            So, I love Rust, and all of the nice things they say about Rust are true. Having said that, I’m now going to completely ignore the Rust angle and focus on something else that occurred to me.

                            To summarize Discord’s problem - after extensively optimizing a Go service to produce minimal garbage, they found that the garbage collector was still triggering every two minutes (which appears to be a hard minimum frequency) regardless of the lack of garbage produced. Further, each GC sweep was expensive because it had to walk the entire heap full of live objects.

                            The interesting point to me is that this use case (latency-sensitive service with extremely low rates of garbage production) was pathological for a tracing GC, and that optimizing it to produce less garbage made it even more so. Tracing collectors operate on every live object and ignore dead objects, so a heap full of live objects and very few dead ones is a bad fit for a tracing collector. They solved their problem by switching to a reference counting system (well, “reference counting” where everything has exactly one owner and so you don’t actually need to count). Reference counting ignores live objects and operates on dead ones, so of course it would be a better fit for this service. If Go had a collector based on reference counting they probably could have gotten much of the same benefit without rewriting.

                            This reminded me of “A Unified Theory of Garbage Collection” by Bacon et. al, but it hadn’t occurred to me before how optimizing the app to produce less garbage could make the GC’s job harder in some ways. It’s still better to reduce garbage production than to not do so, but it may not give as much benefit as one might expect because of this.

                            1. 3

                              They solved their problem by switching to a reference counting system (well, “reference counting” where everything has exactly one owner and so you don’t actually need to count). Reference counting ignores live objects and operates on dead ones, so of course it would be a better fit for this service.

                              Aside from your wider point, it’s a little more subtle than that, because of abstractions like Rc which give a counted reference to a value, meaning multiple references. There’s also Arc which is an atomic reference counter for use in multiple threads. The first simple Rust program I wrote, I was guided to using Rc, so it’s not even uncommon. Without seeing their code, I’m willing to bet there are plenty of such cases in their code.

                              1. 6

                                The first simple Rust program I wrote, I was guided to using Rc, so it’s not even uncommon.

                                Do you mind sharing what you were trying to do? I’ve been writing Rust for a long time now, and I can count on one hand the number of times I’ve needed Rc. I’ve used Arc a fair number of times though. Still, I’d probably call both pretty uncommon. But there are certainly types of programs where they may be more common.

                                1. 4

                                  I’m currently making a game engine in Rust (rewriting my old Idris stuff) and I use it all the time, from day one. Some of it may be due to the problem at hand necessitating it, but some of it is surely my lack of experience in Rust. I think some of the problems might be solved with a more refined use of lifetimes… but I’ve been burned by structs+lifetimes before so I’d rather opt for something I have a better grasp of even if it’s more inelegant a solution.

                                  For example, my game has a Timeline object, which is basically the central source of truth about important game data (stuff that has to be saved). But it’s not a regular field, it’s an Rc, because I need to share it with Scene objects (which actually run the game logic). I could make a complex messaging system to telegraph the state changes between Server and multiple Scenes but again… I don’t really wanna.

                                  1. 2

                                    Yeah I’ve never made a game engine, so it’s hard for me to know whether Rc is truly beneficial there. In any case, I’m mostly just trying to push back against the notion that reference counting is common in Rust code. (And specifically, Rc.) I was just very curious about the “first simple Rust program” that someone wrote where they were guided towards using Rc.

                                    This is important because if reference counting were very common, then that would diminish the usefulness of the borrow checker. e.g., “What good is the borrow checker if you wind up needing to use reference counting so much?” Well, you don’t wind up needing to use reference counting a lot. There are of course many cases where reference counting is very useful, but that doesn’t mean it’s common among the entire body of Rust code.

                                  2. 1

                                    Just as an off-hand example from my experience: you basically can’t get anything done with GTK and Rust without Rc. Cf. https://github.com/bitemyapp/boxcar-willie/blob/master/src/main.rs#L108

                                    I wrote boxcar-willie with assistance from the gtk-rs people.

                                    Some common web-app stuff will force you into that too.

                                    There are other situations and libraries that force it but these are the ones that come to mind from my own background. GUI apps and web apps already touches >80% of programmers.

                                    1. 2

                                      What part of web apps use Rc in Rust? There is more nuance to this. A better metric might be “of all the types you define in your project, what proportion of them use reference counting?” If you have to have one reference counted type among dozens of other non-reference counting types, then I’d say it’s pretty uncommon. For example, if most web apps have a database handle and then database handle uses an Arc to be efficiently shared between multiple threads simultaneously, and since database handles are pretty common in web apps, would you then conclude that “reference counting is common” in Rust? I don’t think I would. Because it’s doesn’t pervade and infect everything else in your code. There’s still going to be a lot of other stuff that doesn’t use reference counting at all.

                                      The GTK case is indeed known, and was on my mind when writing the above comments. But it’s not clear to me that this is a GTK problem or whether it generalizes to “GUI apps.”

                                      1. 1

                                        Well usually it’d be an Arc, particularly in cases where the framework doesn’t provide a way to share data between request handlers.

                                        I was just proffering where I’d run into it. I’m not trying to make some kind of polemical point. I rather like using Rust.

                                        then database handle uses an Arc to be efficiently shared between multiple threads simultaneously, and since database handles are pretty common in web apps, would you then conclude that “reference counting is common” in Rust?

                                        I’m speaking to peoples’ subjective experience of it and how they’re going to react to your characterization of it being rare. We’re not taking a pointer head-count here. You get someone comfortable with but new to Rust and have them spin up a few typical projects they’re going to say, “but I kept running into situations where I needed ${X}” and it doesn’t feel rare because it occurred at least a couple times per project. I’m personally very comfortable and happy with the performance implications of a handful of reference-counted pointers and everything else being automatically allocated/de-allocated on the stack or heap. That being said, if you use the wording like you used above, you’re going to continue to elicit this reaction if you don’t qualify the statement.

                                        Edited follow-up thought: I think part of what’s needed here perhaps is an education push about Rc/Arc, their frequency in Rust programs, when and why it’s okay, and how it isn’t going to ruin the performance of your program if a few are floating around.

                                        1. 2

                                          My initial reaction was to the use of Rc. If they had said Arc, I probably would not have responded at all.

                                          1. 1

                                            I apologize for communicating and interpreting imprecisely. I mentally glob them together.

                                            I think GTK is in fact the only time I’ve really used Rc. Everything else has been Arc I’m pretty sure!

                                2. 1

                                  The interesting point to me is that this use case (latency-sensitive service with extremely low rates of garbage production) was pathological for a tracing GC, and that optimizing it to produce less garbage made it even more so. Tracing collectors operate on every live object and ignore dead objects, so a heap full of live objects and very few dead ones is a bad fit for a tracing collector.

                                  I wouldn’t draw a general conclusion from the behavior of the Go garbage collector.

                                  Optimizing a system to produce less garbage is a standard optimization technique for the JVM and .NET.
                                  It is effective on these platforms because they both use generational garbage collectors.
                                  Long-lived or large objects are traced rarely or not at all.
                                  The LMAX Disruptor, for example, allocates all memory at startup.

                                  This technique isn’t effective for Go because the Go garbage collector forces a collection every 2 minutes.

                                  Go uses a conservative non-generational GC.
                                  Here are some of the tradeoffs of this design:

                                  • Conservative - objects are never moved in memory and the heap is not compacted.
                                    Interoperability with C is easier but heap fragmentation is a potential risk.
                                    Memory usage is lower than with a generational GC.
                                  • Non-generational - Generational garbage collectors can scan only recently allocated objects while ignoring old large objects. Most objects die young so this is often beneficial.
                                  • Pause times may be lower than a generational GC.
                                  • Lower implementation complexity.

                                  Neither design is right or wrong but I would be leery of using Go for a high performance system.

                                1. 27

                                  Was anyone else surprised Bram works on Google Calendar?

                                  1. 15

                                    I’ve been using Vim for almost 20 years and had absolutely no idea (1) what Bram looked like or (2) that he worked for Google.

                                    1. 3

                                      Definitely.

                                      Though I shouldn’t be, it seems like they hired a ton of the previous generation of OSS devs: thinking of things like vim, afl (uncertain, though the repo is under Google’s name now), kismet, etc.

                                      1. 2

                                        It’s just not what I would’ve guessed would be the highest and best use of his talents.

                                        I’m not saying I believed he was working on vim, I know better than that. I’m just surprised it was something so…ordinary and corporate.

                                      2. 3

                                        Yes! And that he sounds as if Google is still a start-up and not one of the biggest companies in the world. Had to check the date of the article. Of course it doesn’t feel like a startup, Bram…

                                        1. 2

                                          Maybe he means Google Zurich, which seems to have expanded by a lot lately?

                                        2. 2

                                          Me, honestly.

                                        1. 6

                                          The post author does not mention it, but there is also Haskell Programming From First Principles which she co-authored along with Chris Allen. Many beginner learners say good things about the book. Some, like me, who appreciate concise writing found it lacking. In the end, whatever book you use - you won’t make much inroads into Haskell (or any radically new tech for that matter) without actually trying to develop projects in it. That’s how we learn. Hands-on work.

                                          There is also Real World Haskell. Although it is a bit outdated (but being revived by volunteers), it contains great practical recipes.

                                          1. 9

                                            Totally agree with your point about actually getting your hands dirty. Haskell is no different from any other language in that regard. You’ll get nowhere simply flirting with the language and pondering poor monad analogies.

                                            The post author does not mention it

                                            I think there’s a reason for that, though I hope this thread doesn’t descend into an argument about that bit of history.

                                            1. 3

                                              Huh, did the two coauthors of that book have a falling out after it was published? I read it myself and liked it well enough, although I found it aimed at a level of Haskell understanding a little more basic than my own at the time I read it.

                                              1. 5

                                                Yes, though as I said I hope this thread doesn’t turn into all of us discussing it. There are statements from the authors and other discussions elsewhere, but let’s all leave it at that.

                                                Instead, we can talk about Julie’s subsequent work.


                                                I bought an early access copy of Finding Failure (and Success) in Haskell and I thought it was really good, especially for people new to the language. The exercises are practical, and help you understand the why behind the what. Motivating examples are so important. Otherwise, I think most people who see a tutorial like “Here’s how monad transformers work” would be like “Ok? But so what?”

                                                1. 2

                                                  Chris Allen (the other co-author) has branched off on his own as well, looking to publish the “next in series” book titled Haskell Almanac. Sadly, however, there has been no update on this book, just as there is none on the much anticipated Intermediate Haskell. Though luckily there is Thinking in Types by the author of polysemy.

                                                  As I see it, Haskell lacks intermediate level books more than beginners books.

                                                  1. 2

                                                    The final release of Haskell Programming from First Principles now has the OK. I’m releasing it by the end of this month. I’ll work on the print version after that. I have a printer that can do an offset print run ready to go. Just a matter of figuring out how many I should run and how to finance it. I have a climate controlled storage unit ready for the books. I never found a suitable solution for third party logistics so my wife and I will be shipping all the print books.

                                                    As I see it, Haskell lacks intermediate level books more than beginners books.

                                                    You’re right that this is the more immediate problem now. Over 5 years ago when I started on HPFFP making sure no beginner was left behind was the more pressing issue.

                                                    I have work to do on https://lorepub.com before it’s ready to sell print books (~1-3 days of coding and ops work from seeing the deployment for digital sales). Once the HPFFP print version is available for sale and that situation is stable, I’ll get back to the Almanac. After the Almanac, I’ll be seeing if I can be more productively employed as a publisher than an author. I believe the process we hammered out for HPFFP can be well applied to other topics and educational goals.

                                            2. 4

                                              Speaking of getting your hands dirty… There is the https://github.com/qfpl/applied-fp-course/ where you actually build a small REST backend with Haskell. Sort of a fill in the blanks style, independent levels of increasing complexity thing. :)

                                              Disclaimer: I’m biased, I wrote it.

                                            1. 9

                                              It depends on what you mean by “their copy of git”. As far as I’m aware, this comes in at least 2 different forms, possibly more.

                                              The backend component of the website, written in rails, most likely uses bindings for libgit2 (especially because GitHub maintains libgit2), probably rugged. Their development of libgit2 and rugged is fairly out in the open. The SSH service may use the actual git binary (or rather git-receive-pack/git-upload-pack).

                                              When I worked at Bitbucket, we used pygit2 and a small patch applied to git itself which improved NFS performance. There were a number of interesting edge cases which were tested for performance and accuracy which determined whether we’d call out to the binary with a very specific command or use pygit2, though all of that was hidden behind a wrapper library which abstracted out hg and git.

                                              It is theoretically possible to implement git-receive-pack and git-upload-pack in code rather that calling the binaries, but unless there’s a custom storage backend, this probably isn’t worth it.

                                              EDIT: the git/libgit2 patches from Bitbucket I’m aware of are listed below.

                                              1. 2

                                                unless there’s a custom storage backend

                                                I would be surprised if there wasn’t in GitHub’s case. Is there anything public about that?

                                                1. 6

                                                  Not directly, but they talk about how they handle replication with distributed operations at https://github.blog/2016-09-07-building-resilience-in-spokes/. I can’t seem to find anything on routing or how they handle repo accesses though.

                                                  There’s also some pretty low level stuff in https://github.blog/2015-09-22-counting-objects/ where they talk about what they did to optimize git clones for very large repos. They also mention “alternates” in passing which can be very powerful (we used these at Bitbucket for diffs - we generated the diff in a different working directory using alternates, but that’s because they use a very unique diffing algorithm).

                                                  As far as I can tell, GitHub tends to do a pretty good job of upstreaming any changes they make… and these blog post seems to imply that they’re using raw git under the hood for most operations, which makes sense. If you can use the canonical implementation of something, you probably should… especially if it’s the technology on which your whole product is built.

                                                  1. 7

                                                    Thanks! I found it after reading your comment:

                                                    I had a hard time believing they weren’t using a dfs or a specialized storage layer because I’ve worked on storage-at-scale problems before and you run into needing something fancy pretty quickly.

                                                2. 1

                                                  NFS? Really?

                                                  1. 1

                                                    Yep, it was a Netapp storage cluster which exported NFS volumes.

                                                    1. 3

                                                      I still have flashbacks to that exact setup. Of course this was at Apple so we were eating our own dogfood and using OS X as a client. It was very bad. I used to regularly find bugs in the NFS stack by searching our video sources for 1k runs of 0.

                                                1. 0

                                                  I knew my time would come! http://www.monohaskell.com/

                                                  1. 53

                                                    *writes a rant about how developers are petulant little children who care more about “convenience” and “fun” than “performance”*

                                                    *puts it on medium*

                                                    1. 19

                                                      I really hate this kind of response. It’s super-trolly and contributes nothing except making you feel good about yourself for somehow finding the “loophole” that allows you to ignore the valid objections raised in the article.

                                                      We don’t all have to be perfect paragons of virtue at all times in order to be allowed to complain.

                                                      1. 15

                                                        They’re blaming all performance problems on moral failings. These people are too whiny and self-entitled to care about the customers, so they use convenience trash like WEBPACK and BOOTSTRAP. Their language oozes contempt.

                                                        In that context, “you used a bloated website for personal convenience” shows how little they actually thought this through.

                                                        1. 5

                                                          No, it doesn’t. It shows the fact that they didn’t have the time to put up their own blog website and maintain the code for it, which is a PITA. Do you think that the author works for Medium and personally contributes code for their website? All of the people that already agree with the sentiment that “bloat is bad” are going to hoot at your epic comment and meanwhile the average person will look at it and be confused about why you’re such a dick about people not having the resources to maintain their own blog.

                                                          1. 21

                                                            He’s saying that people who trade performance for convenience are bad developers, and then he trades performance for convenience by using Medium. I don’t see anything wrong with trading performance for convenience. I see something wrong with him being an asshole to people who trade performance for convenience and then doing it himself.

                                                            If he doesn’t know how to post his stuff anywhere but Medium, then he probably doesn’t know enough about web development to make sweeping critiques about web developers.

                                                            1. 6

                                                              He or she knows stuff is bloated. He or she posting on Medium does not invalidate his or her knowledge of bloat.

                                                              She or he is not an asshole merely for pointing out that bloat is a problem and we’re all complicit.

                                                              1. 12

                                                                He’s not an asshole for pointing out bloat. He’s an asshole because he lays all blame for bloat squarely on the feet of people who use frameworks, calls them “McDonald’s line order cooks”, and claims anybody using a convenience is doing silicon valley cosplay.

                                                              2. 6

                                                                For basically every developer alive, blogging is not a job, and nobody is spending 40 hours a week doing it. What a ridiculous false equivalence. Some people have families and lives outside of work they must dedicate time to instead of idealistic puritanism, and can yet somehow still criticize the work they see happen on the job. Strange concept, isn’t it?

                                                                1. 4

                                                                  That’s a lot of snark when it’s not at all obvious why work-vs-hobby is a critical distinction for determining whether or not something is eligible for criticism. In particular, software businesses (like hobbyists) also have finite resources (notably developer time) and must make decisions about how to spend those resources. Contrary to the false dichotomy put forth by TFA, these businesses’ interests are generally aligned with their users such that choosing to spend developer time on new/improved features is often a better value for the user than performance. I’m a performance hawk, but even I don’t pretend that performance is the only valuable feature–that’s patently absurd. It turns out everything is tradeoffs, and the people ranting about web performance without acknowledging the tradeoffs aren’t worth listening to.

                                                                  1. 0

                                                                    Did you respond to the wrong comment?

                                                                    1. 1

                                                                      Nope. And I’m not sure what about my comment makes you suspect I was responding to the wrong comment.

                                                                      1. 0

                                                                        I didn’t say anything about businesses having “infinite resources” so I was confused when you suddenly changed topic completely

                                                                        1. 0

                                                                          Not changing the topic; just giving you the benefit of the doubt. I was responding to the most charitable interpretation of your ambiguous comment, because while the most charitable interpretations was still clearly wrong, it is more understandable and less nonsensical than other interpretations. Feel free to clarify your position.

                                                                          1. 0

                                                                            So what you’re saying is that you grafted nonsense onto my statement because people using their time away from work for anything other than being productive is nonsensical to you? I don’t see why I should clarify my position when you’re obviously just being a troll.

                                                            2. 1

                                                              webpack implements tree shaking. It is not a trash.

                                                            3. 3

                                                              Hate it or not, but it neatly reflects the problem. Easy trumps performant.

                                                              1. 2

                                                                I disagree that this is a trolly response. It’s sarcastic and brief to be sure, but it certainly accomplishes something. It points out that the author of this article is a hypocrite, and even if hypocrisy isn’t the same thing as being wrong, it’s good to know that someone is being hypocritical when evaluating how to treat people who are wrong in the way described.

                                                                1. 1

                                                                  You can make everyone a hypocrite if you try.

                                                                  https://thenib.com/mister-gotcha

                                                                  https://thenib.com/mister-gotcha-vs-the-green-new-deal

                                                                  It’s a cheap and pointless tactic of Status Quo Warriors. Nothing can be changed because we’re all hypocrites for living with things as they are now.

                                                              2. 12

                                                                *writes a rant about how developers are petulant little children who care more about “convenience” and “fun” than “performance”*

                                                                *puts it on medium*

                                                                This is quite a dismissal (appeal to ridicule?). Are people who post on medium not allowed to complain about web performance, simply because they post on medium?

                                                                1. 15

                                                                  They can both be right and be hypocritical, pointing out the hypocrisy isn’t wrong just because they’re right.

                                                                  If /u/hwayne said, “You’re contributing to the problem you claim exists by putting your article on medium, therefore your argument is wrong”, they’d be committing a logical fallacy. They’re not saying that though; they’re agreeing with the author about what the issue is, and pointing out that the author is needlessly contributing to it.

                                                                  1. 9

                                                                    I don’t actually agree with the author, because they didn’t do anything to support their claim. They just said “it’s devs’ faults for using frameworks” and left it at that. This comment has a different explanation:

                                                                    While frameworks add overhead, they are hardly ever the main source of bloat. In my experience, there is always lower hanging fruit than initial page size:

                                                                    • Analytics and trackers
                                                                    • Ads
                                                                    • Huge third party SDKs (e.g. social login or videos with ads/DRM)
                                                                    • Large images
                                                                    • Fonts

                                                                    Only the last two have to do with developers. The others are, unfortunately, the current business model of the web. )

                                                                    1. 4

                                                                      If developers didn’t make the decision to use the frameworks and libraries they use, then who did? Spooky ghosts?

                                                                      1. 7
                                                                        1. Are frameworks and libraries the primary cause of web slowness, or is it something else? How much does using frameworks and libraries contribute to slowness versus having tons of trackers and ads?
                                                                        2. How much faster would the website be if they replicated all of the functionality without frameworks and libraries? Is it enough to overcome the extra development time?
                                                                        3. Do devs use frameworks and libraries purely because of convenience, or are there other business constraints? Time to market? Responsiveness? Portability?
                                                                        4. Can the developers significantly improve performance without getting rid of the framework or library? Is the problem “they use a framework”, or “they haven’t had time to optimize their code, period”?
                                                                        1. 2
                                                                          1. Counter-question: have you ever in your life been employed to write client-side Javascript and the requirements didn’t list experience in one of JQuery, React, or Angular?
                                                                          2. Given that the greatest bottleneck for webpages is bandwidth and that tree shaking can only do so much, significantly faster if you’re on even somewhat poor internet (most of the US is) or a slow, congested device (a lot of the world is).
                                                                          3. This is a red herring because you’re assuming that because there are a multitude of justifications for development decisions that the developers making those decisions have no agency, which is absurd.
                                                                          4. Tree shaking has been mentioned many times on the page, but the moment a developer uses a scroll-based effect JQuery plugin or starts requiring DOM to be rendered through complex javascript, they are not only doing so because the architecture of the framework has inspired them to do so, but because the design of those libraries tell developers they don’t have to understand what the framework is doing. The problem is multitudinous, just like the justifications that you think relieve the developers of their agency in their decisions.
                                                                          1. 3

                                                                            Counter-question: have you ever in your life been employed to write client-side Javascript and the requirements didn’t list experience in one of JQuery, React, or Angular?

                                                                            Not the person you were asking, but yes, I have. Back when we called this stuff “DHTML”, and lamented that too many people copy/pasted snippets of JavaScript without understanding what they did.

                                                                            because the design of those libraries tell developers they don’t have to understand what the framework is doing

                                                                            There is no “bare metal” anymore. There is nobody who genuinely understands the entire stack anymore, and probably only a handful of people who even understand any single layer of it.

                                                                            Once, nearly two decades ago, I used to think I did, but even then it turned out I really didn’t. Everything from the JS library/framework to the language runtime to the browser itself to the operating system to the CPU it’s running on is full of too much deep magic for any one person to understand even with a lifetime to study it all. We are at the “if you want to make a pie from scratch, first you have to create the universe” stage.

                                                                            1. 1

                                                                              I mean, I wouldn’t equate the need for web developers to at the very least know the actual Javascript DOM API’s to a fancy for trying to understand “the entire stack” down to bare metal.

                                                                  2. 11

                                                                    I’m not dismissing them because they posted on medium! I’m not dismissing them because they complained about web performance on medium. I’m dismissing them because they say web devs are “an army of McDonalds line order cooks who fancy themselves as Michelin star chefs” on medium. If you’re going to be that contemptuous of web devs, you should at least show an iota of self-awareness about where you’re posting.

                                                                    1. 12

                                                                      1.2 MB transferred, 16.84s. That’s with an adblocker.

                                                                      No, they are not allowed to complain. A blog post this length easily fits in 200kb, with the worst CSS framework imaginable included, 10kb would probabaly be possible.

                                                                      1. 12

                                                                        They can complain all they like. I agree completely that Medium is a technologically subpar and gluttonous medium, but there are clearly non-technical reasons to use it, which (as evidenced) many people feel outweigh its shortcomings.

                                                                      2. 4

                                                                        I think it’s a form of whataboutism. Everyone lives in a glass house, so everyone should shut up and stop complaining, I guess.

                                                                        It’s a really cheap put-down, and I’m with you that it’s a ridiculous dismissal.

                                                                        1. 1

                                                                          There are many that do not like medium. To read content posted on medium I use a proxy that will leave only the content. Application is a of 10 minutes effort and the result is good enough - https://github.com/husio/readium

                                                                          Deploy your own instance or use https://readium-demo.herokuapp.com/@CM30/putting-devs-before-users-how-frameworks-destroyed-web-performance-6b2c2a506aab

                                                                          1. 2

                                                                            I think you’re correct to notice the mismatch in the medium and the message, but perhaps the channel was chosen specifically because the folks who may benefit most from the advice would read it on Medium instead of elsewhere.

                                                                            1. 6

                                                                              If they were choosing Medium specifically for that reason, they should have used Medium as an example. There was an essay a while back that did that: it said “you have to read this on Medium” and timed the complaints about medium’s UX to the exact points those UX problems manifested. Anybody else know what I’m talking about? I’m having trouble tracking it down.

                                                                              1. 2

                                                                                That sounds like a slick way of making a point!

                                                                                1. 2

                                                                                  Found it! https://lobste.rs/s/bn30zs/medium_is_poor_choice_for_blogging#c_udeux9

                                                                                  Turns out we both commented on it, haha

                                                                          1. 0

                                                                            If you were to get rid of prism.js and use static highlighting, how would you go about it?

                                                                            1. 3

                                                                              My personal static website generator uses gomarkdown and I just modified the renderer to pass through to chroma, which ends up looking like this. Obviously you could also use the original python pygments project this too, which is what I used to do when doing “staged” shell based rendering.

                                                                              1. 2

                                                                                I was also looking at https://www.gnu.org/software/src-highlite/ and considering building one myself in C (pretty sure I will at some point), but for web sites, I prefer to keep it on the client side in order to keep a clean HTML file.

                                                                                1. 2

                                                                                  That highlighting where package is colored as a keyword but function isn’t hurts to look at. ;) Since they list Ada in supported languages, it clearly warrants a pull request. Maybe I should make one.

                                                                                  1. 1

                                                                                    I actually attempt to auto-detect the language using Chroma in an effort to backport some colors into my older posts (like the one linked), it detected incorrectly. I gave it a hint and now it should look better, thanks for pointing it out.

                                                                                2. 2

                                                                                  Can you recommend me a good static highlighter? I think prism.js fits well for progressive ehancement,it doesn’t mess up the mark up for presentation.

                                                                                  1. 3

                                                                                    highlight is nice. I’m mostly asking about the workflow, what it would look like in the page source.

                                                                                    Ever since I’ve joined IASSGA[1] I’ve been thinking about generator workflows and their implications quite a lot. In soupault 1.7 we’ve added a function for piping element content through an external process, that was meant to enable using any syntax highlighter. Then I realized that you could also use it for adding a rendered version of that content alongside the source, instead of replacing the content.

                                                                                    [1] International Association of Static Site Generator Authors

                                                                                    1. 1

                                                                                      I’m mostly asking about the workflow, what it would look like in the page source.

                                                                                      I wouldn’t, haha, but probably an HEREDOC:

                                                                                      <h1>Highlight example</h1>
                                                                                      
                                                                                      <pre>
                                                                                      <code class=js>
                                                                                      #!
                                                                                      hl << EOF
                                                                                      function foo() {
                                                                                              var a = 1
                                                                                              console.log('foo')
                                                                                      }
                                                                                      EOF
                                                                                      #!
                                                                                      </code>
                                                                                      </pre>
                                                                                      
                                                                                    2. 1

                                                                                      Chroma is nice

                                                                                        1. 0

                                                                                          I really like microlight.js and it’s simple enough to port it to other programming languages (and use it for static highlighting).

                                                                                      1. 6
                                                                                        • Reviewing final release of https://haskellbook.com/
                                                                                        • Prepping Boutique for the release ( e-commerce app backing https://lorepub.com/ )
                                                                                        • Haircut and errands on Saturday
                                                                                        • Picking up sister-in-law on Sunday
                                                                                        • Spending week of Christmas w/ in-laws
                                                                                        1. 2

                                                                                          Awesome! Congrats on going “Final”!!!

                                                                                          1. 1

                                                                                            Thank you!

                                                                                        1. 2

                                                                                          I’ve actually wanted this for a long time. Gonna check it out, see what parts are open source.

                                                                                          1. 1

                                                                                            Can I use this for my public and open source repositories? The URL goes to a place that only seems to let me look ReactJS and popular jQuery plugins.

                                                                                            1. 1

                                                                                              You bet – aiding the maintainers is at the top of our objectives list. The best way to go about it is to log in via Github and then visit the page to request a new Open Repo import: https://www.gitclear.com/open_repo_requests/new

                                                                                              1. 2

                                                                                                Sorry, permissions are too broad, I’m not giving you access to my private repositories. You don’t need that to run a report on a public repository.

                                                                                                1. 1

                                                                                                  This always bothers me.

                                                                                                  I’ve ended up moving all my private repos into organisations so just so I can grant access to my public ones.

                                                                                            1. 4

                                                                                              Does it count as ‘boring Haskell’ if it starts by enabling 39 language extensions?

                                                                                              1. 3

                                                                                                Did you look at the list? It’s almost entirely syntax sugar extensions.

                                                                                                1. 1

                                                                                                  GADTs, existential quantification, multiparameter typeclasses, polykinds, rankntypes, scopedtypevariables, type families and datakinds are hardly syntactic sugar.

                                                                                                  I think enabling stuff like ViewPatterns is fine. That is syntactic sugar. RankNTypes is not.

                                                                                                2. 1

                                                                                                  They start with 39 extensions in their proposed standard library, by my hand count.

                                                                                                  “Boring” seems like a carefully-chosen word to distract from the obvious commercialization being attempted by the author.

                                                                                                  1. 4

                                                                                                    Distract? We’re trying to get paid to move more companies into using Haskell. That’s my (I’m Chris) job and the whole thesis of the article is that there is a highly productive subset of Haskell that is extremely useful in software projects operating under commercial constraints.

                                                                                                    The first line is:

                                                                                                    Goal: how to get Haskell into your organization, and how to make your organization more productive and profitable with better engineering.

                                                                                                    Your reply isn’t constructive and casts aspersions by claiming the explicit point of article is somehow an act of subterfuge. We just want people to start using better tools. For us programmers at FP Complete the reasons for that are selfish but straight-forward: we’re programmers who want to use the tools we like because they make our work less tedious.

                                                                                                    I want to get paid to write software in nice programming languages. I want to create more jobs where people get to get paid to write code using nice programming languages.

                                                                                                    1. 1

                                                                                                      The ‘highly productive subset of Haskell that is extremely useful in software projects operating under commercial constraints’ does not involve starting with 39 language extensions and a huge pile of extremely complex type system nonsense that results in awful error messages. If people want to use a language with cryptic type errors and high performance they should use C++.

                                                                                                      Haskell’s highly productive subset is Haskell with at most about 3 language extensions, all of which are totally optional, along with a set of well-built libraries. I’d avoid typeclasses entirely, and even if you don’t go that far, certainly I’d avoid GADTs, lenses of any kind, and anything to do with the word ‘monad’. No MTL or anything of that nature.

                                                                                                    2. 3

                                                                                                      I’m confused, is commercialization a good thing here or a bad thing?

                                                                                                      1. 1

                                                                                                        39 extensions in their proposed standard library

                                                                                                        That’s what I meant, whoops.

                                                                                                        1. 3

                                                                                                          A lot of language extensions are innocuous and useful. It’s not our fault those extensions haven’t been folded into the main language. What’s your point?

                                                                                                          1. 1

                                                                                                            The extensions haven’t been folded into the main language because they’re completely unnecessary. You do not need GADTs to write Haskell. Advanced type system trickery is exactly the sort of unnecessary crap that a ‘Boring Haskell’ movement should be not using.

                                                                                                            1. 1

                                                                                                              Many of those extensions are actually less well-thought-out than Haskellers think.

                                                                                                              It is widely acknowledged that, as a general rule, orphan instances are bad. One problem with them is that they allow third-party modules to introduce distinctions between types that were originally meant to be treated as isomorphic. (At least assuming you are a well-meaning Haskeller. If you wanted to allow third parties to subvert the meaning of your code, you would use Lisp or Smalltalk, not Haskell.)

                                                                                                              Then GADTs and type families are dangerous for exactly the same reason.

                                                                                                      1. 9

                                                                                                        Now, I’m not a Real Engineer, merely one of these computer-wrangling pretenders, but I am actually familiar with those things.

                                                                                                        I’ve now interviewed 16 people who started in trad engineering and moved over to software, and they unanimously agree that software is Real Engineering.

                                                                                                        1. 7

                                                                                                          I’m looking forward to the follow-up study where you interview people who crossed over in the other direction. And maybe some statistical rigor, if you want us to draw conclusions from your empirical research.

                                                                                                          1. 2

                                                                                                            I’ve so far talked to two people who crossed the other way, but they’re a lot harder to find :(

                                                                                                          2. 3

                                                                                                            From my perspective[1], I would agree that yes, the field certainly can be done as Real Engineering, but in prevailing widespread practice it’s far more often not.

                                                                                                            [1] I say this as someone with an undergraduate degree in engineering, but of the computer variety, so maybe only partway there.

                                                                                                            1. 2

                                                                                                              The challenge is there but as an industry we’re immature and generally bad at our jobs. That’s what people mean when they say this isn’t real engineering–because nobody’s doing the work. It’s slapdash.

                                                                                                              1. 0

                                                                                                                This doesn’t bear out with the first-hand experience of crossovers. “Real engineering” is also incredibly slapdash; I have heard too many horror stories from people in fields we idolize as “real”. And while we’re “immature”, there’s also a lot of innovations we’ve made in process that “real engineers” wish they did in their old jobs. Version control is the big one I hear again and again.

                                                                                                                There’s a lot we can do better, yes, but there’s also a lot we could be doing much, much worse.

                                                                                                            1. 2

                                                                                                              My dev environment is version controlled: https://github.com/bitemyapp/dotfiles

                                                                                                              1. 1

                                                                                                                Must be a different notion of what a fixture is than I’m accustomed to.

                                                                                                                Most of my tests are unit tests, property tests, or integration/functional tests. A lot of my tests will run DAL code or poke at the API and see what state the database is in. As a result, when I talk about fixtures I mean the data installed into the database post-table-truncation. Usually in Haskell I’ll also have a datatype storing all the data from the database in memory as a big Fixtures record, a pattern I picked up from a past employer.

                                                                                                                1. 5

                                                                                                                  I damaged the recoil spring guide rod in my competition pistol by installing it upside down. Rookie mistake! It now has a crack on one side but still works. Will have to see if I can machine one: only have a lathe and this isn’t quite a rotational only shape. Otherwise could try and silver braze the crack.

                                                                                                                  We’re also eyeing a 2nd vehicle, BMW i3, so a test drive maybe.

                                                                                                                  1. 2

                                                                                                                    I’m guessing (and hoping) that a failure of the recoil spring guide isn’t going to be dangerous to the shooter?

                                                                                                                    1. 1

                                                                                                                      Nope, and the crack is not on the side that’s subjected to mechanical stress: wouldn’t ever crack there if it was inserted properly.

                                                                                                                    2. 1

                                                                                                                      What’s your comp pistol?

                                                                                                                      1. 1

                                                                                                                        Browning Hi-Power GP Competition, the one with long barrel and muzzle weight.

                                                                                                                        1. 2

                                                                                                                          Browning Hi-Power GP Competition

                                                                                                                          Nice! Any opinions on the CZ comp models?

                                                                                                                          1. 6

                                                                                                                            Most 75/85 pattern matchguns are made with IPSC type shooting in mind: quick draw, high speed, large targets at close range. I do Nordic field shooting which is more precision oriented. It’s 6 shots per hold, typically at 25m but can vary from 15 to 180m. For IPSC you want one that can be quickly reloaded, has high mag capacity, accepts red dot sights, and is not unwieldy to draw. For Nordic it’s iron sights only so priority is on the largest sightline and the longest barrel (restricted to 6”).

                                                                                                                            I never shot CZ but used a Tanfoglio loaner for a while, which is an Italian 75 copy. It’s entirely fine but is a handicap in Nordic events. Right tool for the job etc.

                                                                                                                            1. 1

                                                                                                                              This was very informative, thank you!

                                                                                                                      2. 1

                                                                                                                        I assume that the upside down here refers to forward to backward? Or did you literally rotate the thing about its axis?

                                                                                                                        1. 1

                                                                                                                          No, literally upside down: the part has asymmetric lug engaging with the barrel and slide stop, and can be inserted both ways. Somehow I messed up after doing it right a few times already.

                                                                                                                      1. 23

                                                                                                                        I usually steal, I mean, get inspired by a theme on another site. I then manually edit the CSS and throw 99% out, and combine with CSS from other sites. It’s usually easy to get something that looks roughly like what you want, and very hard to get exactly what you want.

                                                                                                                        Of course, it won’t use the latest framework, but it’s javascript-free, artisanal, and people are usually surprised at how fast it loads.

                                                                                                                        1. 3

                                                                                                                          This is exactly what I did. I copied over a theme that vaguely looked like what I wanted, discarded the parts I didn’t need, then frobbed it until it looked good. (Few original LoC had remained by that time.) Some time later I rewrote the style from scratch using what I’ve learnt.

                                                                                                                          1. 2

                                                                                                                            This is what I did for https://bitemyapp.com/

                                                                                                                            It probably helps that I have some experience typesetting and like minimal/booky themes that focus on the type.

                                                                                                                            1. 2

                                                                                                                              I wouldn’t say that I’m bad at CSS, but I am pretty poor at coming up with originality. So, I end up pretty much doing something similar to you.

                                                                                                                              At the very least, I’ll get inspiration for design from other sites. Right now, I’m working on redoing my personal site as well (primarily my blog), and I’m really into Drew DeVault’s personal website. I also like Medium’s approach to focusing on the story content. I’ll probably end up doing an approach the combines them in some form.

                                                                                                                              I once had a colleague tell me that art is just regurgitation of other art.

                                                                                                                              1. 1

                                                                                                                                I like the site from crafting interpreters a lot, which is also hand-crafted (as it proudly declares in the footer). I checked out the source and it contains a comment along the lines “ is so beautiful it makes me want to cry”. Robert Nystrom seems like a nice guy.

                                                                                                                                Also, I really like the layout that stackedit.io generates.