1. 7

    It’s not a majority opinion, but I believe some things should just be kept forever.

    Sometimes they were deprecated in Python 2 like using Threading.is_alive in favour of Threading.isAlive to be removed in Python 3

    Like this, for example. Is changing the spelling of something really worth breaking this for everyone?

    1. 6

      Yeah or just provide an alias and in the docs note that the snake case version is preferred or something.

      I really really want to like Python. From a sys admin perspective its a fantastic language. One file scripts where you don’t have to deal with virtual env and its not gonna change much.

      From a DevOps perspective (package creation and management, versioning, virtualenv, C based packages not playing well with cloud-oriented distros, stuff like this in doing language version upgrades) I’ve always found it to be a nightmare, and this kind of thing is just another example of that. I tried to install Ansible and am basically unable to do it on a Mac because no version of Python or Pip can agree that I have installed it and it should be in my path.

      I don’t begrudge anyone who uses it or think it’s a bad language, that would be pretty obtuse, but I always avoid it when I can personally.

      1. 7

        This is what we do in Mercurial. Aliases stay forever but are removed from the documentation.

        Git does this too. git diff --cached is now a perpetual alias for git diff --staged because the staging area has been variously called the cache and the index. Who cares. Aliases are cheap. Just keep them forever.

        1. 2

          I didn’t even realize --cached was deprecated, I use that all the time.

          1. 3

            And that’s how it should be. You shouldn’t even notice it changed.

        2. 4

          Yeah or just provide an alias and in the docs note that the snake case version is preferred or something.

          That’s exactly what was done: https://docs.python.org/2.7/library/threading.html - unfortunately, not everybody spots this stuff, and people often ignore deprecation notices.

          The real problem is that it’s difficult to write a reliable tool to flag and fix this stuff is you can’t reliably do type inference to figure out the provenance of stuff.

          I tried to install Ansible and am basically unable to do it on a Mac because no version of Python or Pip can agree that I have installed it and it should be in my path.

          Some of the things Homebrew does makes that difficult. You’re right: it’s a real pain. :-( I’ve used pipx in the past to manage this a bit better, but upgrades of Python can break the symlinks, sometimes for no good reason at all.

          As far as Ansible goes, I stick to the version installed by Homebrew and avoid any dependencies on any of Ansible’s internals.

          1. 1

            From someone who uses Ansible on a daily basis: the best way to use it is by creating a virtualenv for your Ansible project and keeping everything you need in there. My ‘infra’ project has a requirements.txt and a boostrap.sh that creates the virtualenv and install all dependencies. If you try to install Ansible at the system level, you are going to hate your life.

          2. 6

            Yeah, or at least bring in some compatibility libraries. Deprecating and removing things that aren’t actually harmful seems like churn for the sake of it.

            1. 3

              That (removing cruft, even if not harmful) was basically the reason for Python 3. And everyone agreed with it 10 years ago. And most people using the language now came to it probably after all these decisions have been made, and the need to upgrade to Python 3 was talked about for all this time. Now is simply not the time to question it. Also, making most of those fixes is easy (yes, even if you have to formally fork a library to do a sed over it).

              1. 1

                Those breaking changes came with a major version bump. Why not just wait until Python 4 to remove the cruft?

                1. 3

                  There should ideally never be a Python 4: none of those deprecated bits are meant to be used in Python 3 code. They were only present to ease transition in the short term, and it’s been a decade.

                  1. 2

                    While there are people who prefer a semver-esque approach of bumping the major every time a deprecation cycle finishes, AFAIK Python has no plans to adopt such a process, and intends to just continue doing long deprecation cycles where something gets marked for deprecation with a target release (years in the future) for actually removing it.

                    1. 1

                      Python’s releases are never perfectly backwards compatible. Like most programming languages, old crufty things that have been deprecated for years are sometimes removed.

                      1. 1

                        That’s a shame. A lot of languages provide some mechanism for backwards compatibility, either by preserving it either at the source or ABI level, or allowing some kind of indication as to what language version or features the code expects. It’s nice to be able pick up a library from years ago without having to worry about bit rot.

                        1. 2

                          It’s a library compatibility issue not a language compatibility issue. It’s been deprecated for a decade honestly there’s been plenty of time to fix it

                          1. 1

                            This particular library is part of the language. A decade is an awfully short time for a language.

                            1. 2

                              Python has never promised that it will eternally support every thing that’s ever been in the language or the standard library. Aside from the extended support period of Python 2.7, it’s never even promised to maintain something as-is on a time scale of a decade.

                              Python remains a popular and widely-adopted language despite this, which suggests that while you personally may find it a turn-off that the language deprecates things and removes them over time, there are other people who either do not, or are willing to put up with it for sake of having access to a supported version of the language.

                              This is, incidentally, the opposite of what happens in, say, Java, where the extreme backward-compatibility policy and glacial pace of adding even backwards-compatible new features tends to split people exactly the same way.

                              1. 2

                                In a semver-esque world, anything deprecated in 2 is fair game for removal in 3, of course (and if this particular thing was, then I concede). In that way Python 3 is a different language to Python 2, which I believe is how most folks consider it anyway. It’s just a shame that, apparently, you can’t write a Python 3 program and expect it to work with Python 3 in 10 years with no programmatic way of specifying which Python 3 it works in. Nobody would be any worse off if they just waited for Python 4 to clean up.

                                1. 2

                                  If I write something today, that raises deprecation warnings today, I don’t expect to be able to walk away from it for ten years and then have it continue to work on the latest version. I expect that those deprecation warnings really do mean “this is going to change in the future”, and that I either should clean it up now to get rid of the warnings, or I’ll have to clean it up later if I want it to keep working.

                                  That’s the kind of situation being discussed here – people who wrote code that already raised deprecation warnings at time of writing, and are surprised to find out that those warnings really did mean “this is going to change in the future”.

                                2. 1

                                  Everyone who wants a Python that doesn’t change has been (and probably still is) using Python 2.7. I expect that we will see more pushback in the community against these sorts of changes as that becomes less tenable.

                    2. 4

                      It would be nice if Python had an equivalent of go fix. It’s just a pity things like that are difficult with dynamic languages.

                    1. 2

                      Datadog Log Collection. It’s painless to setup and can do fancy things such as dumping older logs into S3 for long-term storage (which is a requirement in the industry I work on). Honestly, after using Kibana and Splunk in previous jobs, Splunk might have more powerful features, but it’s stupid expensive and hard to maintain. Datadog Logs hits the right balance of cheap, easy, and usable.

                      1. 6

                        Two words: Foam. Roller.

                        1. 1

                          Do you just roll out your lower back? Sides or hips maybe?

                          1. 3

                            I go very gently over my “upper” lower back, if its very bad pain then you need to focus on other areas. IT bands on the side of the thighs, upper back tension, and your ass are other areas to focus on!

                            Foam Roller always hurts like a bitch when you start using it, but its a god send and once you get into it daily its easy and feels really good.

                            1. 1

                              Oh, I always avoided them because they hurt… I guess I’ll try

                              1. 2

                                It does hurt like a bitch at first, but once you get through the pain its damned amazing! I dont even need to do it daily, or even weekly anymore, a few times a month is all I need now.

                          2. 1

                            But how?

                            1. 2

                              This is pretty close to what my physical therapist taught me: https://www.youtube.com/watch?v=MnWWDAsEfXk

                              1. 1

                                There’s actually tons of videos on YouTube on how to use foam rollers and other devices for stretching and helping sore muscles. Make sure to check the source - you don’t want some random giving you advice.

                                1. 2

                                  There’s actually tons of videos on YouTube…

                                  Make sure to check the source - you don’t want some random giving you advice.

                                  I find that to be a tricky proposition. How do you know which one is good?

                                  1. 3

                                    My physiotherapists recommends the PreHab Guys for physical therapy ideas.

                                    I actually site on a gym ball when I’m not at my standing desk - and I’ve found that has been good for prevent back pain from sitting too long.

                                  2. 2

                                    Make sure to check the source - you don’t want some random giving you advice.

                                    I almost feel that’s what I’d be doing by following your 2 word advice…

                                    1. 1

                                      Haha! Well, there’s definitely a range of quality in YouTube. I guess it’s fairly hard to measure if you aren’t used to dealing with fitness types. My general rule of thumb is this: if the person in the video tells you to be gentle with your body, seems to represent a bigger brand than just themselves (say, a gym), and doesn’t try to sell you a particular brand of supplement, they are probably OKish.

                                      If they are pushing supplements, promising you can do 100 pull-ups if you just workout 10 minutes a day or pretend that their six pack is unrelated to their diet, then you want to stay away.

                              1. 5

                                I know this isn’t for everyone - in general the activity itself used to get a really bad rap and is pretty pricey - but since I accidentally started CrossFit about two years ago, all sitting related pain (and even most RSI-related pain) has disappeared. I couldn’t recommend some form of weightlifting + short HIIT cardio enough.

                                1. 7

                                  I’m curious to learn how one accidentally gets into fitness.

                                  1. 2

                                    Haha, sure, short story time: we got accepted to be part of the the NYC Summer 2017 cohort at Techstars. My co-founders and me rented a place in Brooklyn. After a couple of weeks of 12+ hours in the co-working space, eating poorly and waking up in the middle of the night thinking about my Kanban board, I decided that I needed to find something that’d get me tired enough that I’d just sleep.

                                    The closest gym to the apartment turned out to be a CrossFit gym with a great summer promo. One of my best friends had started CrossFit a year prior and was very happy with it, so I decided to give it a go. If I hated it I’d just use the gym as a free-weight facility. The very first ‘on-ramp’ class (which is designed to be a very light version of it) I almost died. I walked home in a daze, laid on a couch to catch my breath and passed out for an hour. I realized how badly out of shape I was.

                                    So, I stuck with it. One of the things that surprised me is just how friendly people were. Everyone was helping everyone else: giving tips on form, recommending scaled versions of exercises (“don’t try this yet, do this other thing to build strength instead”), cheering if you were the last one, and general camaraderie. The ‘beasts’ weren’t trying to compete with the newbies, but rather everyone was on their own lane and high-fived everyone else after the workout. The feeling of ‘going through this shit together’ definitely helps build a sense of community that’ll keep you coming back.

                                    I was worried I’d drop it once we came back to the Bay Area. Agonized a bit with finding the ‘perfect box’ (gyms in NYC are pretty high end) and struggled with sticker shock (going from a $50 a month promo to ~$200 was painful), but once I settled on a box and went back to it, I couldn’t be happier.

                                    1. 1

                                      Nice, that sounds great. I fit into the “skinny-fat” category due to a fast metabolism and a sedentary lifestyle. I am relocating to the Bay Area in a few months and am thinking about bulking and cutting once I get there. I lurk in /r/brogress and other places so I’ve bookmarked a bunch of resources.

                                      Thanks for sharing!

                                  2. 3

                                    I do studio pilates and find the same. Maybe it’s just getting things moving. My personal theory is you need all the muscles working to hold everything together, particularly all the little muscles. Hours of sitting or not moving means the little muscles atrophy and things rub against each other that shouldn’t which causes pain. There’s also theories about the fascia needing release, but who knows. I think the main thing is you need some sort of regular exercise to keep things working.

                                    1. 3

                                      I highly recommend regular calisthenics practice in general. Convict Conditioning is a good book. I’ve written about my thoughts here.

                                      1. 2

                                        Glad to hear I’m not the only one. I couldn’t tell if the reason I don’t experience sitting-related pain is because my age or if it’s because my back takes enough of a beating already, but your comment makes me think the latter.

                                      1. 3

                                        Can any lobsters using HTTPie explain what drew them away from curl or what about curl pushed them to HTTPie?

                                        1. 8

                                          I haven’t been using it for long but for me the nicest thing so far is being able to see the whole response: headers, body, and all of it syntax-highlighted by default. The command-line UI is a little nicer as well, more clear and intuitive.

                                          It will probably not replace my use of curl in scripts for automation, nor will it replace my use of wget to fetch files.

                                          Now if someone took this and built an insomnia-like HTTP client usable from a terminal window, then we’d really have something cool.

                                          1. 1

                                            I’m guessing you mean this Insomnia. Looks cool. Good example of an OSS product, too, given most features people would want are in free one.

                                          2. 4

                                            I use both depending on circumstance (more complex use cases are better suited for curl IMO), but the significantly simpler, shortened syntax for HTTPie as well as the pretty printing + colorization by default for JSON APIs is pretty nice.

                                            1. 3

                                              I wouldn’t say I’d been ‘pushed away’ from curl, I still use curl and wget regularly, but httpie’s simpler syntax for request data and automatic coloring and formatting of JSON responses makes it a great way to make quick API calls.

                                              1. 3

                                                I like short :8080 for local host syntax.

                                                1. 3

                                                  It’s all in how you like to work. Personally I enjoy having an interactive CLI with help and the like, and the ability to build complex queries piecemeal in the interactive environment.

                                                  1. 3

                                                    Sensible defaults and configurability.

                                                    1. 2

                                                      I need a command line HTTP client rarely enough that I never managed to learn curl command line flags. I always have to check the manual page, and it always takes me a while to find what I want there. I can do basic operations with HTTPie without thinking twice and the bits I need a refresher on — usually the syntaxes for specifying query parameters, form fields or JSON object fields — are super fast to locate in http --help.

                                                      1. 1

                                                        curl is the gold standard for displaying almost anything including tls and cert negotiation. i use bat mostly now though for coloured output and reasonable json support. https://github.com/astaxie/bat

                                                      1. 3

                                                        Isn’t evil the actual vim mode for emacs, and spacemacs just a collection of a bunch of packages that happens to include evil?

                                                        1. 2

                                                          Correct. Also, every time I tried Spacemacs it barfed about installing one plugin or another (it changes every time). Not the friendliest intro to Emacs, LOL.

                                                          1. 3

                                                            I liked what Spacemacs did but every time wondering whether the next update will just hose your editor was not a great experience. While I was using it, they even added a “revert update” option, so it looks like I’m not the only one who experienced this.

                                                        1. 44

                                                          Google search results have got worse and worse over the years. It used to be that the first result of my search was nearly always what I wanted. Now Google insists on trying to be clever, and often the MOST IMPORTANT keyword in the search isn’t even there at all.

                                                          1. 16

                                                            A million times this. Google seems far less useful today than it did 10 years ago. Most of the time, I get search results for what Google thinks I’m trying to search for based on popular searches, rather than what I am actually searching for. Basically if your search query is fairly uncommon, Google won’t show you any relevant results, period.

                                                            There is a big gaping vacuum in the market for a search engine specifically focused on technical users looking for technical content. Who wants to start a company with me?

                                                            1. 6

                                                              Isn’t that … almost literally what DuckDuckGo is?

                                                              1. 4

                                                                No, DuckDuckGo pulls from Bing, and both tend to change what you searched for to what it thinks you want instead. Even the old trick of +wanted_keyword -unwanted_keyword does not guarantee it will honor your request (they are treated as ‘suggestions’ instead of rules now), but it does help a lot.

                                                              2. 3

                                                                I’m sure it started with the demise of: https://www.google.com/bsd

                                                                1. 3

                                                                  google.com/linux was literally my first contact with Google. I was attending a local Linux user group (are those still a thing?) in the city I grew up in back in South America, and someone told us we should check that out next time we were looking for Linux resources. I remember the quality and breadth of the results was mind blowing, and I immediately stopped using any other search engines. Never thought I would end up working for them about 15 years later, heh.

                                                              3. 3

                                                                Catering to the lowest common denominator rather than to people who actually know how to structure search queries.

                                                              1. 17

                                                                I’m sad that every thread about Firefox turns into a complain-fest. It is a 28 million line product. It is hard to please everyone. Accept that it is not perfect and please don’t feel entitled that your bug must be catered to. It is a product with 100s of millions of users, hundreds of developers and dozens of teams. If it were simple to fix all the bugs and satisfy every request, it would be done. Really!

                                                                1. 3

                                                                  I love constructive feedback and productive discussions in bugs. Please.

                                                                  1. 1

                                                                    I’m sad that every thread about Firefox turns into a complain-fest. It is a 28 million line product.

                                                                    and you jump straight to criticism too

                                                                    1. 6

                                                                      Yes I criticize the tone of the discussions.

                                                                      1. 6

                                                                        I think the joke was that 28 millions lines of code is a ton of code for a web browser :)

                                                                  1. 2

                                                                    This is the first time I’ve seen the term “modding” used for this.

                                                                    1. 7

                                                                      Indeed. As I mentioned at the bottom of the post, the traditional term (“ricing”) is quite racist, as I was informed the last time I posted it here. Modding makes intuitive sense here, and is a widely used term in other places. “modding Unix” or “modding Linux” is easily Google-able, too.

                                                                      1. 5

                                                                        I LOVE the Unix “modding scene” but the terminology can be cringe. I can never link co-workers to the r/unixporn subreddit for example.

                                                                        I hope more graphic designers start to use modded Unix PCs and help boost this art form. It seems like Figma and the decline of Apple/Adobe are creating the conditions for designers to move to Linux next decade.

                                                                        1. 3

                                                                          That, and the slow shift away from such cringey language - see, e.g, the GIMP -> Glimpse fork, et cetera.

                                                                          We can hope!

                                                                        2. 2

                                                                          I’ve never heard the term ricing used in this context. To be fair, I didn’t pay attention how Linux users call it, because it’s simply configuring things ;)

                                                                          In the past the term I read most often was deskmodding or skinning, back when you needed special tools to make your Windows installation a little more unique. ThemeXP, ResHacker, Winamp Skins…

                                                                          1. 2

                                                                            Always wondered where the term ‘ricing’ came from. Thanks for the clarification.

                                                                            1. 2

                                                                              FYI there’s still one instance of the term “ricing” (just after the first two screenshots).

                                                                              I don’t suppose you’re still using the purple theme? I like it.

                                                                              1. 2

                                                                                Oops! I should improve my ripgrep skills, clearly :P

                                                                                I’m no longer using the same purple theme; the contrast was not sufficient, so I made the background color a little darker. I’m glad you like it!

                                                                          1. 18

                                                                            This is one of the most unpleasant, flamey threads I’ve seen on Lobsters yet…

                                                                            1. 7

                                                                              Seriously, this is scary! First we see that Lobsters is susceptible to systemd hysteria, and now Go generics, as well… Is no place safe?

                                                                              1. 3

                                                                                Let me tell you about my Vim configuration and why I don’t use Emacs…

                                                                                1. 7

                                                                                  Ha! People don’t seem to get so vituperative about editors, though. I mean, people even suggest going “best of both worlds” with evil-mode.

                                                                                  Systemd and Go are both run by small, strong-willed core teams who like to solve concrete problems, have a fairly consistent style of solving them, and provide detailed technical justifications for what they do, but don’t worry much about achieving global consensus before making decisions. Maybe that just inherently irritates people.

                                                                                  1. 4

                                                                                    The other topic I’ve seen technical people go crazy about lately is blockchains, and I got a bit of perspective from working with those for a while, because there it’s so obvious that there is this “political economy of technical decisions”, to coin a phrase, and forks can be extremely, ridiculously contentious.

                                                                                    If systemd were just somebody’s pet project, they could do whatever they liked, but they’ve ended up in a position of power, as it were, because they’re the root process and upstream for most GNU/Linux distributions. I think the anti-systemd crowd should give up on trying to influence that project and go for exit rather than voice—the hard fork approach.

                                                                                    Forks in regular open source take energy and cause some disruption, but at least they’re not blockchain forks. Just start working on removing that daemon and replacing it with your own solutions, and let’s live in peace, right? When has shouting on the internet ever solved anything?

                                                                                    I would suggest forking Go to add generics but… they’re already working on it? Russ Cox himself says:

                                                                                    After the release of Go 1, we continued to explore various possible designs for generics, and in April 2016 we released those early designs, discussed in detail below. As part of re-entering “design mode” for the Go 2 effort, we are again attempting to find a design for generics that we feel fits well into the language while providing enough of the flexibility and expressivity that users want.

                                                                                    Some form of generics was one of the top two requested features in both the 2016 and 2017 Go user surveys (the other was package management). The Go community maintains a “Summary of Go Generics Discussions” document.

                                                                                    Many people have concluded (incorrectly) that the Go team’s position is “Go will never have generics.” On the contrary, we understand the potential generics have, both to make Go far more flexible and powerful and to make Go far more complicated. If we are to add generics, we want to do it in a way that gets as much flexibility and power with as little added complexity as possible.

                                                                                    So, uhh?

                                                                                    1. 3

                                                                                      forking systemd just means more systemd like init systems, not a good approach!

                                                                                    2. 1

                                                                                      Well, systemd appears to irritate people mostly for implementation details.

                                                                                      1. 1

                                                                                        vituperative

                                                                                        It’s emacstuperative, you insensitive clod! ;)

                                                                                        1. 1

                                                                                          Absolutely. Nothing irritates engineers like having their chance to bikeshed taken away. Gnome is another great example of a system that generates tons of hatred, and yet… it’s by far the most popular desktop environment out there.

                                                                                  1. 3

                                                                                    I like the diagrams on these pages. Does anyone recognize the tool? I guess it’s possible they’re simply hand-drawn with great care.

                                                                                    1. 1

                                                                                      It looks like they are “hand drawn” using Inkscape or something. I guess you could use Dia to achieve something similar.

                                                                                      1. 2
                                                                                    1. 0

                                                                                      OK? I mean, this is a drag for people who use Linux, and wanted Apple hardware, but I feel that the delta between Apple hardware and other OEM hardware is closer than it’s been in a very long time, and if you’re not buying to run OS X, why pay the delta?

                                                                                      1. 2

                                                                                        Funny, I think the delta is the largest it has ever been. IMO there’s simply no contest anymore, while back in the day Thinkpads were actually better.

                                                                                        1. 3

                                                                                          I don’t know. I was a Mac user for 7 years, until about two months ago when I bought a Matebook X Pro. Is the hardware as good as Apple? No, but it’s damn close for a computer that cost $1k less than the equivalent Macbook Pro. In fact, it wasn’t even cost, but rather the “innovative” features on the new Macbook Pros (the super low-profile keyboard and the useless touchbar) that pushed make the jump.

                                                                                          Apple still has an edge, but it’s becoming smaller and smaller. I’d say that the biggest quality-of-life advantage Apple sill has is just how well integrated their OS and hardware is, even though Apple seems to be on a campaign to make OS X actively hostile to the very software engineers like me who used to choose the Mac because it was a “better POSIX experience”.

                                                                                          1. 1

                                                                                            New apple hardware is good? Or is the go-to macbook still the 2010-2012 models? IIRC those were the last to use 2.5” SATA drives and normal resolution screens. The retina macbooks lost that stuff but at least retained an okay keyboard. So I would be curious to hear what’s good about the new macbooks, if that’s indeed what you’re saying.

                                                                                        1. 4

                                                                                          The tl:Dr is: use Wayland because X just wasn’t designed for this.

                                                                                          1. 3

                                                                                            If all monitors have the same scale, X can look fine. But it absolutely cannot handle both low-DPI and high-DPI monitors at the same time.

                                                                                            1. 1

                                                                                              Although this does work fine with Qt5.

                                                                                              1. 1

                                                                                                It can, using a specialized xrandr configuration, and it looks great. The only problem I had (which stopped me from using it) is that there’s a bug in the Intel driver that makes the cursor on the laptop monitor flicker, which is more annoying than you’d think.

                                                                                            1. 6

                                                                                              Wow if I bought a monitor with a dead pixel and weird lines on the screen it’d be back in the shop before you could say ‘Consumer Guarantees Act 1993’. Especially on such expensive high end hardware. I was upset enough that my monitors’ colour balance isn’t quite the same.

                                                                                              EDIT: I also find it absolutely hilarious that DPI scaling works fine in Qt 5, and works fine in actual web browsers, but doesn’t work in Electron, the supposedly ‘modern’ UI framework.

                                                                                              1. 4

                                                                                                He didn’t even align the displays with each other … AAAAAAARGHRGHGHRGH.

                                                                                                1. 3

                                                                                                  DPI scaling works fine for Electron apps based on a Chromium version that supports DPI scaling. This has been the case for quite some time now, and Chromium’s move to GTK3 has improved support even further. I’m not sure what Electron apps the author was using that didn’t support DPI scaling, however I’ve yet to come across one that doesn’t scale on my 4K laptop screen. Both VS Code and Slack work flawlessly for me.

                                                                                                  I got my XPS 9560 in early 2017 with a 4K screen so I was initially quite worried about scaling issues, however the only apps I ever have issues with are older GTK2 apps (Gimp, and pgAdmin are the only two that I use).

                                                                                                  1. 2

                                                                                                    DPI scaling works in Electron apps, but I often have to specify it per app (often by using Ctrl +/- for the browser zoom). … It is kinda a step backwards when you think about it.

                                                                                                    1. 1

                                                                                                      I am using Spotify. I have just checked and it’s still not scaling correctly without the appropriate command-line option. I’ll add a note this may depend on the Electron app.

                                                                                                      EDIT: maybe Spotify is not an Electron app, but a CEF app. Is there still a difference?

                                                                                                      1. 1

                                                                                                        The version of Chromium CEF/Spotify uses seems to lag pretty far behind contemporary Electron builds, just based on https://www.spotify.com/ro/opensource/

                                                                                                        1. 1

                                                                                                          Chromium 65 is recent enough to have the appropriate code. But maybe CEF doesn’t make use of it. I’ll update the table to mention Electron apps works fine.

                                                                                                          1. 1

                                                                                                            Spotify for Linux has been around since before Electron existed, so Spotify not using it isn’t much of a surprise.

                                                                                                            According to this page, Electron doesn’t make use of CEF, and instead calls Chromium’s APIs directly, which is probably why Electron apps are able to scale correctly while Spotify doesn’t.

                                                                                                        2. 1

                                                                                                          I use Spotify every day in a HiDPI environment. Never had an issue. The one thing you might want to do if the first time you load it the text looks too small is use the built in zoom feature (Ctrl+/Ctrl-) to bring the font to a readable size, it’ll be saved and you won’t have to worry about it anymore.

                                                                                                      2. 1

                                                                                                        Wow if I bought a monitor with a dead pixel and weird lines on the screen it’d be back in the shop

                                                                                                        The policy allowing some handful of dead/stuck pixels has been written into the warranties of most monitors literally since LCD computer monitors have been around. Because most people use their monitors for web browsing, email, document editing, etc, where a couple of extremely tiny black specs are truly insignificant and will literally never be noticed among all of the dust such that accumulates on every screen.

                                                                                                        If you want a monitor that comes with zero dead pixels guarantee, they certainly sell those, but they cost more as well since there’s more QA involved.

                                                                                                        1. 1

                                                                                                          The policy allowing some handful of dead/stuck pixels has been written into the warranties of most monitors literally since LCD computer monitors have been around.

                                                                                                          They can write whatever they like in the agreement that I never signed or agreed to when I bought a monitor from a shop. It’s completely irrelevant. I’m not talking about returning it to the manufacturer under their warranty, I’m talking about returning it to the shop I bought it from under consumer protection law.

                                                                                                          Because most people use their monitors for web browsing, email, document editing, etc, where a couple of extremely tiny black specs are truly insignificant and will literally never be noticed among all of the dust such that accumulates on every screen.

                                                                                                          My monitor has no dead pixels. If it got a dead pixel, I would notice immediately. They’re incredibly obvious to anyone that isn’t blind.

                                                                                                          If you want a monitor that comes with zero dead pixels guarantee, they certainly sell those, but they cost more as well since there’s more QA involved.

                                                                                                          No, monitors that come with a ‘zero dead pixels’ guarantee are all monitors.

                                                                                                          1. 1

                                                                                                            They can write whatever they like in the agreement that I never signed or agreed to when I bought a monitor from a shop.

                                                                                                            Nobody mentioned an agreement. A warranty is not the same as an agreement or contract.

                                                                                                            I’m not talking about returning it to the manufacturer under their warranty, I’m talking about returning it to the shop I bought it from under consumer protection law.

                                                                                                            It would have been useful to mention that you’re apparently in New Zealand. If I understand it, the law you’re talking about requires every retailer to accept returns of purchased merchandise. Not all countries have such a law. In the U.S. for instance, almost every store accepts returns whether or not the merchandise is defective. But this is simply good customer service, it’s not a legal requirement.

                                                                                                            So now the argument hinges on what is considered defective and who gets to decide that. Is it up to the manufacturer? The retailer? The end user? In your country, I honestly don’t know and don’t care enough to research it right now.

                                                                                                            They’re incredibly obvious to anyone that isn’t blind.

                                                                                                            No, not really. Dead pixels are only obvious when the entire area around the dead pixel is one solid bright color, and even then, are generally indistinguishable from dust. Most people will never notice a dead pixel in everyday use, especially as the pixels in monitors get smaller and smaller. I have a huge monitor with a ridiculous resolution at home. It has a couple of dead pixels, it’s been months since I last noticed them. But by god it was like $200 on Amazon. I’ll happily save a few hundred dollars to deal with a couple of dead pixels I very rarely notice.

                                                                                                            No, monitors that come with a ‘zero dead pixels’ guarantee are all monitors.

                                                                                                            In New Zealand, maybe, but that’s not at all a universal statement. Nor should it be.

                                                                                                            The realities of the LCD manufacturing process are such that if every LCD panel manufacturer threw out all of their panels with one or more dead pixels, every monitor produced would cost the end user a lot more. Because not only do you need better QA, you’re throwing into the trash a significant percentage of your yield. Which has a dual negative impact: Not only did you waste precious factory time and expensive resources on the panel, now it has to get thrown away into a landfill or processed for recycling if that’s even possible.

                                                                                                            It’s far more efficient from a manufacturing, environmental, and market standpoint to just sell the slightly imperfect panels at a discount and sell the perfect panels for whatever the market will bear for zero dead pixels. Which is exactly what most manufacturers do. You want zero dead pixels, buy the one with the zero dead pixels policy. Here is Dell’s version of that: https://www.dell.com/support/article/nz/en/nzbsd1/sln130145/dell-lcd-display-pixel-guidelines?lang=en

                                                                                                            1. 1

                                                                                                              Nobody mentioned an agreement. A warranty is not the same as an agreement or contract.

                                                                                                              A warranty is an example of an agreement. You purchase the thing, and they agree to take it back if it’s faulty. But they can put whatever terms they like, they can define taking it back, define timelines, define ‘faulty’, etc. It’s completely up to them, really. If you don’t like it, don’t buy it.

                                                                                                              It would have been useful to mention that you’re apparently in New Zealand. If I understand it, the law you’re talking about requires every retailer to accept returns of purchased merchandise.

                                                                                                              Only if it’s faulty.

                                                                                                              So now the argument hinges on what is considered defective and who gets to decide that. Is it up to the manufacturer? The retailer? The end user? In your country, I honestly don’t know and don’t care enough to research it right now.

                                                                                                              The same way anything is decided legally: it starts off a bit fuzzy around the edges, but in the vast majority of cases, it’s pretty obvious what it means for something to be faulty. And in a few edge cases, it gets decided by the legal system which sets a precedent that sharpens the edges for everyone else in the future.

                                                                                                              No, not really. Dead pixels are only obvious when the entire area around the dead pixel is one solid bright color, and even then, are generally indistinguishable from dust. Most people will never notice a dead pixel in everyday use, especially as the pixels in monitors get smaller and smaller.

                                                                                                              I can guarantee I’d notice any dead pixels on my 1920x1200, 24 inch monitor. I can guarantee I’d notice any dead pixels on my phone. I think it’s nonsense to claim that most people would never notice a dead pixel in everyday use. A bright dot in the middle of your monitor is going to be obvious if you’re watching something that’s dark. The moment you watch a movie there’s an unmoving bright green dot in the middle of the screen? Everyone is going to notice that.

                                                                                                              I have a huge monitor with a ridiculous resolution at home. It has a couple of dead pixels, it’s been months since I last noticed them. But by god it was like $200 on Amazon. I’ll happily save a few hundred dollars to deal with a couple of dead pixels I very rarely notice.

                                                                                                              It’s fine if the manufacturers and retailers sell them at a discount as seconds. But that’s not what they’re doing. They’re selling them as normal and then just hoping people can’t be bothered complaining about them and returning them.

                                                                                                              The realities of the LCD manufacturing process are such that if every LCD panel manufacturer threw out all of their panels with one or more dead pixels, every monitor produced would cost the end user a lot more.

                                                                                                              For a start, nobody is saying that they have to throw them away. As I said, they could sell them at a discount as a second. Some people would be fine with that, others wouldn’t, that’s friendly to the customer and lets them make a choice with a tradeoff.

                                                                                                              It’s far more efficient from a manufacturing, environmental, and market standpoint to just sell the slightly imperfect panels at a discount and sell the perfect panels for whatever the market will bear for zero dead pixels. Which is exactly what most manufacturers do.

                                                                                                              That’s absolutely not what they do. They sell them all at a price somewhere between those two prices, and when you buy a monitor you roll the dice. Maybe you’ll be lucky, maybe you won’t. People that want a good monitor that actually works as advertised have to roll the dice, and someone that doesn’t care like yourself has to pay a higher cost (for your chance to get a perfect monitor) than they’d pay if they were able to specifically buy a monitor with a couple of dead pixels at a discount.

                                                                                                      1. 2

                                                                                                        Obviously this is a datapoint of one, but we are not switching to Vue from React.

                                                                                                        Angular 1’s deprecation created a lot of opportunity for companies to refactor, React it seems had a lot of inbound interest as a result.

                                                                                                        I don’t see this repeating with Vue unless React is deprecated (and shoots itself in the face like Angular 1)

                                                                                                        1. 1

                                                                                                          FWIW the reason we started using Vue is because it is easy enough to start using Vue here and there while other parts of the website remain more “antiquated”. React is a lot harder to gradually integrate.

                                                                                                        1. 1

                                                                                                          List and Column views

                                                                                                          Finally, a file browser outside of Mac OS that has Miller columns! Too bad it’s only for Elementary OS :-)

                                                                                                          1. 1

                                                                                                            You can actually install pretty much every package in elementary from their PPA: https://launchpad.net/~elementary-os/+archive/ubuntu/stable

                                                                                                            1. 1

                                                                                                              I didn’t know that! Unfortunately, though, I currently run OpenBSD :-)

                                                                                                          1. 3

                                                                                                            Maybe this will convince me to restart my LinkedIn account. It does seem to be a bit of a career hindrance not to have one.

                                                                                                            1. 5

                                                                                                              Wait until you start getting all the recruiting emails before you decide what’s more of a hindrance :)

                                                                                                              1. 4

                                                                                                                That and LinkedIn’s own un-blockable emails are what led me to delete my account in the first place 🙄

                                                                                                            1. 4
                                                                                                              vnoremap < <gv
                                                                                                              vnoremap > >gv
                                                                                                              

                                                                                                              gv is pretty nifty.

                                                                                                              1. 1

                                                                                                                That is a top tip indeed!

                                                                                                                1. 1

                                                                                                                  I’ve been 20% happier since I discovered that. Wish VSCode’s Vim emulation allowed me to do the same.

                                                                                                              1. 20

                                                                                                                Thanks to all the Monad’s tutorial and hype, when I first learned Haskell, a few years ago, it took me a few months to accept that I had understood Monads at the first glance.

                                                                                                                All those tutorials were just confusing. I was all thinking “what am I missing? it seem so simple! why nobody explains what I’m missing?”. I was missing nothing.

                                                                                                                A Monad is simply a wrapper. You have a function to wrap a value (return) and a function that applies to the wrapped value another function that returns a different wrapped value (bind). That’s it.

                                                                                                                1. 11

                                                                                                                  Completely agree with you!

                                                                                                                  See the eightfold path to monad satori from What I Wish I Knew When Learning Haskell:

                                                                                                                  1. Don’t read the monad tutorials.
                                                                                                                  2. No really, don’t read the monad tutorials.
                                                                                                                  3. Learn about Haskell types.
                                                                                                                  4. Learn what a typeclass is.
                                                                                                                  5. Read the Typeclassopedia.
                                                                                                                  6. Read the monad definitions.
                                                                                                                  7. Use monads in real code.
                                                                                                                  8. Don’t write monad-analogy tutorials.
                                                                                                                  1. 2

                                                                                                                    Thanks for this list. Someone on my team recently read and shared a “Monads are like Burritos” blog post. The post made several dubious analogies. The effect was that people felt like they understood Monads. In fact, they did not. This is worse than not understanding them and feeling like you don’t understand them.

                                                                                                                  2. 7

                                                                                                                    Seriously. People act like the concept is so complicated and it really isn’t. I definitely knew what monads were for a long time before all the elaborate metaphors muddled my understanding. So far I’ve gotten the most mileage by illustrating how to convert procedural code to “math style” single expression functions, and rolling from there.

                                                                                                                    1. 1

                                                                                                                      People correct me if I’m wrong because I’m not a Haskeller. I do keep reading these monad things and getting confused about it. One person told me it was basically just imperative programming in a functional language to make things happen in a certain order. I haven’t had anyone attempt to corroborate or refute that. Maybe just one. Your statement sounds similar.

                                                                                                                      It also reminds me of SSA form a little bit in how you describe it.

                                                                                                                      1. 15

                                                                                                                        I will corroborate that as a partial explanation. And it should remind you of SSA form, since it helps accomplish similar things. I think that’s a confusing place to start though, because people tend to ask why functional languages don’t just run things in a certain order anyway. And they do, take printNum( readNum() + 1 ), this will clearly read a number before trying to print the number.

                                                                                                                        Instead, assume we have a VM that only understands simple “math style” functions like:

                                                                                                                        f(x) = expression
                                                                                                                        

                                                                                                                        Such as:

                                                                                                                        square(x) = x * x
                                                                                                                        

                                                                                                                        So yes we could write:

                                                                                                                        main() = printNum( readNum() + 1 )
                                                                                                                        

                                                                                                                        But we could not write:

                                                                                                                        main() = print("multiple"); print("expressions"); print("in a sequence")
                                                                                                                        

                                                                                                                        That is, the VM does not implement multiple statements in a function, it expects only a single expression. Why not? Ignore that for now. This code will work though:

                                                                                                                        main() = printStage1()
                                                                                                                        printStage1() = printStage2(print("multiple"))
                                                                                                                        printStage2(x) = printStage3(print("expressions"))
                                                                                                                        printStage3(x) = print("in a sequence")
                                                                                                                        

                                                                                                                        See how that would work?

                                                                                                                        That’s tedious as hell to write though. Humor me, and now lets write it with lambda expressions. Lambda expressions are function values, i.e. these two definitions of main are equivalent:

                                                                                                                        main() = print("hello world")
                                                                                                                        main = λ() -> print("hello world")
                                                                                                                        

                                                                                                                        Notice I’m using main() = to define a named function, but just main = with lambda. This is exactly identical to the following javascript:

                                                                                                                        function main() { print("hello world"); }
                                                                                                                        main = function() { print("hello world"); }
                                                                                                                        

                                                                                                                        So we can rewrite our program like so:

                                                                                                                        main = printStage1
                                                                                                                        printStage1 = λ() -> printStage2(print("multiple"))
                                                                                                                        printStage2 = λ(_) -> printStage3(print("expressions"))
                                                                                                                        printStage3 = λ(_) -> print("in a sequence")
                                                                                                                        

                                                                                                                        Now lets inline some things, one step at a time:

                                                                                                                        main = λ() -> printStage2(print("multiple"))
                                                                                                                        printStage2 = λ(_) -> printStage3(print("expressions"))
                                                                                                                        printStage3 = λ(_) -> print("in a sequence")
                                                                                                                        
                                                                                                                        main = λ() ->
                                                                                                                                 (
                                                                                                                                   λ(_) -> printStage3(print("expressions"))
                                                                                                                                 )( print("multiple") )
                                                                                                                        printStage3 = λ(_) -> print("in a sequence")
                                                                                                                        
                                                                                                                        main = λ() ->
                                                                                                                                 (
                                                                                                                                   λ(_) ->
                                                                                                                                     (
                                                                                                                                       λ(_) -> print("in a sequence")
                                                                                                                                     )( print("expressions") )
                                                                                                                                 )( print("multiple") )
                                                                                                                        

                                                                                                                        We now have a strategy for compiling a sequence of expressions into a single lambda expression, that returns the result of the last expression. Notice that I used underscores for the lambda args, because their result was unused by the function. But what if our program uses variable names? These are equivalent:

                                                                                                                        main() = {
                                                                                                                          n = readNum();
                                                                                                                          printNum(n);
                                                                                                                        }
                                                                                                                        
                                                                                                                        main = λ() ->
                                                                                                                                 (
                                                                                                                                   λ(n) -> printNum(n)
                                                                                                                                 )( readNum() )
                                                                                                                        

                                                                                                                        Hopefully you can now see that we could write a compiler that converts normal imperative code with variable assignments and so on into an unreadable chain of simple lambdas.

                                                                                                                        So why would you want to do that? Well, if this was a language we were implementing, we can add imperative syntax to our language without actually extending the VM. Our language interpreter can pre-process the code into simple lambdas, then the VM only has to know how to execute simple lambdas. That’s neat.

                                                                                                                        It also lets us make radical simplifying assumptions, just like SSA. Function calls can be evaluated in any order, as long as all its arguments have been evaluated first, just like SSA. But the way we’ve done it so far makes every line dependent on every previous line. So now lets split = into = and <-, where = denotes a weakly ordered assignment, and <- denotes a strongly ordered assignment.

                                                                                                                        main() = {
                                                                                                                          a = 7
                                                                                                                          b = 2
                                                                                                                          x <- readNum()
                                                                                                                          y <- readNum()
                                                                                                                          _ <- printNum(a / x + b / y)
                                                                                                                        }
                                                                                                                        

                                                                                                                        We don’t actually need to create a new lambda until we hit a strong assignment. So this simple lambda code is equivalent:

                                                                                                                        main = λ() ->
                                                                                                                                 (
                                                                                                                                   λ(a, b, x) ->
                                                                                                                                     (
                                                                                                                                       λ(y) -> printNum(a / x + b / y)
                                                                                                                                     )( readNum() )
                                                                                                                                 )( 1, 2, readNum() )
                                                                                                                        

                                                                                                                        Okay but what if we screwed up and wrote this:

                                                                                                                        main() = {
                                                                                                                          a = 7
                                                                                                                          b = 2
                                                                                                                          x = readNum()
                                                                                                                          y = readNum()
                                                                                                                          printNum(a / x + b / y)
                                                                                                                        }
                                                                                                                        

                                                                                                                        Which would compile to this:

                                                                                                                        main = λ() ->
                                                                                                                                 (
                                                                                                                                   λ(a, b, x, y) -> printNum(a / x + b / y)
                                                                                                                                 )( 1, 2, readNum(), readNum() )
                                                                                                                        

                                                                                                                        If functions can be evaluated in any order, will x or y be read first? It’s undefined. Either readNum() call could run first. You shouldn’t be allowed to weakly order things like IO. That should be an error. One way to do that is to give readNum a type, that insists its return value must be strongly assigned. But readNum should also be ordered with respect to printNum, and anything else that does IO.

                                                                                                                        So lets define these functions with a special return type that says they are both IO:

                                                                                                                        readNum(): IO(Number)
                                                                                                                        printNum(n: Number): IO()
                                                                                                                        

                                                                                                                        This IO wrapper type must be strongly assigned, and the result of its assignment will be its inner type. That is, these are basically equivalent:

                                                                                                                        x: Number = 1
                                                                                                                        x: Number <- IO(1)
                                                                                                                        

                                                                                                                        That’s the IO monad.

                                                                                                                        The strong assignment operator <- is called bind. A monad’s bind function takes a function, and returns a new monad, that represents the result of applying the function to the monad’s inner value. Using our typed readNum and printNum, our program looks like this:

                                                                                                                        main() = {
                                                                                                                          a = 7
                                                                                                                          b = 2
                                                                                                                          readNum().bind(
                                                                                                                            λ(x) -> readNum().bind(
                                                                                                                              λ(y) -> printNum(a / x + b / y)))()
                                                                                                                        }
                                                                                                                        

                                                                                                                        If you’ve ever written node.js before, you might be thinking hey wait a minute, that’s just an IO callback! Honestly yeah, pretty much. But with strong typing and syntax sugar. We can write this:

                                                                                                                        x <- readNum()
                                                                                                                        y <- readNum()
                                                                                                                        printNum(x + y)
                                                                                                                        

                                                                                                                        But if we write this, it’s a type error:

                                                                                                                        x = readNum()
                                                                                                                        y = readNum()
                                                                                                                        printNum(x + y)
                                                                                                                        

                                                                                                                        Why? Because the + operator has the type signature Number + Number, not IO(Number) + IO(Number). Even if + was defined for IO(Number), printNum still takes a Number, not an IO(Number). The type system forces us to bind properly.

                                                                                                                        So now our VM (or compiler) can treat all assignments as weak, because we’ve implemented strong assignments on top of weak assignments and lambdas. Normally assuming all assignments are weak by default would make the language hugely error-prone to use. But the IO functions all return an IO monad, so the type system protects us. Constrast with a conventional imperative language, that must assume all assignments are strong unless it can prove otherwise.

                                                                                                                        Naturally the weak assignment strategy opens up a lot more opportunities for certain kinds of optimization. Haskell still hasn’t taken over the world though, cause there are a lot of other opportunities for optimization, like hand writing vectorized assembly. That kind of thing is harder to do in Haskell than e.g. C.

                                                                                                                        1. 3

                                                                                                                          That’s one of the ways Haskell uses monads, but IIRC (and I probably don’t RC), that’s driven more by Haskell’s lazy evaluation than a fundamental property of functional languages.

                                                                                                                          A more general use case of monads is the Maybe monad, which lets you control for nulls. If a function could return an integer or a null, you instead say its return value is Maybe Int. Then the type system can enforce that anything that calls that function handles both the integer case and the “null” case.

                                                                                                                          1. 2

                                                                                                                            I do keep reading these monad things and getting confused about it.

                                                                                                                            Monads are mathematical structures. They have nothing to do with computer programming whatsoever. In fact, monads are so ridiculously general compared to most other mathematical objects that there is no way they could serve a concrete purpose for non-mathematician standards. So the first thing monads are not is “something you use”.

                                                                                                                            Theoretical computer scientists (read: mathematicians) discovered [0] that you can “give a semantics” to a higher-order [1] strict [2] language in which “types” are denoted by “objects in a category C”, and “a computation that produces a value of type B from a value of type A” is denoted by “an arrow A -> TB”, where T is “a strong monad over C”. The tl;dr of all this [3] is that monads are “something intrinsic to the very structure of the programming languages we use”, just like the Earth’s gravitational field is “something intrinsic to the very structure of the world we live in”. You don’t need a mathematical model for it to exist, although it is nice to have one for some purposes.

                                                                                                                            However, Haskell is a lazy language, so it is intrinsically comonadic rather than monadic. (Again, [3].) And, while Haskellers like their lazy language overall, they also want the sequential structure of their effects to be more like what strict languages have, because lazy effectful computations are insanely hard to reason about. So you could say Haskellers have monads in their standard library because they don’t have it in their core language.

                                                                                                                            I have made essentially the same point elsewhere.


                                                                                                                            Footnotes:

                                                                                                                            [0] As opposed to “created”, like operating systems, word processors or computer games are.

                                                                                                                            [1] Having procedures as first-class values, e.g., Lisp, Python, Java, ML, Haskell.

                                                                                                                            [2] Reducing arguments to a normal form before they are passed to a function, e.g., Lisp, Python, Java, ML, but not Haskell.

                                                                                                                            [3] Lots of details omitted. It doesn’t really matter what any of this means anyway.

                                                                                                                            1. 1

                                                                                                                              Your distinction between “discovered” and “created” seems to presuppose Platonism, which is a rather contentious issue in the philosophy of mathematics. A Formalist would say that math is indeed created, and that while the implications of a mathematical system may not be known for a long time, math is still a product of a human mind.

                                                                                                                              1. 1

                                                                                                                                I’m by no means a Platonist. I’m just saying monads weren’t invented for this specific purpose. Noticing connections between seemingly unrelated mathematical theories happens all the time.

                                                                                                                        2. 6

                                                                                                                          Explaining monads to programmers is like explaining commutativity to accountants.

                                                                                                                          1. 4

                                                                                                                            Yep. This is why I shifted to trying to teach people to understand the concept of data that obeys laws. That’s the real issue: they see “monad laws” and they freeze.

                                                                                                                            1. 7

                                                                                                                              Probably easier for statically typed OOP people to just hear interface. A monad is a kind of interface for some generic type with a constructor and an aggregate/flatmap where the returned generic is the same type as the input.

                                                                                                                              I think most of the struggle in learning that its just a type with a bind and return is people worry about teaching the math behind it. This is a bad idea. If you’re going to teach math, teach math, and if you’re going to teach programming teach programming. You don’t need to understand the abstract backbone to understand that you can use this thing to manage side effects.

                                                                                                                              1. 1

                                                                                                                                What exactly is a nontrivial data structure, if not “data that obeys laws”?

                                                                                                                              2. 3

                                                                                                                                This, a million times over. When I learned about monads in university, the concept was simple and intuitive and I recall just “getting it.” A couple years ago I decided to learn Scala (after a decade of using imperative languages), and a lot of the tutorials made a big deal about monads and tried to explain them in the most obtuse manner, using all kinds of computer science terms and references. For a while I questioned whether I had actually ever understood monads.

                                                                                                                                1. 1

                                                                                                                                  I’m in the process of learning Haskell myself right now and I feel myself slowly coming to this same conclusion. I think part of the reason they seemed complicated on the surface, for me at least, is due to how heavily they are used in so much Haskell code out there.

                                                                                                                                  Also because of the abstraction-driven nature of Haskell, I’m always aware that there’s (potentially) a lot happening behind a small operator or function so as a beginner I assume there’s a lot of magic happening that I just don’t understand yet. Couple that with terms for these concepts that are rooted in mathematics (and thus unfamiliar with your average dev, like myself) and you get a recipe for assuming there’s always more to understand.

                                                                                                                                  1. 1

                                                                                                                                    I think it really took this video for that to get across to me. This whole time I thought I was still missing something. It turns out I use Monads all the time!

                                                                                                                                  1. 11

                                                                                                                                    This article has a very low quality: it reports on two not interesting facts (retrieving code via http and loading a DLL from current directory). Why is it upvoted so much?

                                                                                                                                    1. 14

                                                                                                                                      Two relevant points at least: (1) an unverified binary is downloaded and installed and (2) on Windows outdated and likely exploitable versions of OpenVPN and OpenSSL are installed.

                                                                                                                                      Then there’s the other more trivial stuff in the article that may or may not be interesting.

                                                                                                                                      Despite the abrupt nature of the article, it seems worth talking about.

                                                                                                                                      1. 4

                                                                                                                                        Yeah, I’m kind of appalled that the author completely glanced over the setup step where you download the script asking you to send your password over an unsecured connection. Forget about a man in the middle attack that switches the script, all you need is to log the HTTP requests and you get the user’s password.

                                                                                                                                        1. 4

                                                                                                                                          They seem to stop because “they couldn’t be bothered” right where things could be about to get interesting. Which is fine ofc, that’s their prerogative, but it leads to a largely uninformative article.

                                                                                                                                          1. 1

                                                                                                                                            Yeah, something has got to be wrong here. How can an article have 49 upvotes but not a single comment in its first 13 hours?

                                                                                                                                            1. 8

                                                                                                                                              It’s an interesting find but not super engaging. It’s gross incompetence with very much not industry best practices. There isn’t much to learn from this other than “don’t write sketchy code”.