I keep my cats indoor most of the time, and let them out for an hour or two a day under supervision. They're just as happy as outdoor cats, live longer, and won't commit floof murder. Win win.

The whole point of enslaving an animal having pets is to have a cute thing to love, right?

I think cats are cjuter but I wouldn't own either pet. If I were to have a pet I'd get something nice like a rat or a fish.

A rat?

I'd get a falcon with a machine gun mounted on it

Rats are small and cute, they eat vegetables and stuff.

@WheatWizard My house had (has?) one and it ate a good bit of chocolate, I'd be delighted to give it to you :P

@RedwolfPrograms ಠ_ಠ

fishies are so huggable

I feel sorry for fish trapped in tiny glass bowls

Be like Tycho Brahe and get a moose

Although I have no idea if they're just as happy as wild fish or not

But don't get it too drunk

Or it'll fall down the stairs

I had a mouse and it died ∎

why tf is termux related to hacking :/

i would not support the pet trade tbh

@Wezl-acautionarytale was it your pet?

No it was his prisoner

yes

:(

guess what weasels eat for food

€_£

btw how is a weasel chatting?

@PyGamer0 this is the reason I am Wezl - a cautionary tale :P

@RedwolfPrograms Oh, so a pet

My cats aren't prisoners :p

@PyGamer0 probably the same way you are

True, they're just there for the food :P

Or they've got Stockholm syndrome

@RedwolfPrograms you are their prisoners:P

One escaped a few times but she came back the first time, and slapped some poor guy's dog another time so he called us to come get her

Scully's adorable but she is not a fan of dogs

(She never agro's on humans dw)

Can weasels do math?

@Wezl-acautionarytale ^?

they can do some math

Some I dislike about Python: a, b = b, a looks like (a), (b := b), (a) to me

but that's not very specific

@RedwolfPrograms that makes no sense

to me

maybe a,b = b,a looks better?

@RedwolfPrograms this is badly formatted. good style is to write a, b = b, a :P

@RedwolfPrograms Does val (a, b) = (b, a) look better to you?

I like JS's [a, b] = [b, a] a lot more

@user Yes, mostly

Even without the val it'd look better

@RedwolfPrograms I think this is just that you're used to languages where that is what it means. I'm used to Python and Go, so it's perfectly clear to me

Yeah, almost certainly.

i am used to errr... only python :/

let (a,b)=(b,a) in a is an infinite loop in Haskell.

this is what it does in my programming language: apply function a, then b then = then b, then a :)

Wait what?

= is such a terrible symbol for assignment.

why should "a" be an identifier and not "=" or "b,"!?

Assignment is directional. = looks symmetric.

@user Because of lazy evaluation, when a (the one on the RHS of in) is evaluated, it sees "ah, a=b, let me evaluate b", then sees "ah, b is a, let me evaluate a", etc.

In some languages assignment is not directional.

@Wezl-acautionarytale Because of context and expectations

Which is why any aspect of a programming language's syntax should be any way :p

@Adám While the math symbol := might have been better, I think = isn't too bad

@Adám It's the worst symbol, apart from all the other options

@pxeger I was asking Wezl

oh

@Adám of course, as always, prolog does everything in a more beautiful but inconvenient way.

The horny operator

:= is quite ugly to me, I like : on its own though

@pxeger I don't follow.

@WheatWizard I'd argue that if it isn't, it's unification rather than assignment

: on its own looks like a type ascription or dictionary to me

@RedwolfPrograms =: would make more sense.

But yeah, I'd like : too.

@Adám We're stuck with it now; so many languages use it that using anything else is just too unfamiliar, so it's realistically the best option

I really like how a+: b looks, too

@Adám how does =: look? (J)

I think : should be reserved for "is of type".

If every existing programmer on earth got hit by a bus, we could start over with := or whatever (<- is my favourite option btw)

@Adám Eh, the colon on the right makes me think that the thing on the right is the subject and it equals the thing on the left, essentially the opposite

@pxeger I don't agree.

@pxeger Let's start with 1-indexing too while we're at it

Since : is very commonly used in math for type declarations.

@user No, 1-indexing is bad

Why?

@user I see "=:" as "is as follows"

@WheatWizard Who needs types anyway‽

@user It'd make no sense in lower level languages, so people would change it for those, and we'd have two standards

non-morons

@pxeger I don't think this argument is that important. there are good reasons to break from conventions, and most languages are not marketed towards all programmers in general

@pxeger <- is poor man's ← but is dangerous in situations like a<-5

@Adám I'm used to ≔ so it looks like the opposite of that

@pxeger Arguably, people who need help remembering what's what type are more of morons

I don't really like <-, I feel like it points the wrong way. The variable refers to the value not the other way around.

-> makes more sense imo.

^

I like -> for functions though

x -> 3 says "x is a variable that points to 3".

I guess in Haskell etc. that makes more sense, but in imperative languages <- makes sense to mean "write to"

@WheatWizard Maybe depends on value and reference semantics?

In my language nib, assignment is value expression .: variable >:)

It should be <- for copy value and -> for make reference /j

what about <- this here is the variable and this is what it contains -> :P

x -> 3 feels like "x maps to 3" to me because that's how you declare maps/dictionaries in Scala

@WheatWizard I actually kinda like that

@user Variables are kind of like maps in a way ...

what about <==?

@RedwolfPrograms I don't think it'd make no sense for them, they could certainly use 1-indexing too

@PyGamer0 too long to type

Fat backwards arrow (Unicode) wouldn't be bad, honestly

of course it doesn't have to be infix either. in scheme it's (define var val), in postscript it's val var def, and in forth it's : fn body ; (prefix, postfix, outfix?)

@user But it makes very little sense for "the item at pointer" to be "pointer[1]" and "the item at pointer + 1" to be "pointer[2]"

@pxeger StackExchange is the perfect piece of software on which to operate a code golf community.

honestly i like =: or :=

@RedwolfPrograms Pointer arithmetic is borked anyway :P

And worse, "the item at pointer - 1" is "pointer[0]"

I also really like zero indexing for other reasons

@pxeger This is nothing, the bot flags the sandbox every week for having too many answers.

@RedwolfPrograms Which are?

@RedwolfPrograms Okay yeah that'd be confusing

Well, I guess familiarity is a big part

@RedwolfPrograms for example Boolean arrays indexing into stuff

I wish JS would do that

1 based, we can change binary to use 1 and 2 then instead of 0 and 1

But we high level programmers are already sacrificing intuitiveness. Why can't the first item in an array be arr[1]? It'd fit in with math too

["a", "b"][false] is undefined, because it's ["a", "b"]["false"]

@user it makes much more sense in the context of modular arithmetic. The fact that in Jelly, i0 gets the last element is pretty unintuitive

Boolean indexing is like an anti-feature. I know it's useful in golf, but bools are not integers and shouldn't be treated like them.

I actually get confused quite often IRL when people use 1-indexing

@WheatWizard Idk, I kind of think it's a cool alternative to ternary in languages that have ugly syntax for it

@pxeger True

@WheatWizard Unless Bools are integers, like in APLs.

But they shouldn't be

Yeah.

Not having distinct types for booleans is weird

Why (not)?

more type distinctions is in general better because it prevents footguns

Because there is no inherent relation between truth and the number 1 and falsehood and he number 0.

@RedwolfPrograms lesson: Always ask people what have they set ⎕IO to.

I like Bool being treated as an int that can only ever be 0 or 1

They are different concepts and should not be interchanged.

@RedwolfPrograms Acts like a number in any situation, but x * bool is safer to do

@pxeger although the fact that x[-1] is the first(-last) and x[1] is the second is a bit confusing. I wish you could have x[-0]

@RedwolfPrograms If you have refinement types or whatever, then that's fine, but in a dynamically typed language, it's kinda weird

@pxeger You could…

@pxeger Maybe we should use x[~0]

I'm pretty sure all users of APL-like languages are very happy that Bools are just regular 0s and 1s.

@pxeger Nobody says you can't :p

I mean, make it convention

@WheatWizard Why not? If 1 is truthy and 0 is falsy...

Really you should just have different semantics for "index from the front of a list" and "index from the back of a list".

@user A much nicer way of representing booleans is with an enum like enum Bool { case True, False }

The Iverson bracket brings it to general mathematics too, and Knuth likes that.

@WheatWizard Like two different functions to call?

@RedwolfPrograms which is also kind of bad. Ruby's truthiness is better, because everything is truthy except nil (and false itself). That means 0, [], etc. are still all truthy

Heh, I remember with horror BASIC's using -1 for true.

I like that a lot

@Adám because it's all 1s when in two's complement, right?

-1 for true makes a lot of sense

It's confusing when you go to Bash and 0 is truthy and everything else is false

@pxeger I suppose.

It's just really nice to have booleans be separate from numbers so there aren't different standards

@RedwolfPrograms Why? What is the relation? I can go about declaring that values are equivalent, but it's arbitrary and not a good model of anything. You can't have true apples, you can't be true meters away from something. It's fine to convert between these types explicitly when needed but implicit conversions like these just push error cases down the road making them harder to identify.

@user Agreed.

@user try Zsh, where it's sometimes that and somtimes the inverse

When does the inverse happen?

In arithmetic expressions, it uses C-style booleans

@WheatWizard When would that ever cause an error?

How do you get something that holds a bool mixed up with a number?

The same way you get anything mixed up?

@pxeger Wait, how are booleans involved in arithmetic expressions?

Like sometimes you pass the wrong value to something. And it would be ideal if you learn about that as soon as possible.

@RedwolfPrograms if you try and use 2 like a boolean, you get true which then becomes 1 which is decidedly not the same as 2

@user with the ! && || operators

@WheatWizard But you get protection from an extremely rare and easily noticeable and fixable issue, at the cost of having to write more code every time

Oh, I see

Not really arithmetic, but that's what zsh calls them

The only uses for bools as ints are "clever" hacks, which you plain should not be doing.

@RedwolfPrograms Extremely rare and easily noticeable?

And you don't have to write that much more code

@pxeger That's why 2 shouldn't be allowed where a Boolean is expected.

Yep, I've never had that happen, and if I did, I'd notice I'm not getting the right result from the addition/multiplication/whatever in like...60s

All you need for the conversion would be 0!=x or something like that, which is 3 characters

@RedwolfPrograms This makes me feel like you have never worked with actual software projects

These types of errors are neither rare nor easily noticible.

^

Why would an "actual software project" be any different?

If anything the unit tests and stuff should catch it, making it even less necessary

I assume it'd be bigger, making it harder to find errors

Because they have big code bases and involve a lot of people touching each other's code.

Well you should still be following other best practices, like breaking things up into small functions

@RedwolfPrograms in an ideal world, you'd have no unit tests and the compiler would magically know if your code was wrong

If you have a 2000 sloc function that's doing things that can mess up halfway through, that's the issue. Not anything else.

static typing is one step towards that

strong boolean typing is another

In any case, why leave it to be caught down the line? Static + strong typing can help you catch it immediately with very little extra code

"Caught down the line"? Do y'all just write code, never run it, and assume it works?

I'd rather not have anything go to unit tests. There is no good reason to interchange these types values implicitly so the compiler should prevent you from doing so, because either you are doing something you shouldn't be, or you have made a mistake.

@RedwolfPrograms yes, often

@RedwolfPrograms 200 10 sloc functions would be entirely normal, and they'd still be hard to diagnose

@user No? Not if they're pure.

@RedwolfPrograms No, but it's better to find an error practically as soon as you type it rather than run it, track it down, and then go back to fix it

If you write one of those 10 sloc functions and it's not giving you the right output, then it'll take 10s to find the line that's the issue

Not necessarily

Maybe not the first time

It might be the combination of two functions causing the issue

Not if they're pure

It should never matter if they're pure

wdym?

@RedwolfPrograms On a big project running code pretty much requires a deployment to staging. I'd really rather not have to go back and fix a tiny error then redeploy, if I can catch it in the compile I absolutely want to.

@user How could f(g(x)) cause an issue when f(x) and g(x) both work fine?

But you don't know they both work fine without comprehensive unit tests

@WheatWizard You don't quickly test the functions you write in a console or something?

@user By trying some exceptional inputs by hand?

Y'all don't do this by habit?

@RedwolfPrograms You're assuming these functions are purely mathematical and don't also involve a GUI or whatever

Or even doing it in your head

A human can only catch so much

@user Then they're not pure

Ok?

You're not always going to be able to write pure code

But you can in most cases

@RedwolfPrograms My functions often require database connections, authentication services etc. The pure stuff I test easily with unit tests, but a very small amount of logic ends up being pure. And the pure stuff is just less likely to go wrong in the first place.

Or you might have a model that takes 10 minutes to train, and a function that's applied to it after those 10 minutes. Why spend 10 minutes to run tests every time?

Exactly!

Just run the one at the end with some test inputs before you run the whole thing

@RedwolfPrograms even if they are pure, if they connect with lots of other bits of code (even if they're also pure) which do other things, they're not as easy to test on their own

Why make up test inputs when you can literally just have a static type system to help out?

personally wrt typing, I like dynamic/lazy typing and I like dependent typing (no experience with it though), but I'd rather not be caught in the middle with static typing

@pxeger And mocking can only be done to a limited extent

Because I don't want to have to bother with static types 24/7 instead of an error once a day that I can fix in half a minute

I think you think static typing is much more of a pain than it really is

Static typing is not a bother, it really doesn't require any effort.

I think if your only experience with static typing is in Java or C++ you can easily think it is a lot of effort

Getting errors and mistakes asap is really critical.

@pxeger Well are there any commonly used languages that do it better?

AbstractFactoryManager f = new AbstractFactoryManager(x.getAbstractFactoryManager()))

Even a dynamically typed language that's strongly typed will help you fail and catch errors quicker

I just got here but I think I agree with both sides of this debate X^D

@RedwolfPrograms Kotlin, Scala, Haskell, the list goes on and on

@RedwolfPrograms Go, Rust, Kotlin, Dart, Haskell

TypeScript

@pxeger Even Java isn't that bad, honestly

Yeah it is

I've been using it for a club and it's a bit verbose, but still expressive enough to do most things

Java is really pretty awful.

I miss Scala's more complex type system but Java's is still good enough

expressivity is orthogonal to verbosity

@user wait how can you hit things with a language?

Kotlin is pretty much jusst strictly better than Java.

@pxeger It's not verbose enough to bar you from doing what you need to do

@pxeger (lthough both are related to usability in general)

@WheatWizard Kotlin is fun!

@WheatWizard Gonna have to disagree there. Flowo typing is sooo good

Flowo typing?

@user that sounds like you agree (assuming you meant "flow")?

???

Kotlin is the one with flow typing, and WW said Kotlin is better, and you said you like flow typing

Oh I interpret WW as saying "Kotlin is better than Java, but only just"

I meant to say "Kotlin is better than Java by a lot"

Isn't english awesome

Yeah the real bad language here is English

english has flow typing

I was sayin that Kotlin is plainly better than Java in every way.

@Wezl-acautionarytale true

English doesn't have typing (well, kinda?)

Fun fact: "You're not sh*t" can be either an insult or a compliment

English is great

@user it has flow valueing, then

@WheatWizard lol I interpreted it almost the opposite way

@RedwolfPrograms It unironically is. But it's also very weird, inconsistent, and hard to learn.

Anyone working on this? codegolf.stackexchange.com/a/240669/108218

Nah, using english is hard

@user "strictly" meaning "even if there are no parts which are a huge amount better, there are definitely no parts which are worse"

@RedwolfPrograms Not just learning it

Better languages could certainly be made (and have been)

@pxeger Oh, that makes sense

I'd describe the way I communicate (and most likely other people) as "markov chain with lots of training and an underlying goal", and that does not work well with English

who here is bilingual?

I got 32 emails in the last 24 hours, exactly half of which was college spam >:|

@RedwolfPrograms "you ain't shit", maybe, because that's basically an idiom for "you're bad" (as well as literally meaning "you're not bad"); "you're not shit" doesn't have the same idiomaticity I think

@RedwolfPrograms Hm, I guess YMMV. I don't have much trouble using English. (Sometimes people have trouble understanding what I say, but I'm sure that's their fault. :P)

We could kinda deal with that with variables (and I think DLosc mentioned sometime before that ASL kinda has that)

@user sometimes I write sentences with {} for grouping like that, but when I do that it generally makes me realise I'm just not writing very well

@Wezl-acautionarytale does bilingual have to mean 2 native? Or can I be native and fluent?

@RedwolfPrograms Our testing setup at my work mails me every time it deletes a test image. So I get like over 100 emails a day from that alone.

@Wezl-acautionarytale My Marathi and Hindi skills get worse every day but I currently speak them passably

@pxeger i don't care. fluent is enough for me

@WheatWizard I get two emails a day saying merely "your email system is working"

@pxeger True, but some ambiguity is often unavoidable

so how does english compare?

(because I'm paranoid that my email system will break)

Maybe that's a sign you should use a more commonly used email system :p

@Wezl-acautionarytale I like that English doesn't have different conjugations for verbs depending on gender (and often for number) because it's really annoying

@RedwolfPrograms Doesn't pxeger use their own domain or sth?

@RedwolfPrograms but it hasn't actually ever broken, so I might take the training wheels off

@user Hebrew has entered the chat

@user pxeger.com/…

@user I just have my domain registrar forward them to my gmail

the problem is that I don't what my domain registrar (or really any company) reading my email

@DLosc Ooh, does it also not have different conjugations depending on number? Because that's a feature I would love to see in English

gendered pronouns are also irritating. In general gender-specific words are not very helpful within a language :\

@pxeger but I'll accept AWS reading it because I'm definitely the customer not the product there

I am, you are, one is, we are, they are is so annoying

Yep, because there's definitely someone over at Google who sits there and snoops in people's spam all day

@user No, the opposite. Verbs are inflected for both number and gender.

@user all of these grammar features help improve redundancy of information, so it's easier to deal with mis-spech or mis-hearing or typos or mis-reading

@user You're looking for something like Mandarin, I think

@Wezl-acautionarytale I would really like it if we had 1st person singular, 2nd person singular, 2nd person plural, 1st person plural including the person you're speaking to, 1st person plural excluding the person you're speaking to, 3rd person singular (gender neutral), and 3rd person plural (gender neutral)

@DLosc :(

Time to learn Mandarin if I can get past the script

@user There should be optional gendered pronouns I think

It's nice for reducing ambiguity

@RedwolfPrograms I mean, sending a copy of all email to an advertising network which then automatically (not using "a person who sites there all day", obviously) scans it for keywords

@pxeger That's true, but we could deal with that by making the word for "I" ten syllables :P

"He broke up with her" is a lot easier to understand than "The person that is a guy broke up with the other person"

@RedwolfPrograms Reducing ambiguity could be done with custom pronouns made on the spot or just the nouns themselves

inclusive/exclusive we is definitely a feature that should go in 2.0

@RedwolfPrograms In this case, you could just say "They broke up with their SO" or "Bob broke up with Alice" (if those are their names), which is not too cumbersome imo

@user Ah, Quechua is the language for you.

Thanks, but Marathi has that feature already :P

Oh, cool

@user by having two gendered pronouns (plus two other 3rd-person ones), it's less often that we have to switch to using actual nouns. If we had only one 3rd-person pronoun, every time we had more than two nouns in a sentence we'd have to keep clarifying whom we were talking about

That hoenstly doesn't sound too bad imo

Yeah it is

People abuse pronouns too much, I often hear something like "He told him to get something from him", which is just confusing

Pronouns in practice are overused imo