1. 10

    This sadly feels like C++ will be bound by the part of the industry that just wants to live on legacy forever. So we’ll probably need to sacrifice C++ to them and use something new, if we want a modern C++.

    1. 7

      There are only two kinds of languages: the ones people complain about and the ones nobody uses.

      -Bjarne Stroustrup

      The commitment to backwards compatibility is one of the major reasons why C++ has gained such high adoption in industry. C++ is certainly not my favorite language, but being able to compile and run code from two or three decades ago without modification is massively important for infrastructure development, and few languages have demonstrated the same compatibility guarantees seen in C++.

      1. 3

        That Bjarne’s quote is annoying. It is obviously true (almost tautological), but completely sidesteps whether the complaints are valid or not.

        Backwards compatibility with problems of the past was already a hard constraint for C++98, and now there’s 20 more years of C++ additions to be backwards-compatible with.

      2. 6

        d and rust are both solid options for a modern c++ if you don’t need the backward compatibility. as others have noted, legacy support is one of the major selling points of c++; there is no reason for them to give that up.

        1. 4

          Explain please. Why do you think that? I only see new tools to use but my projects are my own.

          1. 6

            It’s regarding the non-breaking of the API and rather deprecation of std::regex etc. They’re not breaking it because apparently the industry will fork it otherwise. So we’re stuck with some bad decisions like forever.

            1. 2

              because apparently the industry will fork it otherwise

              Don’t they already fork it? Almost every C++ project seems to have some reimplementation of part of the standard library.

              1. 1

                There’s a really big difference between forking the standard (whatwg-style) and avoiding a few of the features of the standard library in favor of your own alternative implementations.

                1. 2

                  I very much doubt you’d see an industry fork. The companies with sufficient interest in C++ and the massive resources required to develop compilers are probably the ones pushing C++ forward.

                  What you would be more likely to see is some companies that just stop upgrading and stick with the latest release which doesn’t break compatibility.

                  If you did see any non-standard developments to said release, I expect they would be minor and not widely distributed. Those who are resistant to change are unlikely to be making big changes, and until relatively recently C++ has had very little in the way of a community that might coordinate a fork.

          2. 4

            Legacy code is code that’s worth keeping running. A significant part of C++’s value is in compatibility with that code.

            Causing an incompatibility that would be at the kind of distance from C++ that Python 3 was from Python 2 just isn’t worth it. If compatibility constaints are loosened more, Rust already exists.

            1. 3

              Legacy code is code that’s worth keeping running.

              Sure. The question is whether we have to keep punishing newly written code and new programmers (who weren’t even alive when C++’s poor decisions were made) with it.

              1. 2

                A language called “C++” but incompatible with the C++ that existing code bases are written in wouldn’t solve problems for new programmers working on those code bases. That is, you can’t change a language spec and fundamentally alter design decisions that existing code already was built on.

                Constraints on newly-written code depend in how the new code intermingles with old code. New code interleaved tightly into existing C++ code is constained by existing C++. For code that doesn’t interact with C++ at all or interacts with C++ through a sufficiently identifiable interface doesn’t have to be in a language called “C++”.

            2. 3

              Agreed. I believe that this kind of “modern C++” is Rust; there just has to be a way to keep C++ experts and their design mentality away from core development. Otherwise Rust will end up like C++.

              1. 3

                I’d disagree with a characterization that Rust is a modernized C++. I believe there are things in Rust that the people building C++ would love to have (epochs for example are a hot topic in that thread), but I don’t think it’s the language they would build if they could get out the chisel and compatibility break away not only ABI but maybe even syntactic decisions and more. Despite the lack of commitment so far to measly ABI breaks, with some of what’s seemingly in the pipeline really just transforming a lot of the day-to-day of working with C++, maybe all you’d need to end up with a “modern C++” is sort of a, uh “C+”. My personal choice for trimming to create a C+? Kill preprocessor directives with fire!

                1. 1

                  I could have said more precisely:

                  Rust is what C++ developers need. It’s not necessarily what they want.

                2. 1

                  …there just has to be a way to keep C++ experts and their design mentality away from core development. Otherwise Rust will end up like C++.

                  This comment makes me a bit sad. I understand the point that @soc is making, but I don’t think that the Rust community should ever be built on a foundation of keeping people out. The C++ community certainly struggles with a culture of complexity, but there is a lot that the C++ community can bring to the Rust community and vice versa.

                  1. 2

                    That and a lot of Rust’s core team are C++ experts already.

                    1. 1

                      Every language is built around a set of values that result in a self-selection process for potential adopters:

                      • The language has bad documentation? Keeps out people who think documentation is important. (See Scala.)
                      • The language keeps adding features? Keeps out people who think that adding more features does not improve the language. (See C++, C#, JavaScript, Typescript, Swift, Rust, …)
                      • Etc. etc.

                      For instance point number 2 – I have decided that Rust 1.13 is roughly the max language size I’m willing to deal with when writing libraries.

                      I have subsequently skipped all newer Rust versions and the features that were added in those versions. I can’t really “un-adopt” Rust, but I think I’m pretty far removed from usage that Rust devs would consider “mainstream”.

                1. 3

                  I’m always perplexed why people would leave GitHub for GitLab because of the Microsoft aquisition.

                  GitHub has many useful features (issue tracking, pull requests, integrated builds), so unless Microsoft began to blatantly embrace, extend, and extinguish, I see no reason to leave the platform just because a company that was anti-open source some 10 years ago bought it.

                  1. 5

                    It’s not all about the features for many people. Ideological alignment is important, too. Knowing your the customer, not the product, is also important. And even if you like the features - the purchase is a good impetus to take a new look at the competition, and maybe discover new features that GitHub’s behind the curve on.

                    1. 1

                      You mean vendor lock in?

                      I’ve been thinking about that for the past few days, but I probably won’t switch to sourcehut any time soon because I can’t find a good email provider (protonmail doesn’t support other clients without a bridge). I might try GitLab soon though.

                      1. 2

                        I usually recommend Migadu for email.

                        Full disclosure: sourcehut has an ongoing consulting arrangement with them, but I have advocated for Migadu since long prior.

                    2. 3

                      Just because someone did something repeatedly in the past, no reason to suspect they might do it again right?

                      1. 1

                        If we were talking about an individual I’d agree with you. But a corporation doesn’t necessarily work like that.

                        1. 1

                          A corporation is generally less trustworthy than an individual, as it can be sold to anyone at any time, and is generally guided by whatever is believed to be most profitable, irrespective of current or past behaviour. Should you expect them to revert to their previous attitude? Maybe not. Can you trust them to remain aligned to your interests and needs? Absolutely not.

                        2. 1

                          Considering the change in Microsoft’s leadership, I don’t think they would.

                        3. 2

                          GitHub has many useful features (issue tracking, pull requests, integrated builds)

                          These extras are precisely why it’s risky to stay on a platform where you don’t trust the owner. A git repo is fairly portable: you can easily transfer it to a different host, or even self host it. GitHub issues and pull requests aren’t portable: The more your project uses GitHub issues, pull requests and CI, the more painful it becomes to move to another platform in the event that GitHub starts serving malware (as SourceForge did) or charging for certain features (as many businesses with a free introductory tier do once users are locked into their platform).

                          Even when GitHub wasn’t owned by Microsoft, there were risks to be assessed, and a balance to be sought between present convenience and future sustainability. For many, Microsoft’s past bad behaviour increases the risk enough that it is worth at least mirroring projects elsewhere, and possibly leaving GitHub altogether.

                        1. 2

                          Linux 5.6 has mainline support for the Amazon Echo.

                          Words fail me.

                          Edit apparently flippant comments regarding huge open-source projects headed by a European with a name that starts with “L” are only applicable to one of them. I will take the critique under advisement.

                          More seriously, I was not aware that the Echo was a full-fledged Linux box, and my reading of this that the support was for some weird integration with its voice integration. There are (as far as I know) no Echoes for sale in Sweden, so I had no idea that this was an option for a small-ish cheap Linux box. Now I know more it sounds mildly interesting.

                          1. 15

                            At the risk of being offtopic, I find this kind of comment on Lobsters really irritating, to the point that I think there should be some sort of downvote reason along the lines of “comment so vague it doesn’t contribute to discussion at all”. I’m guessing you’re disappointed, but given that not everyone on this site has English as their first language, I’m not even sure that’s the case. If you’re going to include close to zero information in your comment, why even comment?

                            1. 5

                              I think “troll” should be replaced with “unhelpful” or “not even wrong”.

                              1. 2

                                spam is a good one.

                                1. 2

                                  I’d like to apply a flag like that to a number of the comments here: https://lobste.rs/s/t6xcjc/systemd_homed_service_merged

                                  Edit if you want a specific flag, either troll or off-topic works.

                                  1. 3

                                    Edit if you want a specific flag, either troll or off-topic works.

                                    I don’t think they do work. troll isn’t quite right, in that the person often isn’t trolling, they’ve just left out so much detail that their comment isn’t understandable (sometimes it might be understandable to a small clique who are in the know, but not a general audience). offtopic isn’t right, in that they are often referring to the topic, just not in a way that makes a meaningful contribution to the discussion. I try to avoid giving misleading “downvote feedback”.

                                    1. 3

                                      I see what you mean now. me-too ?

                                2. 10

                                  Why? It’s just an ARM device; why not allow people to hack it to run their own Linux on it?

                                  1. 6

                                    I’ll note that I read it the same way at first; it sounded like integration with the service, not booting on the device. There’s another article specifically about the Echo, but that makes it seem entirely unimportant. So I have no idea why that was even mentioned in the 5.6 stuff.

                                    1. 3

                                      Why? Mainline support makes it easier to take the hardware and repurpose it.

                                    1. 12

                                      As long as the source codes are available and the license is free, it is OK. The team developing Qt need money, it is not possible to work for free – so it is good if companies building their own products on top of Qt contribute financially.

                                      1. 6

                                        Agreed. A common misconception (which is evidently shared by the author) is that FOSS means you cannot charge for your work.

                                        The GPL (and, IANAL, but also LGPL since it’s derived from it) explicitly allow this behavior:

                                        https://www.gnu.org/licenses/gpl-faq.en.html#DoesTheGPLAllowDownloadFee

                                        https://www.gnu.org/philosophy/selling.html

                                        1. 6

                                          But Qt isn’t charging for GPLed software. They charge for a proprietary library that happens to be identical to a GPL library.

                                        2. 3

                                          The team developing Qt need money, it is not possible to work for free

                                          However, as this very post points out, their pricing model is still broken, so there’s no reason to believe these changes will make any more money for them.

                                        1. 4

                                          When I was working for Quby, I was unpleasantly surprised at how expensive Qt is, how little flexibility the Qt company shows when dealing with prospective customers

                                          Having witnessed similar licensing discussions with Qt in the past, I think that part of Qt-the-company’s problem is that they are incompetent when it comes to selling what they have.

                                          The user in question was already complying with the LGPL on existing platforms, but was considering deploying Qt application on a new platform and wondered whether it would be simpler to get a commercial license to avoid some of the hoop-jumping. The Qt company could have simply pocketed a decent fee to license Qt commercially for that platform. Instead, they tried to push for all-or-nothing (i.e. commercial license on all existing platforms), at an astronomical price. Whenever talks seemed to be going in a reasonable direction, Qt would recall their salesperson and send another in their place, effectively resetting the discussion. Given that the user was already complying with the LGPL, they walked away, used Qt under the LGPL on the new platform, and Qt got nothing from what should have been an easy sale.

                                          Talking of potential future KDE/Qt splits, I’d be interested to see an updated version of the graph in this blog post, if anyone knows how to get the data: https://pusling.com/blog/?p=362

                                          1. 3

                                            I wonder if Idris 2 (https://github.com/edwinb/Idris2) will help with any of the problems with Idris that you encountered. The Readme makes a few claims which might be relevant:

                                            • Better inference…
                                            • Better type checker implementation which minimises the need for compile time evaluation.
                                            • New Chez Scheme based back end which both compiles and runs faster…
                                            • Everything works faster :).
                                            1. 4

                                              Edwin said that some of the problems will in fact be addressed: https://twitter.com/edwinbrady/status/1216825355417399301

                                              1. 11

                                                In particular, I wouldn’t be surprised if a large part of the compilation performance problems were due to ST, which was a fun thing to try but now I think is far too complicated for what it achieves - linear types probably do the job better for the situations where it’s most useful - and the notation is pretty ugly too. Also the fact that it uses implicit conversions internally (which don’t, and won’t, exist in Idris 2) makes it very hard to get good error messages.

                                                It’s great to see people trying these things anyway! I’ll be interested to find out how Idris 2 deals with it, but I have a bit of work to do before it’ll be possible to try.

                                            1. 8

                                              The only real advantage of a touchscreen is its ability to change function.

                                              In a smart phone, this is essential, because you have a very small space which is sometimes a browser, sometimes a phone, sometimes a map, etc.. In embedded controllers, it can be a cost saving, in that instead of producing custom hardware to control different systems, you can mass produce one type of hardware and run different software on it.

                                              On the bridge of a ship you have plenty of space to play with, so there’s no need to pack too many functions into a single unit, and something as well funded as the US military shouldn’t be trying to save money at the cost of safety and functionality.

                                              1. 1

                                                I encountered this issue when Qt switched to using getrandom() by default. A simple upgrade to a newer version of Qt, and suddenly this small embedded device would hang on boot. It turned out that Qt’s text streaming file IO operators were using QHash (Qt’s hash table) under the hood, which needs some random data to initialize itself.

                                                The decisions (Using their own hash table internally, QHash using a secure algorithm, defaulting to a proper source of random data) make some sense, but it struck me as slightly absurd that as a result it needed a good source of random data to be able to read a text file.

                                                1. 3

                                                  Someone correct me if I’m wrong but it seems that in the absence of a hardware RNG, getrandom() can never be expected to work well. Collecting randomness based on interrupts is never guaranteed to unblock in any sort of reasonable time. Also it’s just a software heuristic that may not even meet the application’s criteria for randomness. Soap box here, but IMO ideally getrandom() should return EINVAL simply in the absence of a reliable hardware RNG and user-space can then take that as a signal to employ their own heuristics.

                                                  1. 2

                                                    I believe you can employ two tricks to achieve sufficient entropy in the situation where you do not have a hardware RNG:

                                                    1. You can save the entropy pool at shutdown and restore it at boot.
                                                    2. For the first boot of a device, I think you can pre-seed it with entropy from somewhere else.
                                                    1. 1

                                                      I think in a case where user-space seeded the kernel with randomness like that, I would support that also being a situation where getrandom() didn’t return EINVAL. At the same time, it may not even be necessary for the kernel to be involved unless it needed randomness itself (which I guess it often does).

                                                    2. 1

                                                      I hit this problem with a custom GCE image, for whatever reason they sometimes gave me a VM without rng. I had to send some extra randomness encrypted with the boot metadata.

                                                    1. 5

                                                      Do folks using ligatures not incur the cognitive cost of wondering what two (or more) keys were pressed to create a given ligature? Especially when reading other peoples’ code. This is a nice customizable font, but I’m set in my ways w/ source code pro.

                                                      1. 5

                                                        Iosevka has the term variant for people who don’t want ligatures.

                                                        Agree on Source Code Pro, an amazing font.

                                                        1. 4

                                                          Not really–the ligatures are just stylized combinations of the keys in most cases. >=, <=, !=, and == all become one syntactic element when reading, and in practice I have no trouble typing them. And they are especially nice in closures and lambdas.

                                                          1. 1

                                                            As an Emacs user, it sounds like everything prettify-symbols-mode does. Is there any real benefit, giving that one seems to give up dynamic reprogrammability, that ligatures have to offer?

                                                            1. 2

                                                              For reference, vim has something similar called conceal that people use for rendering latex in unicode and so on.

                                                              1. 2

                                                                I haven’t used prettify-symbols-mode specifically, so this may not apply, but when I tried similar things in the past, the problem was that it was generally replacing two or three characters with one character, meaning that either it messed with alignment, or it had to try and do weird things like surrounding the symbol with two half-width spaces.

                                                                Personally, I use the Hasklig font, and find that the ligatures look good, but it’s also unobtrusive enough that I just set it as my terminal font (I use Konsole, which supports ligatures) and use it everywhere, rather than trying to only use it with certain files (When I’m using a GUI editor or IDE, I usually use Hasklig as my font there too).

                                                                1. 1

                                                                  I hadn’t run across prettify-symbols-mode, thanks for mentioning it! I’ll take a look at it.

                                                                  1. 1

                                                                    giving that one seems to give up dynamic reprogrammability

                                                                    Can you expand on this? As I understand it, nothing is changing in the actual textual content when using ligatures, so I’m not sure what you’re referring to.

                                                                    Is it just in comparison to prettify-symbols-mode where you create your own mappings?

                                                                    1. 2

                                                                      My understanding is that you can’t (easily?) turn specific mappings or as you say add ones by manipulating a variable (i.e. dynamically reprogramming), but it’s kind of “set” in the font.

                                                                      1. 2

                                                                        Ah, I see, thank you.

                                                                        I had never considered changing ligature mappings dynamically, though the fact that this release has different ligature sets for different languages presents a usecase I hadn’t thought of before.

                                                                        I wonder if doing these mappings in opentype rendering vs in the “editorspace” so to speak would make a difference performance-wise, sort of like what’s happened recently with bringing linum-mode into C.

                                                                  2. 1

                                                                    But what if say you’re reading some code in OCaml with <> or Fortran with .NE. and /= While those would probably not be ligatured, if they were it could be super confusing. I agree that there’s a certain elegance to the look, the ergonomics of not knowing what was typed to create something means you could conceivably half erase something and not know how to retype it.

                                                                  3. 1

                                                                    Ligatures in code listings sound like a nightmare to me.

                                                                    Is it just a display thing? I.e. my code has “>=” while I see ‘≥’ in the editor? [1]

                                                                    1. 2

                                                                      That’s right. In editors like Sublime or VSCode, you can turn off ligatures if you don’t like them; in the case of Iosevka, you can also download a version that does not have ligatures (the term variant).

                                                                      1. 2

                                                                        Yeah it’s just that, your code still lives on disk as >= but the font does a ligature like it might do with fine or flare (the fi and fl merging) in a wysiwyg word processor. The difference is fine and flare still preserve the 2 characters visually, many of these ligatures toss them completely and sometimes go from 2 fixed width chars to 1 which makes alignment a bit strange as well. Though in some cases it could be much nicer.

                                                                    1. 2

                                                                      Newer languages are not more likely to have CRs

                                                                      This surprised me. The median age of a language with a CR is 24 (1995)

                                                                      Looking at the table, it is worth noting that in many cases the “appeared” date used is the date the language appeared, not the date at which the package manager appeared. For example, javascript is listed as appearing in 1995, but the npm package manager which the stats refer to didn’t appear until 2010 (according to wikipedia). It would be interesting to have a plot with the year the package manager appeared instead of the year the language appeared.

                                                                      Also, I’d prefer if the y-axis scale was kept logarithmic, but labelled with numbers of packages, not log of number of packages.

                                                                      1. 5

                                                                        I just started using Python in earnest this year and I was constantly infuriated by examples and modules that were Python 2 but had no indication until you started using them. Over and over I’d find a neat module that did exactly what I wanted but then I’d find out it was Python 2. Absolutely maddening.

                                                                        1. 1

                                                                          Can you give some examples? I found that years ago there was a lot of this, but many libraries I use now are Python3-only, and many of them even explicitly Python3.6+ (probably to use f-strings).

                                                                          1. 1

                                                                            These were very hardware-oriented modules for doing robotic related things. The primary one that I needed was an interface for iRobot’s open platform: https://github.com/pomeroyb/Create2Control. I gave up and made two separate scripts because I needed Bluetooth from Python 3 libraries.

                                                                            1. 2

                                                                              I’ve had a very similar experience with various Raspberry Pi hardware add-ons. The vendors typically provide a python library to interface with the hardware, but it’s often not updated after it’s released. Try to build something with 2 or more bits of hardware and you find a horrible mess of mismatched python versions and mismatched dependency versions. Worst of all, you don’t find out until runtime whether two versions are incompatible.

                                                                          2. 1

                                                                            This year? I’m not disputing your experience, but that’s surprising to me since the the community as a whole has been firmly on Python 3 for years now. http://py3readiness.org/ is all green, etc.

                                                                            1. 3

                                                                              These were very hardware-oriented modules for doing robotic related things.

                                                                              1. 2

                                                                                I for one am not surprised. The long tail is pretty long still. We’ll be dealing with infrequently maintained domain specific Py2 codebases and docs for many years to come.

                                                                                1. 1

                                                                                  I wish I’d known about the “Can I Use Python 3?” tool that is on the page @kbd linked to. That would have saved me some frustrating moments. https://github.com/brettcannon/caniusepython3

                                                                          1. 2

                                                                            I thought it would all be worse, but it really doesn’t matter - I don’t need to look at what I’m typing as I type it, only after it’s been written, as to proofread.

                                                                            1. 2

                                                                              I think it makes a massive difference whether you’re typing lots of text (and don’t really need the feedback from the screen), or editing, where you need to move the cursor about and wait for the feedback that the cursor is in the correct position (There may be exceptions, e.g. if you’re familiar with an editor like vim, you can type a sequence of commands with the confidence that it will move to the desired position and perform the required edit. However, a single mistake can completely alter the whole sequence of commands).

                                                                              1. 0

                                                                                Even when editing I know what I should be typing before I type it; else it’s extra work for no reason.

                                                                            1. 25

                                                                              With respect to email, don’t forget that pull requests were once intimidating too - as anyone who frequently works with onboarding new developers to its workflow can attest. To help make onboarding users with email easier, I wrote this tutorial:

                                                                              https://git-send-email.io

                                                                              I also wrote a rebase guide which applies to both workflows for making your changes more consistent and easier to review:

                                                                              https://git-rebase.io

                                                                              1. 26

                                                                                https://git-send-email.io

                                                                                That nicely outlines how to send patches, but I think people have far more difficulty receiving patches via email. Not everyone uses mutt, aerc, or runs a patchwork instance. Many mail clients, that people are otherwise generally fairly happy using, are just super not great at handling emailed patches. Emailed patches also generally don’t show a CI status that you can view ahead of time (I have heard of some, but I don’t ever remember seeing it firsthand in the wild).

                                                                                It’s great that it (an email patch workflow) works well with your workflows and tooling, but for some people it just… doesn’t work as well.

                                                                                1. 4

                                                                                  I mean, those people who don’t have such a mail client are missing out. It’s like arguing that we should use SVN because not everyone has git installed, in my opinion. And testing your patches against SourceHut CI is pretty easy, before or after it’s sent.

                                                                                  1. 26

                                                                                    I think one issue is that for most of us, sending and receiving patches is a very small part of what we do with email, so choosing a mail client on that basis doesn’t make sense.

                                                                                    1. 1

                                                                                      But we aren’t forced to use only one mail client. I use several depending on context / the task at hand.

                                                                                      1. 1

                                                                                        I am curious about your multiclient workflow. Do you use multiple addresses, or use filters and one shared address? Or just all the mail in all of them?

                                                                                        1. 4

                                                                                          Whether you use local maildir or imap, mail stores are designed for concurrent access. How many people check email on their phone and not their phone?

                                                                                          1. 1

                                                                                            Sure, but my question was specifically about their workflow with it.

                                                                                          2. 2

                                                                                            As it happens I do use multiple accounts for multiple “hats”, but that’s slightly orthogonal to multiple clients, which I use even for a single account. My daily driver is mutt; I use thunderbird for rare occasions when I need to see rendered html properly or perform a search (still haven’t got mairix or not much etc set up) and I often use ios mail app but mostly read only.

                                                                                            At work we use Gmail. I do check that from ios mail app too. I recently started configuring mutt to read my work mail too but it’s a work in progress so I still regularly open the Gmail website.

                                                                                      2. 23

                                                                                        I mean, those people who don’t have such a mail client are missing out. It’s like arguing that we should use SVN because not everyone has git installed, in my opinion.

                                                                                        To me it sounds a bit more like arguing “anyone who doesn’t ride a penny-farthing to work every day is totally missing out”.
                                                                                        Well…maybe.. I do find it unlikely that is going to convince very many people who weren’t already riding them, or weren’t already inclined to do so. Even if it is amazing.

                                                                                        Sidenote1: I may be wrong, but it even appears that Mutt itself uses gitlab instead of email based patches. If true, I find that oddly humorous.

                                                                                        Sidenote2: I have nothing against email based patch flows, and if I am going to contribute to a project, I generally contribute in whatever form a project requires (within reason). But for my own projects, I do not desire an emailed patches based workflow (EPBW), nor do I desire to run/manage/admin/moderate(remove spam) a mailing list. That’s just me though.

                                                                                        1. 7

                                                                                          To me it sounds a bit more like arguing “anyone who doesn’t ride a penny-farthing to work every day is totally missing out”.

                                                                                          I don’t really like this take. Having sunk thousands of hours into the GitHub, Gerrit, and email-driven workflows, I can confidently assert that the email-driven workflow, even setting aside the many respects in which it is politically and technically superior, is simply the most efficient for both contributors and maintainers. The penny farthing comparison is unfair.

                                                                                          Sidenote1: I may be wrong, but it even appears that Mutt itself uses gitlab instead of email based patches. If true, I find the humorous.

                                                                                          Mutt uses Gitlab and mailing lists and Sourcehut, actually. The dominant avenue of contributions to mutt is through its hosted mailing list. They use Sourcehut CI, however.

                                                                                          Sidenote2: I have nothing against email based patch flows, and if I am going to contribute to a project, I generally contribute in whatever form a project requires (within reason). But for my own projects, I do not desire an emailed patches based workflow (EPBW), nor do I desire to run/manage/admin/moderate(remove spam) a mailing list. That’s just me though.

                                                                                          That’s why Sourcehut can do it for you.

                                                                                          1. 9

                                                                                            I don’t really like this take. Having sunk thousands of hours into the GitHub, Gerrit, and email-driven workflows, I can confidently assert that the email-driven workflow, even setting aside the many respects in which it is politically and technically superior, is simply the most efficient for both contributors and maintainers. The penny farthing comparison is unfair.

                                                                                            A bit of an “Ipse dixit”, but I’ll take it at face value anyway. To be clear, my comment was in response to your statement:

                                                                                            I mean, those people who don’t have such a mail client are missing out.

                                                                                            Which is what I made the comparison against. You have now pulled in other concerns in your response, and attributed them to the comment I made. I find that a bit uncharitable. I guess at this point we can just agree to disagree.

                                                                                            Mutt uses Gitlab and mailing lists and Sourcehut, actually. The dominant avenue of contributions to mutt is through its hosted mailing list. They use Sourcehut CI, however.

                                                                                            That’s odd. I looked through the last 2 months of their mutt-dev mailing list, and saw no mailed patches, but several gitlab PRs. Maybe I saw the wrong mailing list? Maybe I didn’t go back far enough? Overlooked it?
                                                                                            It doesn’t really matter, and I’ll take your word for it that they predominantly use emailed patches.

                                                                                            1. 2

                                                                                              The last 2 months have only seen one patch on Gitlab:

                                                                                              https://gitlab.com/muttmua/mutt/merge_requests?scope=all&utf8=%E2%9C%93&state=merged

                                                                                              After reviewing it myself I have to correct myself, I reckon that Gitlab and the mailing lists are at about an even pace these days.

                                                                                              1. 2

                                                                                                Do note: that was merged PRs. There were a couple of more (not many though!) in All which is what I looked at.

                                                                                        2. 5

                                                                                          Not everyone is productive using such mail client. Personally, I just plainly cannot remember more than a few shortcuts, which is already a massive roadblock for effectively using CLI tools as for most of them rely on shortcuts to increase productivity, they also do not provide me with options of what I can do, and I cannot for my life remember what can I do for all the possible contexts, cause of course options on what you can do are dependent on the context which you are currently in. Some people just aren’t productive using CLI tools, and saying that they “are missing out” because they plainly cannot effectively use the tool is simply gatekeeping.

                                                                                          1. 3

                                                                                            saying that they “are missing out” because they plainly cannot effectively use the tool is simply gatekeeping.

                                                                                            This is absurd. If a mechanic decides that he “is not a ratchet person” and will only ever use open-end wrenches, then I will question his professionalism just as I would question a software developer that “is not a CLI person” and will not learn to use a CLI mail client.

                                                                                            He doesn’t need to use the CLI mail client for his day-to-day email, but he should be capable of learning how to use it to handle the occasional emailed patches.

                                                                                            1. 5

                                                                                              Or this person will work with whatever, when paid for (professionals are paid for their work by definition!), but will only work with tools he/she finds enjoyable when doing charity. Thus FLOSS projects forcing inconvenient, last century methods with arrogant communication are missing contribution.

                                                                                              I thing the FLOSS community should focus on this kind of openness more, instead of CoCs.

                                                                                              1. 3

                                                                                                Good point. For work I’ll use whatever tools get the job done, no matter how gruesome. But for FOSS contributions, I agree that if the tool is difficult or simply frustrating to use, then it may as well not exist.

                                                                                              2. 1

                                                                                                Wrong assumption. Difference between using GUI and CLI clients is not like between open-end and ratcheted wrenches. Using those wrenches is basically the same. Meanwhile the experience between using CLI and GUI mail client is a lot bigger. I’d compare it to using automatic and manual wood planes. You can work with higher precision and similar speed with manual hand plane, but most carpenters would choose automatic hand plane, as it “just works” and doesn’t require that much skill and learning to do.

                                                                                                And why should you care what kind of wrench does your car mechanic uses, if he does the job well? This isn’t a problem not using better tools, but a problem of tool abilities. The tools that an average developer uses does not represent the tools that are created for that workflow. And that is a problem.

                                                                                                1. 2

                                                                                                  I’ll entertain the analogy to a wood plane, though I’m unfamiliar with the devices. You say it yourself: the manual wood plane is useful in certain circumstances but requires skill. So does the CLI mail client. Use the automatic wood plane where it fits, but at least learn the skill to use the manual wood plane where the higher precision is necessary.

                                                                                                  A developer that refuses to acquire a skill is simply not professional.

                                                                                                  1. 1

                                                                                                    It’s not like it requires much skill. It is the basically the same skill. The difference is, you need to move the manual wood plane along the plank 10 times, while with automatic you only need to move it once and the motor does its job. Some people just don’t have the patience and/or physical stamina to use manual wood plane. Manual hand plane is in fact more configurable, and can be used in more specialized scenarios. So enthusiasts use hand planes. Your average carpenter does not.

                                                                                                    1. 2

                                                                                                      The analogy was not mine.

                                                                                              3. 0

                                                                                                Consider acme?

                                                                                                1. 2

                                                                                                  I am unable to find such email client. And the point is, for a workflow to be usable by a wide range of people, it should require as little new tools that do the same as the ones they use. And in case of email clients, most people probably like their current email client, and they do not want to change it. So they, in turn, do not want to switch to this new workflow, which, while potentially increases productivity, requires them to switch to tools they do not like.

                                                                                                  1. 4

                                                                                                    acme is a text editor which can be easily coaxed into being a mail client.

                                                                                                    Consider as well that you needn’t discard your daily mail client in order to adopt another. What difference does it make if some technology is backed by email or by some other protocol? Just because you already have an HTTP client (e.g. your web browser) doesn’t mean another isn’t useful (e.g. curl).

                                                                                                    1. 7

                                                                                                      Acme does not seem like general user friendly. My colleagues all use JetBrains IDE’s and use Thunderbird as their mail client. And acme would be a downgrade for their experience. I might use it, but they wouldn’t. If I cannot offer them a good GUI email interface, there is no way they would switch to email-based workflow.

                                                                                                      1. 0

                                                                                                        I was recommending acme particularly for you, given the following:

                                                                                                        I just plainly cannot remember more than a few shortcuts

                                                                                                        If your colleagues won’t join you I consider your colleagues to be in the wrong, not the software. A bicycle is easier to use than a car but it’s not going to get you to the other end of town in time for the movie.

                                                                                                        1. 14

                                                                                                          If your colleagues won’t join you I consider your colleagues to be in the wrong, not the software.

                                                                                                          Don’t you think peace within a team is more important than any particular software or workflow? Or, to put it another way, the feelings of people are more important than any workflow, so if a large group of people reject a workflow, it’s better to conclude that the workflow is wrong for those people than to say that those people are wrong.

                                                                                                          1. 7

                                                                                                            My colleagues wouldn’t join me because the workflow is bad, but because there is no tooling suitable for them and the workflow. If tooling for a specific workflow just isn’t comfortable for me, I’m just not going to use it.

                                                                                                            1. -8

                                                                                                              Then you ought to be coding in basic. Good things often require effort.

                                                                                                              Edit: this comment seems to be being misinterpreted, so a clarification: I’m not earnestly suggesting that he should use basic. I’m extending his logic to an incorrect conclusion to demonstrate the flaw in his argument. Most languages are harder than Basic, therefore Basic is more comfortable, therefore why ever learn anything else? Obviously it doesn’t make sense.

                                                                                                              1. 18

                                                                                                                You are literally making the exact same argument that @ignaloidas’ colleagues are. The only difference is that the tooling you find suitable and the tooling they find suitable is a null set. They want to be in JetBrains’ IDEs, you want to be in email. You built tooling that demands email-based workflow because it’s what you want and then tell them they have to change; they’ve got tooling that demands GitHub (or a workalike) and then tell their colleagues that they have to change.

                                                                                                                As an aside, I pay for and generally enjoy using Sourcehut, and I respect your diehard allegiance to email, but you’ve got to quit acting like this in the threads. I get that you love an email-based workflow, and find it superior for your use cases. Having used Git and Mercurial since, what, early 2006 I guess—certainly before GitHub and Bitbucket existed—I disagree (especially when your workflow starts to involve binary assets, so most websites, games, mobile apps, and so on), but I’m also comfy in that workflow, and happy to support an SCM that fully supports that flow. But if you insist that people who do not use your workflow are wrong, and do so in this offensive manner, you’re going to start losing customers.

                                                                                                                And as an aside to that aside, you need to do what you want with Sourcehut, but the fighting against this on principles to me, as a former SCM lead, looks a bit forced: looking at this whole thread, and thinking back to a very early comment, all you’d have to do to satisfy him is to make temporary branch names that can be pulled in some mechanism based on the patch series. That’s it. It’s not trivial, but it’s also not that difficult, since you’re already doing 90% of that with the patch view. If you don’t want to do it, that’s fine, but it seems like that’d still mandate patch-accessible workflows, while also meeting the PR crowd a bit.

                                                                                                                1. 2

                                                                                                                  Note about the JetBrains’ IDEs. It’s not like they are incompatible with with email driven workflow, they just have tools that are better suited for pull-request workflow. I gave JetBrains IDEs as an example of what an “average” developer as I know it uses from day to day, as it seems that many bloggers have a distorted view of “average” developer. Average developer actually doesn’t want to fiddle with settings and try 10 different variants before deciding to use one. They want tools that “just work” without massive setup. Average carpenter wants a table saw that simply does the job they want to, they do not fiddle around it to make it the best saw for them.

                                                                                                                2. 14

                                                                                                                  Hi this is not a very nice tone, please try to argue in good faith.

                                                                                                                  1. 13

                                                                                                                    Is insulting prospective customers really the best way to grow your business?

                                                                                                                    1. 0

                                                                                                                      That was no insult, it was a logical extension of his logic. I didn’t mean it sincerely, I was using it to explain his error.

                                                                                                                    2. 2

                                                                                                                      Ok, in simpler terms. I would probably still use an SUV instead of Smart even if Smart can go through some shorter paths, because I feel cramped when driving it. Same with software. Some software is in fact more useful than other, but is harder/inconvenient to use for some than software which doesn’t have those fancy features.

                                                                                                                      1. -5

                                                                                                                        This isn’t such a case. This is a case where you (or your colleagues, I’m not sure at this point) are refusing to try unfamiliar things and, being ignorant of the experience, asserting it’s worse.

                                                                                                                        1. 3

                                                                                                                          It is. The thing is, I have tried mutt and aerc, and the problem is that I just plainly am not comfortable using bigger CLI programs, that is, those, whose scope goes out of pipes and command line rguments. About the only programs that of such style that I can use is nano and htop, only because they have a handy shortcut guide in the bottom at all times. Acme is also not the kind of editor I would like to use casually. It is easy to blame the people that don’t use it, without understanding the reasons why they don’t use it.

                                                                                                                          1. 0

                                                                                                                            You didn’t know anything of acme not even 2 hours ago. You’ve evaluated it in that time?

                                                                                                                            Herein lies my point. I have a vision and I must at some point exercise my creative authority over the project to secure that vision. Yes, it’s different from what you’re used to. You can construct reasons to excuse this away, but I fundamentally believe that being unwilling to learn something new is the underlying problem. As evidence, I submit that there’s no way you could have given acme a fair evaluation since my suggestion of it. I don’t consider this sort of behavior acceptable cause for changing my system’s design to accomodate.

                                                                                                                            1. 12

                                                                                                                              As someone who used Acme for two years, @ignaloidas does not sound like someone for whom Acme would even be worth trying. It’s great, but incredibly dependent on how you want to use your editor. You can’t disable word wrap, or use any shortcut to move the cursor down a column, for Christ’s sake. It’s really not for everybody (perhaps not even most people).

                                                                                                            2. 2

                                                                                                              So they, in turn, do not want to switch to this new workflow, which, while potentially increases productivity, requires them to switch to tools they do not like.

                                                                                                              What happened to using the right tool for the job?

                                                                                                              1. 1

                                                                                                                The question here is not about “the right tool for the job” but about the usability of those tools for the wider audience. Currently I do not see the majority of the developers switching to email-based workflow purely because of the usability of tools. “Rockstar developers” think that CLI’s are very usable and productive, but that is not the case for the average programmer.

                                                                                                                1. 3

                                                                                                                  “Rockstar developers” think that CLI’s are very usable and productive, but that is not the case for the average programmer.

                                                                                                                  Good to know that we were all rockstars for decades without realizing it!

                                                                                                                  This is probably just an age thing but I don’t know any professional programmers who aren’t comfortable with CLIs.

                                                                                                                  1. 3

                                                                                                                    There is CLI, and there is CLI application. Git is used through CLI. Vim is a CLI application. Surely you know at least one professional programmer that isn’t comfortable with Vim and alike.

                                                                                                        2. 3

                                                                                                          I am not particularly experienced at using git with email. One problem I have had in the past is when I want to pull in a patchset from a mailinglist archive, where either I am not subscribed to the mailinglist, or wasn’t subscribed at the time when the patches were sent. Can these mail clients help me with this problem? (By contrast, I find it very easy to add a branch / PR as a remote and pull or cherry-pick commits that way)

                                                                                                          1. 3

                                                                                                            lists.sr.ht, the sourcehut web archive for mailing lists, has a little copy+paste command line thing you can use to import any patch (or patchset) into your local git repo. Here’s an example:

                                                                                                            https://lists.sr.ht/~sircmpwn/aerc/patches/7471

                                                                                                            On the right, expand the “how do I use this” box and a short command is given there.

                                                                                                            Integration directly with your mail client would require more development but isn’t necessarily out of the question.

                                                                                                            1. 3

                                                                                                              That’s good to see, but presumably doesn’t help for non-sourcehut mailinglists?

                                                                                                              1. 3

                                                                                                                No, I’m afraid that there are fewer good solutions for non-sourcehut mailing lists. Patchworks has a similar feature, if the list in question has that set up. You could also ask someone else for a copy of the mail. I don’t think this damns the idea, it just shows that we need better software to support the idea - which is what sourcehut tries to be.

                                                                                                      2. 2

                                                                                                        I am still trying to find some time to check out Sourcehut. My only concern is how to configure it to run CI builds on mailing list patches as I couldn’t find it anywhere in the docs.

                                                                                                        1. 1

                                                                                                          This hasn’t been implemented yet, but it will be soon.

                                                                                                          1. 1

                                                                                                            Great. If that happens I will think about migrating some of my personal projects to the Sourcehut as it seems pretty as a pretty nice solution.

                                                                                                      1. 5

                                                                                                        I think the issue is that SV is driving a certain level of pay. But as remote work becomes more and more accepted companies outside of SV are having to compete at wages that are close to SV prices. I live in a medium sized urban American city and our tech wages used to be some of the lowest in the country. Like 40-50k a year. Due to the acceptance of remote work I was able to force a local company to pay me a wage in the mid six figures because I could point to remote wages and say I can get a remote job making x living here why would I work for you for less? So now I’m in the top 0.5% of my states wages because I used the remote market to drive a much higher wage.

                                                                                                        1. 2

                                                                                                          I’m a little surprised that the Silicon Valley companies are offering the same or similar (Is this what you’re implying?) wages for remote work as on-site: I would expect them to offer a lower wage on the basis that you don’t need to cover the cost of living in Silicon Valley (while still offering a little more than any company local to you).

                                                                                                          1. 2

                                                                                                            The wage they offer you is based on what you can convince them you are worth to someone. If you’re a senior engineer and want to work remote, get multiple offers, find a company willing to pay Bay Area compensation for remote work. The other companies then have to compete with that.

                                                                                                            I know of several remote engineers who have that arrangement.

                                                                                                            1. 1

                                                                                                              I’ve seen a few friends get offers in the mid to upper 100k’s from SV companies. I was first offered below 100k at my current job and the pressure of those remote salaries allowed me to push for a significantly higher rate then they would have offered me otherwise.

                                                                                                          1. 3

                                                                                                            This looks pretty great! Moving to CMake seems like the smart move, and I’m super psyched at their continued level of investment in Python.

                                                                                                            Kinda sad about their intent to move away from OpenGL and to Vulcan, Metal and Direct3D though. I guess the idea of one 3D graphics API to rule them all is dead?

                                                                                                            1. 4

                                                                                                              Apple claims that they’re going to remove opengl support from MacOS at some unknown point in the future, Qt is just preparing for that I guess.

                                                                                                              1. 4

                                                                                                                Apple is super annoying these days :) (I mean, I know they always have been, but lately I feel like they’ve turned it to 11, or maybe just in areas I care about!)

                                                                                                                I wonder if Vulcan is a possibility on OSX. Betcha it will be once all the game studios start writing for Google Stadia (Ungh.)

                                                                                                                1. 10

                                                                                                                  There is moltenvk, which implements (a subset of) vulkan on top of metal.

                                                                                                                  1. 8

                                                                                                                    And gfx-portability too.

                                                                                                              2. 2

                                                                                                                My understanding is that OpenGL is a pain to use in general, not just cuz of driver stuff but that the API itself is not something that (notably) game developers enjoy using.

                                                                                                                So there aren’t too many people going to bat for OpenGL

                                                                                                                1. 1

                                                                                                                  I thought that Vulcan is supposed to be the new “one 3D graphics API to rule them all”?

                                                                                                                  1. 3

                                                                                                                    Not without Apple’s buy-in it won’t be.

                                                                                                                  2. 1

                                                                                                                    Moving to CMake seems like the smart move

                                                                                                                    I’m a little disappointed that they’re dumping QBS development on the “community”. My impression is they went straight from “Technology preview” to “We’re not going to continue developing QBS because noone’s using it” without any sort of “QBS is ready now, please try it” announcement.

                                                                                                                    1. 1

                                                                                                                      Aren’t you supposed to be able to throw away prototypes?

                                                                                                                      1. 1

                                                                                                                        Absolutely, but not with the justification that customers weren’t using them.

                                                                                                                        Edit: “details” can be found in this mailing list thread if you’re interested: https://lists.qt-project.org/pipermail/development/2018-October/thread.html#34023

                                                                                                                  1. 8

                                                                                                                    Wow, that is a very unusual introduction to Haskell — going straight into imperative programs (everything’s a do!) and concurrency. And then it just…stops!

                                                                                                                    1. 6

                                                                                                                      It’s a phrasebook. It gives a way to do something in a language you don’t really know.

                                                                                                                      It isn’t idiomatic, it’s just getting you to have something to show for it as quickly as possible.

                                                                                                                      1. 6

                                                                                                                        It’s a work in progress:

                                                                                                                        We have launched the Phrasebook with 14 demonstrations of topics ranging from if-then-else expressions to transactional concurrency, and there is a lot more to come.

                                                                                                                        1. 2

                                                                                                                          In… a good way? Bad way?

                                                                                                                          1. 5

                                                                                                                            I don’t know! Well, it’s not good that it just stops. But I wonder what a Haskell book would be like that started with the imperative and concurrent stuff like “normal” languages have, and ended with the higher-order functions and so on, instead of the other way around, as a Haskell book normally does.

                                                                                                                            Like, you would start off thinking it was like Go or something, just with weird syntax. You’d get sucked in that way, but then things would start getting more abstract and powerful, and by the end you’d be using pure functions and GADTs and free monads before you knew what hit you.

                                                                                                                            1. 3

                                                                                                                              Like, you would start off thinking it was like Go or something, just with weird syntax. You’d get sucked in that way, but then things would start getting more abstract and powerful, and by the end you’d be using pure functions and GADTs and free monads before you knew what hit you.

                                                                                                                              I suspect you might give up, thinking, “what’s the point of this weirdness” before you got to any real motivation or reason to keep learning.

                                                                                                                            2. 4

                                                                                                                              I like it. And I am waiting for it to provide more examples. I went through several books, still reading and still trying to learn. But did already write programs that I am using for my work and that are helpful for me. Still mostly reaching out for shell scripting, because the shell scripts naturally grow by combining commands and I wish I would use some Haskell Shell in which I would do my daily stuff and that would easily allow me at some point to put together the Haskell programs.

                                                                                                                              I like how they are showing ghcid early (how long did it take me to find settle on ghcid, how many editor/IDE tools did I try), and I like that ghci is introduced. It’s pragmatic.

                                                                                                                              I hope it will go on with many examples.

                                                                                                                              1. 0

                                                                                                                                In… a good way? Bad way?

                                                                                                                                Definitely a bad way.

                                                                                                                                All the weirdness and higher order stuff is there to give you all kinds of guarantees which can be extremely useful.

                                                                                                                                In fact: If you are not using the higher-order stuff, you might just as well use another language which requires you to jump though less hoops, because you are missing the whole point of what Haskell is about.

                                                                                                                                You should start with the higher-order stuff and then bolt this phrasebook on as an afterthought, not the other way around. If you start with this phrasebook, you will essentially be writing a bad code base.

                                                                                                                                Please keep in mind that I have actually reviewed assignments from a “Functional Programming” course, which used Haskell as it’s primary subject of study.

                                                                                                                                1. 9

                                                                                                                                  You are gate-keeping, and this behaviour is definitely worse for the community.

                                                                                                                                  I’m one of those developers who had no computer science education, and started programming essentially by banging rocks together, trying to pay the bills with WordPress and jQuery.

                                                                                                                                  I learned Haskell the trial-and-error way, and the imperative way. My first foray into Haskell was from the book Seven Languages in Seven Weeks, which necessarily doesn’t go very deep into the languages it exhibits. I got some of the basics there, but otherwise trial-and-error, Google, IRC, etc. My first web apps in Haskell were pretty terrible, but I needed to just get something working for me to be more invested in the technology. Everyone sucks at something before they’re good at it anyway. There’s still an enormous amount of Haskell for me to learn. I see that as compelling, not a hurdle.

                                                                                                                                  This has not “destroyed my reputation”, as you asserted. If anything it’s only improved it, especially among people who are interested in Haskell but are discouraged by people like you.

                                                                                                                                  Now I run three businesses on Haskell, and employ other Haskellers who have worked at Haskell companies you have heard of.

                                                                                                                                  1. 6

                                                                                                                                    you will essentially be writing a bad code base.

                                                                                                                                    But you WILL be writing a code base.

                                                                                                                                    1. 1

                                                                                                                                      But you WILL be writing a code base.

                                                                                                                                      You will be writing a codebase that will force the next competent Haskell developer, to throw out all your work and start over. Also: It will destroy your reputation.

                                                                                                                                      Honestly, it’s better to not write anything at all if this is your starting point. Just use something else like python, C/C++, Java or C#. This is simply not how Haskell should be written and I will probably also perform worse than the alternatives.

                                                                                                                                      Why? Because if you use Haskell the right way, the compiler can throw in all kinds of optimizations, like lazy evaluation and memoization for free. If you are writing Haskell in the way that is proposed in the Phrasebook, you essentially loose all those perks without gaining anything. In fact your code will be much, much, (about a factor 10 actually) slower than it would be if you’d just started out by using a different language.

                                                                                                                                      For an elaborate example, you can look at The evolution of a Haskell programmer. Note that the Juniors and the first Senior developer’s solutions are in fact perfectly valid and viable.

                                                                                                                                      However, the second senior (which uses foldl) makes a critical mistake which costs him the “lazy evaluation perk”, which means that his best-case and worst-case performance are both O(n), whereas the senior that uses foldr will have O(1) as best case and O(n) as worst case performance.

                                                                                                                                      And it goes downhill from there. However the Haskell code I see in the Phrasebook is similar to what the “Beginning graduate Haskell programmer” would do.

                                                                                                                                      The “right” way to do it, is the “Tenured professor”-way all at the bottom. It doesn’t matter that product uses foldl’ internally in this case, which also sacrifices lazy evaluation. It’s about a way of doing things and in general, where you rely upon the implementation of libraries getting better. This phrasebook also throws a lot of those perks out by manually taking control over nearly the entire control flow (which is something you should do as little as possible when you are writing Haskell).

                                                                                                                                      That is the kind of “bad codebase you would be writing” we are talking about here. If you find yourself in the situation where you need this phrasebook to get started, you are simply out of your league. The situation is really not unlike the software engineering team that programmed the flight computers of the 737 MAX 8. You should step away and say: “No, I am not up to this task right now. I need at least 120 hours (but 240 hours is a more reasonable estimate) of study before I can do this”.

                                                                                                                                      But if you did invest the hours upfront and are using this Phrasebook as an afterthought… sure; Sure! Go ahead! You should now know where the pitfalls in these examples are.

                                                                                                                                      1. 7

                                                                                                                                        One of the authors of this Phrasebook is also an author of Haskell Programming from First Principles, which starts from the lambda calculus. I think she’s deliberately exploring as different an approach as possible. There’s isn’t a single Right way to teach, the readers’ varied backgrounds and motivations lead them to really different results.

                                                                                                                                        1. 1

                                                                                                                                          One of the authors of this Phrasebook is also an author of Haskell Programming from First Principles, which starts from the lambda calculus. I think she’s deliberately exploring as different an approach as possible. There’s isn’t a single Right way to teach, the readers’ varied backgrounds and motivations lead them to really different results.

                                                                                                                                          The approach the author is taking now, is an approach which defeats the main purpose of Haskell: It’s type-system and a relatively smart compiler that exploits this through lazy evaluation. Because of this, I simply do not agree with this statement.

                                                                                                                                          A pilot needs to learn at least some basic meteorology and aerodynamics, the same applies here, because if you don’t take the time to properly understand the type system and lazy evaluation, you are basically an unlicensed pilot that knows how to get an airplane off the ground, keep in in the air and land it again, but without any contact with air traffic control.

                                                                                                                                          I would not want to fly with such a pilot, neither do I want to use an aircraft he/she has flown in. In reality we have systems in place to stop this from happening and the pilot will be told to stay on the ground and “pilot” something (like a car for example) he/she knows how to pilot. In the software world, we do not have a system, other than our own sound judgement, in place to prevent this from happening.

                                                                                                                                          So please: Learn Haskell’s fundamentals first and then add this phrasebook to the mix afterwards or choose an entirely different technology. Everyone who is currently next to you or whom comes after you, will thank you for it.

                                                                                                                                          1. 3

                                                                                                                                            Hopefully Haskell can be many things to many people. I think it makes for a pretty good imperative language.

                                                                                                                                        2. 6

                                                                                                                                          I’m currently training a team of engineers to write Scala. We’re experiencing the “no code” problem right now. I prefer people write bad (but functional) code than no code.

                                                                                                                                          1. 1

                                                                                                                                            I’m currently training a team of engineers to write Scala. We’re experiencing the “no code” problem right now. I prefer people write bad (but functional) code than no code.

                                                                                                                                            I would agree with you if this was about any other programming language, but Haskell really is a different beast in this regard.

                                                                                                                                            I pose you this question: Would you rather spend some time training your engineers or would you rather have them dive in without them knowing what they are doing?

                                                                                                                                            Since you are training a team, you’ve probably chosen the first approach, which is exactly what I am proposing you should do with Haskell as well. You do not hand a pilot the keys to an airplane without making sure they’ve had some proper training. The same applies here (see below). Most other programming languages are like cars or trucks, but Haskell really is more of an aircraft.

                                                                                                                                            1. 8

                                                                                                                                              I think this type of elitist gate keeping dissuades people trying to learn Haskell and reflects poorly on the community. Furthermore the creators of the Haskell Phrasebook clearly know a lot about Haskell and have built a business around teaching it to people. Do you think it’s possible for them to have a compelling reason to create a resource like this?

                                                                                                                                              @argumatronic: I’ve seen people do similar with Haskell, starting with very imperative-style Haskell, but in the meantime: I can understand you, thank you for making effort to learn a new language, welcome.

                                                                                                                                              1. 0

                                                                                                                                                I think this type of elitist gate keeping dissuades people trying to learn Haskell and reflects poorly on the community.

                                                                                                                                                Actually I digress. There is nothing elitist about it. It’s about using a hammer to turn a screw in.

                                                                                                                                                Furthermore the creators of the Haskell Phrasebook clearly know a lot about Haskell and have built a business around teaching it to people.

                                                                                                                                                The fact that someone builds a business around something, doesn’t mean they are doing things the right way. Teaching people things the wrong way, has a tendency to stick around. Oh and btw, I also earned money teaching Haskell (and cryptography and security) to people during my studies at an accredited university with the oversight of a professor leading in the development of the language…. So I am no lightweight either…. And what I see here makes me cringe and would have awarded any student a non-passing grade with approval.

                                                                                                                                                Do you think it’s possible for them to have a compelling reason to create a resource like this?

                                                                                                                                                Yes I do. In fact, they state the same reason as I suspected on the Twitter feed you mention:

                                                                                                                                                IME, people start to write more Haskelly Haskell as they get comfortable with it, but we have the tools to write imperative-style Haskell as a bridge, no shame in using them.

                                                                                                                                                And:

                                                                                                                                                Eventually, by doing that a lot, I became quite fluent in Japanese. And I’ve seen people do similar with Haskell, starting with very imperative-style Haskell, but in the meantime: I can understand you, thank you for making effort to learn a new language, welcome.

                                                                                                                                                And like I said, there is nothing wrong with using the phrasebook, but you have to use it after you at least have a firm grasp op the basic concepts. Doing it the other way around will give the community and the language itself a bad name. If nothing else, the Haskell ecosystem will turn into a hack fest similar to python or nodejs with the decrease in quality and performance of everything that comes with it.

                                                                                                                                                That’s what I am worried about and it’s also why I disagree: You want people that write Haskell, to write it in a completely different way than you’d write an imperative language.

                                                                                                                                1. 1
                                                                                                                                  • 2nd July, 2019: CVE-2019-13143 reserved
                                                                                                                                  • No response from vendor
                                                                                                                                  • 2nd August 2019: Public disclosure

                                                                                                                                  So… This is essentially an invitation to start using the exploit in the wild?

                                                                                                                                  1. 3

                                                                                                                                    No? What about it reads that way to you?

                                                                                                                                    1. 2

                                                                                                                                      Nothing (and of course you don’t mean it that way), but I’m just not sure if it’s a good idea to disclose an exploit if it’s not fixed yet. At the same time, I’m not in security and I don’t know the common accepted practices. I was hoping that someone would patronizingly explain why it’s OK to do so in response to my deliberately provoking comment ;)

                                                                                                                                      1. 8

                                                                                                                                        I believe the general idea is that you give the vendor time to fix it before you disclose it publicly, but if the vendor does nothing at all, then it is better for the user to know about the vulnerability, so they can attempt to mitigate it (e.g. in this case by not using the ‘smart’ ‘lock’).

                                                                                                                                        1. 5

                                                                                                                                          u/Thra11 has answered this, but to add to that, public disclosure acts as a ditch effort to get the vendor to notice the issue and hopefully, address it. It’s a hard choice to make, especially when releasing exploits that could compromise thousands of user accounts. But at the same time, the users (at least a few) will learn of it and stop using the lock.

                                                                                                                                          1. 3

                                                                                                                                            There’s a good likelihood for any vulnerability that’s disclosed that there are people who already are aware of it and are presently exploiting it. Disclosure allows people to avoid being exploited and takes power away from those who hope to use it.

                                                                                                                                      1. 9

                                                                                                                                        I think the author misses a critical point about VPN providers and why some of us use them: You choose and control who could potentially snoop on you.

                                                                                                                                        Would you rather trust coffee shop wifi or a provider whom you’ve researched, feel is “good enough” for your needs, and are in a customer/service provider relationship with? Do you trust your ISP to shield you from p2p nastygrams or do you trust a foreign vpn provider who has a track record of not caring?

                                                                                                                                        Its about choice and trust. Trust isn’t all or nothing, you should know how much you trust your provider and with what.

                                                                                                                                        1. 3

                                                                                                                                          Would you rather trust coffee shop wifi or a provider whom you’ve researched

                                                                                                                                          I trust my local coffee shop more than any tech company!

                                                                                                                                          1. 1

                                                                                                                                            But, do you trust people accessed your local coffee shop network?

                                                                                                                                            1. 1

                                                                                                                                              It was a joke, but yeah, that’s what SSHing into my home computer is for.

                                                                                                                                              1. 2

                                                                                                                                                I was thinking “is he making jokes?” and just looked into your comments, and you seem serious to me. So, sorry about lack of sense of humour.

                                                                                                                                                That’s what SSHing into my home computer is for.

                                                                                                                                                Seems like not a huge problem because SSH warns you when fingerprints changed.

                                                                                                                                                1. 2

                                                                                                                                                  Hehe, no worries. I enjoyed the article; thanks for posting it.

                                                                                                                                                  A while back I quipped that “VPN is just SSH for suits”; I have honestly never used a VPN because I still can’t figure out what the point is if you already know how to use SSH.

                                                                                                                                                  1. 2

                                                                                                                                                    Reason to use a VPN like ipsec rather than openssh’s SOCKS proxy: better compatibility, lower overhead.

                                                                                                                                                    Compatibility: ipsec or similar VPNs are mostly transparent to applications. Not every program is happy out of the box to talk over a SOCKS proxy. Offhand I’m not sure if ssh’s SOCKS proxy can be used for UDP protocols. (You can use socksify or something to shove all TCP sockets over a particular SOCKS proxy but IME it isn’t reliable.)

                                                                                                                                                    Overhead: not all that bad but just mentioning it for completeness: you can get some head-of-line blocking delays if there’s any packet loss between you and the sshd. Something like ipsec won’t unduly delay packets if some arrive out of order. (Also, not sure if this is accurate but I’ve read somewhere that openssh has some throughout limitation on long fast networks. You probably don’t run into that though.)

                                                                                                                                                    Btw not picking on openssh here, just mentioning it by name because it’s the ssh impl you’re most likely to use these data and the only ssh impl I’m happy to trust.

                                                                                                                                                    This isn’t to say don’t use ssh SOCKS as if it were a tiny vpn, I have done that plenty times myself, just outlining valid reasons one might want the more complicated solution instead.

                                                                                                                                                    1. 2

                                                                                                                                                      Thanks for the technically correct answer. =)

                                                                                                                                                      I guess what I really meant was more like “I’ve never wanted to tunnel a network connection made from a program that isn’t a browser or running over an SSH connection” which is slightly different.

                                                                                                                                                      Now I’m having trouble thinking of any such networked program I use at all other than games. I guess VLC, but apparently that supports SOCKS too. I’m sure they exist; I just don’t have any use for them. =)

                                                                                                                                          2. 2

                                                                                                                                            You choose and control who could potentially snoop on you

                                                                                                                                            I think this is a very good point. Your ISP generally has to be in your country, and as such may be bound by laws requiring them censor certain sites or to log data or metadata. You can’t choose a foreign ISP, but you can choose to use a VPN provider in a different jurisdiction.

                                                                                                                                            1. 1

                                                                                                                                              Yep, and those are exactly the two use cases where the author says a VPN is reasonable. It’s too bad the author chose to be dogmatic and pooh-pooh those two cases instead of just admitting that their advice isn’t universal.

                                                                                                                                            1. 2

                                                                                                                                              mirrors will reflect IR, so a hot spot on a mirror may be from a ceiling light not from a camera behind it

                                                                                                                                              I would have thought that this should be fairly easy to distinguish by moving the IR camera: an IR reflection should move around the mirror like a visible reflection would, while a hotspot behind the mirror should stay put.