These types of donations to open source initiatives should be publicized and encouraged to have brands see it as a worthy way of gaining supporters.
I got close 20 years ago, but "things".
1. Sigils, and relatedly, contexts. In my opinion, `my $length = @list;` is a horrid way to spell `length = len(list)`. It feels too much like typecasting magic.
2. Having to opt in to pass by reference caused so much pain. You're happily passing a hash around, but then you want to do something to it, so now you have to change the type signature of the function, then everything that calls it, etc. etc.
Contrast with Python, where everything is pass-by-object-reference and sigils aren't needed because contexts in the Perl sense don't exist. This worked on my first try:
>>> a = ["foo", 123, {"bar": [(1,2,3), {"qux": "quux"}]}]
>>> a[2]["bar"][1]["spam"] = "eggs"
>>> import json
>>> json.dumps(a)
Sure you can write amazingly obscure foot-guns in Perl but that's also true of any other language. But honestly I'd rather a few lines of obscure Perl code WITH a comment block explaining why, than a dozen classes with bits and pieces of business logic spread all over the place.
I've done a few small Perl script in the past month, mostly just to try out things and learn a bit more. I'm surprised how robust the code turns out, without me trying. The Perl syntax is a little all over the place at times, but it's incredibly powerful.
Overall it's probably not a language I'd use at work, unless I have to, but for hobby project I would pick Perl again. It has put some of the fun and humanity back in programming.
There's also this polished three-hour introductory lecture: https://www.youtube.com/watch?v=eb-j1rxs7sc
Combine that with reading up on details in the reference and you're in for a decent start. https://docs.raku.org/reference
Some of the warts are gone (like a list element needs to have a scalar context, the stuff that scares away beginners).
It is a _large_ language with paradigms and constructs that are from everywhere (ML, Haskell, Lisp, C, Perl you name it).
Powerful operators. Actually too powerful. Easy to write elegant line-noise kind of code.
Easy to use built in concurrency. (There isn't much that is not built in :-) )
Nice language for Sys/Ops scripting if you find Bash too dangerous and Python too tedious.
That said, how does DuckDuckGo get that money?
Its only fault is, it has too much stuff in it.
See the comment from Olaf Alders here:
Look, I don't hate Perl. It was my first real language beyond basic that I used for a long long time. But Perl's popularity peaked in the late 90s? Early 2000s? The failed Perl 6 adventure was about the time that people started fleeing elsewhere, like PHP.
Maybe Perl 6 was not even really needed and Perl is perfect ;)
They'll rarely advertise it in a job listing of course. They're looking for people with Java/C#/C++/Python experience, and there's certainly plenty of that, but also thousands of little Perl scripts doing ETL workflows.
Weird donation if you ask me. There are many many many more interesting languages that I would rather see succeed. Koka, Hylo, Vale, Whiley, Lobster, etc.
The main problem in my eyes is not enough volunteers (although they are doing a superhuman effort) to get it into the production level it needs to get more widespread adoption. The other problem is that Python already has a huge amount of libraries and is considered to be "good enough" feature wise, so it's hard to attract interest.
I do enjoy reading Raku code and think it is super neat as this do it all post-modern language. Inertia is hard to overcome though.
my $a = ["foo", 123, {"bar" => [[1,2,3], {"qux" => "quux"}]}];
$a->[2]{"bar"}[1]{"spam"} = "eggs";
use JSON;
print(encode_json($a))
use JSON;
my $a = [];
$a->[2]{"bar"}[1]{"spam"} = "eggs";
print(encode_json($a))
To do this in Python is truly grim:
import json
from collections import defaultdict
# recursive defaultdict using lambda
datastructure = lambda: defaultdict(datastructure)
a = [None] * 3
a[2] = datastructure()
a[2]["bar"][1]["spam"] = "eggs"
print(json.dumps(a))
import json
from collections import defaultdict
def datastructure():
return defaultdict(datastructure)
a = []
# expand list to at least length 3
while len(a) < 3:
a.append(None)
a[2] = datastructure()
a[2]["bar"][1]["spam"] = "eggs"
print(json.dumps(a))
$a->[2]{"bar"}
$a->[2]->{"bar"}
So when you see
$a->[2]{"bar"}
$a->[2]->{"bar"}
If one wants the function to mutate them, one has to explicitly mark them as `$x is rw` in the function signature; this then requires one to always pass a mutable container for $x. (A bit more detail: https://andrewshitov.com/2019/10/15/110-is-rw-vs-is-raw-in-r... )