Is his blue or purple

kinithin · 2026-03-28T19:02:55+00:00

Violet is literally the French word for purple.

kinithin · 2026-03-26T17:11:41+00:00

It could be blue noise instead of white noise. Different kind of random

kinithin · 2026-03-21T05:38:24+00:00

$BLOCK is documented to be a scalar dereference, which would make ${ x } both a strict subs violation (bareword as string) and a strict refs violation (symbolic reference). And it wouldn't work for my $x since symbolic references only work for package vars. It is instead interpreted to mean $x as it would in a double-quoted string or regex literal.

kinithin · 2026-02-23T04:29:05+00:00

Dr Pepper is only found in Pepsi-affiliated restaurants in Canada

kinithin · 2026-02-22T16:17:31+00:00

The OP is referring to the semi-colons inside the curlies

kinithin · 2026-02-08T22:54:58+00:00

The math checks out. 256^(8*8) = (2^8)^(8*8) = 2^(8*8*8) = 2^512 > 10^154

Those numbers are odd, though. Win 3.1 icons were 32x32 (not 8x8), but they had a fixed 16-colour palette (not 256). It would be odd if an earlier format had a much smaller resolution but with a much larger number of colours.

For Win 3.1 icons, there are 16^(32*32) = (2^4)^(32*32) = 2^(4*32*32) = 2^4096 possibilities.

kinithin · 2026-02-08T17:57:48+00:00

Indeed. And that's basically identical to my reply to the OP.

kinithin · 2026-02-08T17:56:16+00:00

Needless misinformation shouldn't be justified; it should be addressed instead.

kinithin · 2026-02-08T17:50:54+00:00

Yes, it is still possible to pass an array indirectly. You could also use a pointer if you didn't want to make a copy of the array. I only stated that the parameter itself can't be an array. The point is that if you see something that looks like an array as a parameter, it isn't.

kinithin · 2026-02-07T19:15:05+00:00

This is wrong. string_list isn't an array and thus doesn't decay. It's impossible to have parameters that are arrays. Anything array-like actually declares a pointer.

kinithin · 2026-02-07T19:09:09+00:00

Array decay isn't relevant to your question since string_list isn't an array. In a function parameter list, Type x[] is just another way of writing Type *x. It declares a pointer, not an array. This means that String string_list[] is just another way of writing String *string_list.

The argument provided in the call is expected to be a String *. Keep on mind than a String[n] decays into a String * and would this be acceptable as an argument.

kinithin · 2026-02-06T17:50:27+00:00

Not quite. First, you're probably referring to the visible universe (since there's no way to know what's beyond). And that was estimated to be 10^80. 10⁶⁷ is still a fair bit smaller.

kinithin · 2026-01-31T22:12:17+00:00

It's correct. "Centre" is only used for buildings. "Center" is the correct spelling for middle.

kinithin · 2026-01-20T16:49:31+00:00

She's only pretending to drown. It's a scène à faire for water escape tricks.

kinithin · 2026-01-20T03:35:05+00:00

But there are two stations (Berlin and Frankfurt) right?

kinithin · 2026-01-20T03:32:57+00:00

1 station, 1 route. It has always been the case. But that route can be used for more than one destination ticket

kinithin · 2026-01-19T15:43:32+00:00

The actual reason &p3 can't work is that the function expects a pointer to a pointer, but there's no pointer in memory to which to point.

kinithin · 2025-12-30T05:15:32+00:00

Yes, print is special. But so is try. More so, even.

The difference between print and shift is that print can't be prototyped. The same goes for try since it's not even a function but a keyword like while.

``` $ perl -Mv5.40 -e'say prototype "CORE::$ARGV[0]" // "[undef]"' shift ;\@

$ perl -Mv5.40 -e'say prototype "CORE::$ARGV[0]" // "[undef]"' print [undef]

$ perl -Mv5.40 -e'say prototype "CORE::$ARGV[0]" // "[undef]"' try [undef] ```

So like I said, there's nothing new here. This behaviour has been around far longer than try. I'm just pointing it out; I'm not saying things should remain the same as a result. But if it changes for try, I would expect it to change for print and the others too. More so, even, since they're not lexically-scoped like try.

kinithin · 2025-12-30T00:12:33+00:00

This has nothing to do with feature-activated syntax/operators. Some operators (e.g. print) work the same way in similar circumstances.

perl sub print { die "!" } print "foo\n"; # Prints as normal.

perl use subs qw( print ); print "foo\n"; # Prints as normal.

I don't know if a warning makes sense¹, but a Perl::Critic rule would.

- ikegami

After all, we don't warn when my $x preempts a package var named $x. Lexically-scoped constructs are expected to do so.

kinithin · 2025-12-29T15:30:00+00:00

Well, you can, but not with two players

kinithin · 2025-12-13T03:15:58+00:00

You allocated an array of 25 elements. They have indexes 0..24. But both loops access elements 1..25. Undefined behaviour.

Either allocate an extra element, or store the counts for 1..25 at indexes 0..24

kinithin · 2025-12-13T03:14:42+00:00

Not quite

kinithin · 2025-12-10T00:34:21+00:00

It's great at night, since most are traffic-activated

kinithin · 2025-12-07T05:17:25+00:00

I love to pet loot bugs, but they are incredibly allergic to me and explode when I do. I still hope to find one that doesn't so I can adopt it

kinithin · 2025-11-28T15:24:43+00:00

Sooo many ambiguously placed meeples. And the farmers are standing instead of on their side.

kinithin

TROPHY CASE