sullyj3

I despise Trump, but claiming that talking about his shortcomings is an apolitical conversation is totally disingenuous. Politics isn't this bloodless process of determining the best policies by rational debate, as much we'd like it to be. Politics, as often as not, consists entirely of making the other team look bad, to raise the relative status of your own team. That's just how humans operate.

The dynamics here reminds me of https://www.lesswrong.com/posts/ZQG9cwKbct2LtmL3p/evaporativ...

It seems plausible to me that it's just a consequence of some contingent aspect of the design of the location system, and there's not a compelling reason to refactor.

sshfs is the biggest one for me. Allows you to use all your local tools.

> Why can't methods (for instance) get displayed as convenient, without worrying about where they are in the file?

This is something unison is playing with with their codebase manager.

https://www.youtube.com/watch?v=gCWtkvDQ2ZI

oops!

> I'm willing to longbets that by 2025 we see a Rust framework as the top browser toolkit.

I might be willing to take that, depending on the odds and the deciding method for determining the "top browser toolkit".

The way maths is taught in Australia, for a long time the term function was synonymous with the concept "2D plot that passes the vertical line test" in my mind. I was completely unaware of how much broader and more interesting a concept functions are. There are probably many people whose understanding never progresses beyond this, which I think this is extremely unfortunate.

musical notes repeat once every doubling of frequencies, so there are many C#s spread throughout the range of human hearing. The only way someone could be unable to hear c# would be if they were unable to hear at all.

There seems to a large contingent of linux users who are somehow completely immune to garbage user experience. It's really impressive.

The graphical and audio applications for linux aren't worthwhile, or at least they're not competitive with the top proprietary offerings. It's not really about the theoretical capacity of of linux to support audio and graphics. The low market share of desktop linux makes it not economically worthwhile for top proprietary software companies to port to linux. That's just an unfortunate fact. I don't really want to edit graphics with Gimp when Photoshop exists, and I don't really want to produce music in Ardour when Ableton Live exists.

I think the only real way to fix this is to change the economic incentives by increasing desktop Linux market share, which is a long and uphill battle.

Because I don't want to have to reboot every time I want to do something else with my computer.

Check out Rust and Haskell, both have the ability to derive the interfaces/traits/typeclasses for equality and comparison automatically.

Not a great headline really, C is nearly 50, but most people wouldn't consider it a disaster for everything to be written in C. The problem isn't that COBOL is old, it's that it's largely obsolete.

The benefit of significant whitespace is that you can't write code like this:

  int foo() {
         a();
    b(); 
          c();
  if (test())
    doSomethingIfTest();
    doSomethingUnconditionally();}

The reason the first element is used as the pivot is that these are linked lists, not arrays, so it would take linear time to access the middle and end. This isn't a real quicksort.

Somebody said it, but it's glib, and not particularly true. I believe it was a comment on do notation, the bind operation, and programmable semicolons. The customizability is definitely cool, but nobody could possibly argue that imperative programming in Haskell is ergonomic.

Sure, IO and ST are escape hatches, but they're not escape hatches that beginners struggling with the concept of a higher order function are going to be able to use.

It's definitely possible to write "boring Haskell". getting fancy is more of a cultural tendency than a necessity when building things with Haskell.

https://www.snoyman.com/blog/2019/11/boring-haskell-manifest...

Wow, this is pretty damning. The author seems fairly level headed and the criticisms feel well reasoned. I've played around with elm a little bit, but this really puts a damper on my desire to dive in further. Hopefully the core team takes some of this criticism on board.

Another reasonable hypothesis is that only the elite had the opportunity to become authors

What's the point of humiliating evil? Seems more like a petty human impulse than a deific one.

This equation is missing a term for lost sales due to damage to public image.

It seems to me that the things people like about the haskell style syntax are

1. Don't have to name the parameter

2. less nesting.

You can get the best of all worlds with lambdacase style constructs. You don't need to write out the name of the function a bunch of times.

  function = \case
    SpecialCase ->
      ...
      handle_odd_special_case;
    Default ->
      ...
      main_business_logic;

That's not as rhetorically powerful.

Probably the scale.

Chrome does this more simply, but the feature is less discoverable. you don't have to create the keywords manually, you just hit tab after entering the URL where the search box is located. since the URL is autocompleted, for frequently used websites this is a matter of typing the first two or three characters and then hitting right arrow.

Due to GHC's fusion, they're often not even created. They're used more like control flow constructs than arrays.

I mean, they could be, theoretically, but generally authors try to make the number a good reflection of the project's status.

  sum([1,1]) = 1 + 1 = 2
  sum([1]) = 1
  sum([]) = 0

  0 + n = n + 0 = n

Zero is the unit with respect to addition, so when we add together a list of no numbers, we ought to get back zero.

you can `from math import prod` in python3.8

  prod([2,2]) = 2*2 = 2
  prod([2]) = 2
  prod([]) = 1

  1 * n = n * 1 = n

The same way, one is the unit with respect to multiplication. So, multiplying no numbers together gets you one.

  all([True,True]) = True && True = True
  all([True]) = True
  all([]) = True

  True && x = x && True = x

You get the idea.