Under the "Countries Visited" section it says "been lucky to run on all seven continents, including antarctica!", but it doesn't look like they've been to Australia.

Oh lol you’re right! Perhaps they ran in Australia before they started this ten-year streak? In that case it could still be true, but not show in the data

Edit: also, they pulled the data from strava. It’s possible they forgot to record their Australian run(s) in strava for some reason

wonder if I know this person, as I've also run on all seven continents, as well as the north pole (which is not a continent).

there aren't that many of us (that have run on antarctica, vs king george island).

I haven’t been to Australia, but I’ve run in Hawaii, which is part of Oceania (broader than just Australia).

Come to Australia! It's a great place to run!

Or NZ at the least. Hawaii isn't on the content. You've got only one continent to go before you can check that box.

I have 100% confidence you'll do it!

I ran every day for a year, and kinda wished I had kept going (though I only managed 3 continents in that year).

Notably not on the tectonic plate Australia is on (which is mostly although not entirely just Australia in terms of land), though, if someone is going by that definition.

Eh, that doesn't really count. Sounds like a good excuse for a trip ;)

there's also 8 continents now apparently.

https://en.wikipedia.org/wiki/Zealandia

Answering for myself, I started looking into APL, but at the time, learning the keymaps for the symbols seemed difficult, so I started learning array lang techniques with J, and ended up liking it.

Some of the knowledge you acquire from one array lang can translate to the others, but the semantics are not 1:1 (ie. J is not just ASCII APL).

As it currently stands, I dabble in almost all the array langs, but of the ones I use, I think best in J. It's got a lot of convenience in it's large set of primitives, and there's no "indirection" between the character you want, and the one you type. Still, it's not without it's shortcomings.

I think I would probably still recommend BQN to most people looking to get into array programming, as it removes some warts in APL/J.

You lose some convenience functions (base conversion, fixed-point, etc) but you get a language which is more uniform and intuitive. And FWIW, I had the keymaps learned within the first day I started to play with it.

It's still a learning curve regardless of which lang you learn, but it will change how you think.

I wa recently playing with this pattern in J, where it can be expressed like so

  ~:"1/~&.#:i.2^8

See it here: https://jsoftware.github.io/j-playground/bin/html2/#base64=b...

First thing I thought of

https://www.youtube.com/watch?v=M4g4WBo-5fc

I was also a big fan of the Panorama feature that used to be built in.

These days I'm using the Panorama Tab Groups [1] extension, which provide a practically identical experience the the old built in Panorama.

[1] https://addons.mozilla.org/en-GB/firefox/addon/panorama-tab-...

FWIW, I solved this in J as follows

F =: >@{.@(\: #@>)@(#~ (2 >: +/@e.&'aeoiu')@>)

which I think maybe composes a little better

This doesn't include the splitting. I would imagine I would be feeding this function from a boxed list from a word list, like: F 'b' fread 'dict.txt'

Also `;:` is unreliable on hyphenated words, etc. Better to use `cut`.

Another Unicode article that mentions Swift, but not Raku :(

Raku's Str type has a `.chars` method that counts graphemes. It has a separate `.codes` method to count codepoints. It also can do O(1) string indexing at the grapheme level.

That Zalgo "word" example is counted as 4 chars, and the different comparisons of "Å" are all True in Raku.

You can argue about the merits of it's approach (indeed several commenters here disagree that graphemes are the "one true way" to count characters), but it feels lacking to not at least _mention_ Raku when talking about how different programming languages handle Unicode.

I went looking for a web browser!

  >  "Produce" is a term I've never seen used this way before, and I assume it is unique to Raku.

More commonly referred to in the functional languages as a `scan`, but yes, it seems that `produce` might be unique to Raku. I've not seen `accumulate` outside of Python, but there's a lot of langs so who knows.

code_report (Conor Hoekstra) has discussed the difference names of `scan` on a couple occasions, eg: https://twitter.com/code_report/status/1246494250537291776

Connor has declared a fondness of APL's where fold and scan show a clear visual relation: `/` & `\`. I suspect Raku was shooting for something similar with it's choices:

[f] list # or list.reduce(f)

[\f] list # or list.produce(f)

I've just found the key exchanges that arrived at "produce" by using the IRC log search[1] and then, er, scanning backwards to where the exchange began[2]:

> TimToady: is it okay to rename the 'reduce' builtin to 'fold' and add one for 'scan'? My understanding is that 'reduce' is the general term for them both.

[1] https://irclogs.raku.org/search.html?query=produce+reduce&ty...

[2] https://irclogs.raku.org/perl6/2006-05-15.html#17:10-0001

I recall Larry saying the key visual aspect is the `\` (I don't recall him mentioning the `/`) because `[\` visually echoes the typical shape of results:

    .say for [\**] 2,3,4

    4                          #           4
    81                         #      3 ** 4
    2417851639229258349412352  # 2 ** 3 ** 4

I know cygx already replied, but to be clear, function signatures have been available in Perl since 2015. They were added (as experimental) in 5.20, and are now enabled by default with `use v5.36` or later.

All new features must now go through an experimental phase after the smartmatch debacle. Signatures stayed in experimental status a little longer than most new features due to an unfortunate change with respect the order of function signatures and function prototypes. Provided you weren't using prototypes (which you almost never need) then they've been largely stable since 2015.

Most distro's under current support ship with at least Perl 5.24, so you can use them almost anywhere.