WTF Bites

SirTwist

@Tsaukpaetra Eh fuck Apple, the only mac on the network belongs to one of the other sw devs and he's been working from home since April so coming in via VPN, and phones shouldn't be on the internal network. I really don't want to fuck with renaming the domain AGAIN (it was set up by a friend of the boss originally with an .inc top level domain we didn't own, before .inc was even a possibility) and I've got a few people moved on to it already. The Big Move has been pushed off because of no-time-to-switch-shit-over-this-has-to-be-done-next-week for more than 5 years now.

Wikipedia says 8.8.8.8 is a global anycast, so I will probably set Panama to use that Real Soon Now™ since I've already put in a CNAME for the Subversion server, which will be moving as soon as I get the last two users off that old DC and shut down that VM.

Tsaukpaetra

@pie_flavor said in WTF Bites:

Monad is the simple term for 'a function taking a thing with elements and also taking a function that takes one of said elements and returns another thing that's the same kind of thing as the first thing, which then applies the function to each element of the first thing and produces the same kind of thing as the first thing with all the produced things joined together'. Dunno how you'd simplify it further.

So, a function where:

Accepts I as a collection of T elements
Accepts function Y that accepts a T element and returns a T element
Iterates I's T elements, executing Y for each T element
Returns resulting collection of T elements

Great!

Maybe: A function that applies a function across a collection of things that gives back a (new?) collection of the same type of things.

@pie_flavor said in WTF Bites:

this is really simple and used everywhere, even in procedural programming.

I have done this.... five times? Maybe? Maybe I'm not recognizing all the everywhere it's used because I've never heard it called a mobad ever at any time.

@pie_flavor said in WTF Bites:

Treating each function as though it has only one parameter and returns another function with the rest of the parameters is beyond stupid and I really can't wrap my mind around someone who would program in a language with those semantics and call it fun.

Who is doing that? What? What manner of straw man are you shooting at now?!?

@pie_flavor said in WTF Bites:

That is a monad. I'm not changing anything.

You're right, you're just tossing out red herrings to avoid the problem. Sorry.

pie_flavor

@Tsaukpaetra said in WTF Bites:

Who is doing that? What? What manner of straw man are you shooting at now?!?

Functional people are. That's how Haskell works.

Tsaukpaetra

@pie_flavor said in WTF Bites:

@Tsaukpaetra said in WTF Bites:

Who is doing that? What? What manner of straw man are you shooting at now?!?

Functional people are. That's how Haskell works.

Alright. Well I have no experience in any of that so... whatever I guess. You shoot at who you will.

Watson

@pie_flavor said in WTF Bites:

@Tsaukpaetra said in WTF Bites:

Who is doing that? What? What manner of straw man are you shooting at now?!?

Functional people are. That's how Haskell works.

One argument -> one return value. Both of the same type: endofunction! Self-composable! Find an identity element: Monoid!

I think one of the reasons why category theory has the jargon it has is because it is so abstract: there are so many areas in which it can be applied (set theory, relational database theory, anything that can be interpreted as a monoid...) that those applications have already used up the more familiar terms, and to use them again at two levels of abstraction would get excessively confusing.

Kamil Podlesak

@Benjamin-Hall said in WTF Bites:

And you still haven't explained how null coalescing (which I understand just fine, thank you very much) is a monad/flatMap--it doesn't fit the definition you provided. It's just syntactic sugar for nested conditionals. It doesn't care about collections of things at all--it doesn't care what T is in Optional<T>. Unless you force Optional to be a collection type. Which it isn't necessarily, or if it is, that's an implementation detail not an underlying fundamental.

That is the point: (nested) conditionals and collections (and surprising number of other things) actually have something fundamental in common. If you extract that common part, you can use it as a library and the main code can contain only the different parts.

Code reuse, the holy grail of programming!

Is this enough as an elevator pitch?

Zecc

@pie_flavor said in WTF Bites:

It's easy. A monad is flatMap / and_then / SelectMany, except in general. It's a kind of endofunctor, which represents its property of the same type coming out as went in.

A monad is someone who lives on the move, without fixed redisence.
There are whole tribes of monads travelling in cavarans.

Gąska

@pie_flavor said in WTF Bites:

Treating each function as though it has only one parameter and returns another function with the rest of the parameters is beyond stupid and I really can't wrap my mind around someone who would program in a language with those semantics and call it fun.

I do. It's cool because it lets you avoid a lot of trivial wrapper lambdas and intermediate variables when doing a lot of flatmaps etc. Especially fun with the pipe operator.

Instead of:

let c1 = collection.filter(fun x -> x.contains('0'))
let c2 = c1.map(fun x -> stringToIntRadix(16, x))
c2.map(fun x -> max(0, x))

You get:

collection
|> filter (String.contains '0')
|> map (stringToIntRadix 16 |> max 0)

If I wasn't a hateful man and a bit paranoid about doxxing, I'd show you my recent OCaml project where currying saved me at least 20% character count.

Gąska

@Tsaukpaetra said in WTF Bites:

@pie_flavor said in WTF Bites:

Treating each function as though it has only one parameter and returns another function with the rest of the parameters is beyond stupid and I really can't wrap my mind around someone who would program in a language with those semantics and call it fun.

Who is doing that? What? What manner of straw man are you shooting at now?!?

Bulb

@Benjamin-Hall said in WTF Bites:

(because Python treats all mutable parameters as being ref implicitly, one of the more annoying things it does)

No, it definitely does not. It merely has referential semantics for all complex objects, but most languages do that.

A ref in C# means you can change the value of the variable. <abbr title="Off the top of my head and I don't regularly write C#, so it might not be exactly syntactically right'>I.e.

void Add(ref int variable, int value) {
    variable = variable + value;
}
…
    int x = 5;
    Add(x, 3);
    // x == 8 here!

You can never do that thing in Python! What you can do is e.g.

def append_to(list, value):
    list.append(value)
…
l = list()
append_to(l, 5);
// l == [5] here

but you can do the equivalent thing in C# without ref keyword:

void AppendTo(List<int> list, int value) {
    list.Add(value);
}
…
    var l = new List<int>();
    AppendTo(l, 5);
    // l == { 5 } here!

And neither C# nor Java have C++'s const to prevent the mutation here though you can pass an interface that does not contain any of the mutating methods to the same effect if you have one defined.

pie_flavor

@Gąska but that's just collection.filter(fun x -> x.contains('0')).map(fun x -> stringToIntRadix(16, x)).map(fun x -> max(0, x)), is it not? What does |> there offer that . does not?

pie_flavor

@Bulb Yes C# does - it's called in

Gąska

@pie_flavor said in WTF Bites:

@Gąska but that's just collection.filter(fun x -> x.contains('0')).map(fun x -> stringToIntRadix(16, x)).map(fun x -> max(0, x)), is it not? What does |> there offer that . does not?

Tidiness. Readability. Structure. And not needing everything to be a method.

I admit I had a mind derp and the extra variables are unnecessary (here, not in general - so let's say it's half a point). But not having to write all those "fun x ->" is still cool. Also, note one less map without making a convoluted multi-statement lambda.

Bulb

@pie_flavor said in WTF Bites:

@Bulb Yes C# does - it's called in

Well, sort of, but not really. When the parameter is a value type, in makes it be passed by constant reference, but when the parameter is an object type, it is always passed by reference and this reference cannot be made constant (in should make that const-refernce-to-non-const-reference, which is useless). So while technically in does the same thing as const & in C++, it only works for a specific subset of cases.

Gąska

@pie_flavor said in WTF Bites:

@Bulb Yes C# does - it's called in

using System;
using System.Collections.Generic;

public class Test
{
	private static void letsMakeFunOfPieFlavor(in List<int> list)
	{
		list.Add(20);
	}

	public static void Main()
	{
		var list = new List<int> { 10 };
		letsMakeFunOfPieFlavor(list);
		list.ForEach(Console.WriteLine);
	}
}

Let's make fun of @pie_flavor | C# Online Compiler | .NET Fiddle

pie_flavor

@Bulb The exact same subset of cases as in C++ - i.e. cases in which the type in question is a value type. It doesn't work for reference types in C#, which is identical to C++ because in C++ it doesn't work for reference types either, being as they don't exist.

Bulb

@pie_flavor C#'s in is equivalent to C++'s const &, not just const, which modifies the reference that's already there (always explicit, unlike C#, where it is implicit in most of the interesting cases).

Gąska

@Bulb to be specific, C# has equivalents of C++'s const T and T& const but nothing for const T&.

Zerosquare

@Tsaukpaetra said in WTF Bites:

I own tsaukpaetra.com

http://tsaukpaetra.com/ times out.

http://www.tsaukpaetra.com/ redirects to https://tsaukpaetra.com/, which works.

I'd file that as a bug, but knowing you, it might be a feature.

Gąska

@Zerosquare said in WTF Bites:

@Tsaukpaetra said in WTF Bites:

I own tsaukpaetra.com

http://tsaukpaetra.com/ times out.

He just said he owned it, didn't he!?

Urban Dictionary: Owned

Bulb

@SirTwist said in WTF Bites:

This *.local wildcard would fuck up mDNS too presumably, so is still a WTF.

No, because mDNS is queried before DNS, so anything that mDNS knows about gets resolved correctly.

boomzilla

@Benjamin-Hall said in WTF Bites:

@Gąska said in WTF Bites:

@Benjamin-Hall said in WTF Bites:

@topspin I just helped someone with a very simple issue[1] who tried to think in terms of functional programming. Except without really understanding much of it beyond a few random buzzwords. It was...sigh.

[1] "why should I return data from my Python functions instead of simply relying on side-effects[2]?"

[2] specifically, he was using Pandas, which has a mutable dataframe object. So sure. You can pass it into a function, mutate it, and the mutation sticks outside the function (because Python treats all mutable parameters as being ref implicitly, one of the more annoying things it does). So he was passing it in, mutating it, and then returning None (technically not including a return statement at all, but...). And was getting confused as to how the magic was happening. Yet he was also talking about functional programming and first-order functions, preferring map over loops, etc. Didn't seem to understand the concept of pure functions, however.

Weird. Sounds like he knows everything he needs to know except reference semantics. How he arrived there, I have no idea.

To be honest, this person has...issues. He's not stupid, but there are certainly other mental health issues involved, plus pushing out of some substance abuse issues. So I'm pretty sure he understands lots of things that are just scrambled due to prior problems. But it was mostly "can talk cogently about higher-order functions, etc, but struggles with really basic concepts that are at the core of those things."

That's kind of like a phase I go through when learning a lot of things. Certain aspects make (or seem to make) sense immediately. Others are kind of a mystery and I chug along with trial and error. At some point I have an epiphany and some fundamental thing about the subject reveals itself to me and suddenly everything else falls into place.

Gąska

@boomzilla but the particular combination of what clicked for this person and what didn't makes his case very peculiar.

boomzilla

@Benjamin-Hall said in WTF Bites:

Can you explain a monad (both the idea and the application) without using any term associated with functional programming? That is, no flatMap, no talking about mapping, functors, or any such thing? Basically, I'm asking you to ELI5.

I think the most important thing is to avoid talking about them altogether. Once you understand what they are, you realize they are kind of trivial (if fundamental). It's almost like going on and on about semi-colons when trying to explain C. The listener gets the impression (from the speaker's enthusiasm) that there's some great thing going on and so keeps looking for something sublime when it's just not there.

Gąska

@boomzilla although making something a monad gives you access to some pretty cool libraries for working with your custom class that you just wrote, in languages where monads can be encoded in the type system. Somewhat like implementing IEnumerable interface in .Net, except monad is more general and therefore both more and less useful. And few type systems are elaborate enough to allow it.

All in all, whenever you see practical applications of advanced type theory, it's always about generic programming.

Gąska

One more thing. Another reason currying (single-argument functions returning functions instead of multi-argument functions) is nice is - again - generic programming. If you have a generic function that takes arbitrary other function as an argument, currying means it can accept multi-argument functions and treat them the same as single-argument functions - including things like calling them and saving the return value.

boomzilla

@Gąska agreed. The problem, I think (and to elaborate on my previous comment) is that the people who tend to be functional programming advocates are really into the math and think it's very cool (and I'm not saying that it isn't) but it's not so cool to the person who just wants to get shit done.

It's like being excited about DAGs when discussing why using version control is important. Technically true but it just makes people want to give you a wedgie and shove your head in a toilet.

Gąska

@boomzilla said in WTF Bites:

It's like being excited about DAGs when discussing why using version control is important. Technically true but it just makes people want to give you a wedgie and shove your head in a toilet.

On the other hand, the fact that Pijul's patches are always commutative might have earth-shaking consequences for the workflow of future programmers, if it ever becomes popular. Math has very real consequences even when people don't see it (static type checking is basically extended set theory) - it's just that people interested in such things are generally assholes. Like me.

Rhywden

WTF of my day: So, I'm subscribed to a digital version of a weekly newspaper. I recently wanted to check when the next payment was due. That's when I noticed that their subscription management page offers everything - save for a "Cancel subscription" method.

I'm not quite sure but I think I've read that it's borderline illegal now to have a method to subscribe but not to offer the same method to cancel (i.e. you let someone sign up by telephone but suddenly it's not possible to cancel by telephone for "security reasons").

Then again, their FAQ explicitly states that there should be a "Cancel Button" but there isn't.

So I wrote them an email which basically amounts to "You forgot something on your website", including helpful screenshots.

What I got back was an answer: "In order to help you, we need your account number!"

So I just wrote them back: "In order to provide that, I need you to read what I wrote first!"

I really love stupid (tech) support drones incapable of recognizing that not everything is included in their nice scripts.

Tsaukpaetra

@Zerosquare said in WTF Bites:

@Tsaukpaetra said in WTF Bites:

I own tsaukpaetra.com

http://tsaukpaetra.com/ times out.

http://www.tsaukpaetra.com/ redirects to https://tsaukpaetra.com/, which works.

I'd file that as a bug, but knowing you, it might be a feature.

Yeah, Cox blocks port 80 unless you pay disproportionately more for a "business" account.

Tsaukpaetra

@Rhywden said in WTF Bites:

I really love stupid (tech) support drones incapable of recognizing that not everything is included in their nice scripts.

I do! Sadly I left because it was way too hard to be a shining star while still complying with metrics...

dkf

@topspin said in WTF Bites:

(Academia doesn’t exactly move fast when it doesn’t come to ML garbage)

The only thing that academia truly, consistently moves fast for is applying for more funding.

Bulb

@Gąska said in WTF Bites:

On the other hand, the fact that Pijul's patches are always commutative […]

Actually, no, they are not.

https://pijul.org/manual/why_pijul.html#patch-commutation:

In Pijul, for any two patches A and B, either A and B commute, (in other words, A and B can be applied in any order), or A depends on B, or B depends on A.

In practice cherry-picks often require some manual wiggling, in which case Pijul (and Darcs) would simply consider the patches dependent and pull things you didn't want. While in other cases the patches are only dependent semantically, so Pijul (or Darcs) won't pull them together, but the result won't build, requiring manual intervention again. These make the patch algebra much less helpful in practice than it sounds.

Learning the patch algebra back when Darcs first came with it did help me greatly many times over the years when resolving conflicts and sorting out what to merge where. But I don't think the automation would have helped me any more as it always needed understanding of the code beyond what the automation could have.

Gąska

I can't believe that the single most common notification you will ever receive from MS Teams is "Someone mentioned General in General", yes no one, absolutely no one at the entire Microsoft thought that maybe some better wording could be invented.

dkf

@Gąska said in WTF Bites:

It's kinda like RAII - non-C++ programmers used to find it unnecessary because they don't need it, then they've got using and now they find it unnecessary because they already have it under different name.

C++ is the Apple of programming languages, “inventing” stuff “differently” that's been in other places for many years.

Bulb

@Gąska said in WTF Bites:

I can't believe that the single most common notification you will ever receive from MS Teams is "Someone mentioned General in General", yes no one, absolutely no one at the entire Microsoft thought that maybe some better wording could be invented.

Do you mean literally “Someone” or just some random username? That it only mentions the channel name and not the team it belongs to is indeed , but as far as I remember it always said who.

Also, why are you getting notifications when somebody mentions a channel? I don't think I am getting those.

Gąska

@Bulb said in WTF Bites:

@Gąska said in WTF Bites:

On the other hand, the fact that Pijul's patches are always commutative […]

Actually, no, they are not.

Why Pijul - The Pijul manual

:

In Pijul, for any two patches A and B, either A and B commute, (in other words, A and B can be applied in any order), or A depends on B, or B depends on A.

Okay, have your badge. Two patches are always either commutative or form linear history.

In practice cherry-picks often require some manual wiggling, in which case Pijul (and Darcs) would simply consider the patches dependent and pull things you didn't want. While in other cases the patches are only dependent semantically, so Pijul (or Darcs) won't pull them together, but the result won't build, requiring manual intervention again. These make the patch algebra much less helpful in practice than it sounds.

Cherry-picking is very rarely needed compared to other VCS operations. And where Pijul's patch algebra really shines is merges. Because Pijul files are DAGs and not flat sequences, it is possible two commit a merge conflict, have two conflicting versions of a file coexist in the same revision, continue working on other parts of code and make further commits, and only then resolve that merge conflict. And the result will be identical to resolving the conflict right away. You can even commit your conflicts, push them, and let someone else take care of resolving them! The possibilities are endless. Darcs doesn't offer anything like that AFAIK.

Bulb

@dkf said in WTF Bites:

@Gąska said in WTF Bites:

It's kinda like RAII - non-C++ programmers used to find it unnecessary because they don't need it, then they've got using and now they find it unnecessary because they already have it under different name.

C++ is the Apple of programming languages, “inventing” stuff “differently” that's been in other places for many years.

E.g. std::transform (instead of map like everywhere else – common theme in the standard library). But I don't think that's the case with RAII. For all I can tell RAII was invented in C++.

Note that using is a very weak infusion of RAII. The point of RAII is that it composes automatically, because it also applies to instance scope.

Gąska

@dkf said in WTF Bites:

@Gąska said in WTF Bites:

It's kinda like RAII - non-C++ programmers used to find it unnecessary because they don't need it, then they've got using and now they find it unnecessary because they already have it under different name.

C++ is the Apple of programming languages, “inventing” stuff “differently” that's been in other places for many years.

Except C++ really was first - at least as far as mainstream languages are concerned. I mean, what year was using added to Java? 2010? When were destructors added to C++?

Gąska

@Bulb said in WTF Bites:

@Gąska said in WTF Bites:

I can't believe that the single most common notification you will ever receive from MS Teams is "Someone mentioned General in General", yes no one, absolutely no one at the entire Microsoft thought that maybe some better wording could be invented.

Do you mean literally “Someone” or just some random username?

Random username. But "General in General" is literal. Joe mentioned General in General. Patrick mentioned General in General. Marge mentioned General in General. I see it at least once an hour.

Bulb

@Gąska

Why are people at your company mentioning channels?
Yes, it should be saying General of which eFfing team, especially since all teams have a “General” channel by default.

Gąska

@Bulb said in WTF Bites:

@Gąska

Why are people at your company mentioning channels?

To ping everyone in said channel because they have something important to say. Basically @here except MS Teams has no @here.

Yes, it should be saying General of which eFfing team, especially since all teams have a “General” channel by default.

Or just not repeat the channel name twice if the mention is in the same channel.

topspin

@pie_flavor said in WTF Bites:

@Benjamin-Hall said in WTF Bites:

@pie_flavor said in WTF Bites:

@Benjamin-Hall As I understand it, you are complaining that there is a word for a concept. Even though you acknowledge the concept exists, even though every modern programming language and quite a few archaic ones too have it, even though it's an operation that's useful sometimes to express independently of what language you're implementing it in.

Not complaining. Just wondering why it's such a big deal.

It's not.

This, I think, is the actual point to make. For the people asking it, it doesn't really matter. See below.

And why it's so darn difficult to get people to use simple terms for things instead of immediately resorting to jargon.

The difference between 'a simple term' and 'jargon' is whether you understand it yet. Monad is the simple term for 'a function taking a thing with elements and also taking a function that takes one of said elements and returns another thing that's the same kind of thing as the first thing, which then applies the function to each element of the first thing and produces the same kind of thing as the first thing with all the produced things joined together'. Dunno how you'd simplify it further.

It is a pretty simple concept when you just look at it by itself. The problem is when it comes up in an explainer's variant of the X-Y problem. You actually wanted to know something completely different, the monad thing got presented as a crucial part of the answer and now you're asking more questions to understand it and get completely lost, whereas the whole monad thing was tangential at best.

What I mean:
: Okay, this functional paradigm seems pretty cool. If I don't have side effects I don't have to worry about them. One less thing to look out for. But in the end, I actually need some side effects for my program to be useful, right? So how do I do output if the language strictly prevents side effects?
: For output you use the IO monad.
&zwj; : What's that? What do I do??
: A monad is just a monoid in the category of endofunctors. They are great, you can write your own and they're super useful. The IO monad is the one that does output.
You fucking what, mate?

Then the discussion delves deeper and deeper into the monad stuff, leaving just more confused, when it didn't really matter to begin with. The whole monad was a red herring that just distracted from the actual question.
From my (incomplet and inkorrect) understanding, the IO monad is just some built-in magic that handles something that you actually cannot write in the language itself, comparable to something like an unsafe block or a JNI interface (if you pretend you cannot write those because now you've "left" the safe space of the language). That's what you need to know, it's a built-in bridging the pure and non-pure parts by handling the sequencing, executing exactly once, etc. for you and actually doing the output. That it's a monad is the least interesting part about it.

Interestingly, I've learned what a group is 15 years ago: a set with a binary operation on it and neutral and inverse elements. A monoid is missing the inverse, so an even weaker concept. While that is interesting for an algebraist to study, it doesn't say much about the monoid/group itself, it could be pretty much anything. (And that's why they're interesting to study in the first place)
What about monads, then? I guess a monad is just some monoid? Here comes the non-enlightening line about monads/endofunctors. Now why is this suddenly so much more confusing? Because it's irrelevant, you're looking for how this is magic and enables you to do special things, when in reality it is at best a side note / implementation detail, at least for the person asking. (It's probably important for the implementor, but that's a different matter.)

Now that I've mentioned algebraic groups, let's try an analogy. Someone in elementary school needs to learn arithmetic and wants to know how addition works. Your answer is "oh, the integers form an abelian group (ℤ, +, 0)". That is about as useful as telling your student about the Peano axioms. It doesn't mean those aren't interesting to study in itself, or that having "jargon" for these concepts is a bad idea, it's that it doesn't answer the question.

topspin

@Bulb said in WTF Bites:

@dkf said in WTF Bites:

@Gąska said in WTF Bites:

It's kinda like RAII - non-C++ programmers used to find it unnecessary because they don't need it, then they've got using and now they find it unnecessary because they already have it under different name.

C++ is the Apple of programming languages, “inventing” stuff “differently” that's been in other places for many years.

E.g. std::transform (instead of map like everywhere else – common theme in the standard library). But I don't think that's the case with RAII. For all I can tell RAII was invented in C++.

It's basically axiomatic that C++ names things wrong. map was already taken for dictionaries, one of the few things that actually aren't horribly named, so std::transform had to give. It's not even that bad.
And to be fair, while the STL algorithms have always been advocated for over loops, before lambdas they were just too painfully verbose to use, so better to use map for std::map.

Gąska

@topspin even with lambdas they're still painful. It's only with C++20 ranges that they start resembling something ergonomic.

Mason_Wheeler

@Gąska said in WTF Bites:

The lambda calculus in [Milner 1978] also looked like a moon language the first few dozen times.

It always does. I've never understood why lambda calculus is taken seriously when so many similar systems are categorized as jokes or estoteric programming languages.

Benjamin Hall

@topspin Yes! This! Someone understood what I was trying to get at.

The concept of a monad isn't so bad. But the explanations of it are horrific and get in the way of understanding the actual issue, which is "how do I do something useful in this language that explicitly forbids any such thing?"

Gąska

@Mason_Wheeler said in WTF Bites:

@Gąska said in WTF Bites:

The lambda calculus in [Milner 1978] also looked like a moon language the first few dozen times.

It always does. I've never understood why lambda calculus is taken seriously when so many similar systems are categorized as jokes or estoteric programming languages.

Because it's incredibly simple and has many interesting properties, the study of which brought great many good things. It's never been meant to be used for real programs. It's right there in the name: calculus.

Think of Euclid's geometry. Just 5 axioms, but boy, how much the humankind has progressed thanks to them!

Mason_Wheeler

@Gąska said in WTF Bites:

Because it's incredibly simple

Look up how subtraction is defined in the lambda calculus and then try to say that again with a straight face.

Gąska

@Mason_Wheeler simple in mathematical sense. Having few rules. Pure lambda calculus has no concept of numbers at all, so of course arithmetic is going to be tricky. In fact, the only thing that exist in pure lambda calculus are variables and single-argument functions. Even types are mere extensions - and there are multiple, mutually incompatible ones.