zlacker

>>speckx+(OP)
It's been discussed before, but Python just seemed more straightforward to a lot of people. It had a built-in object oriented model as well when that was the rage instead of the weak default one and dozen modules on CPAN to do object oriented programming. There was generally one way to do something and that was easier to learn than TIMTOWTDI.

>>7thacc+bH
One of Python’s killer features is how easy it is to find a Python library wrapping some native code library written in C or Fortran. Those used to be notoriously difficult to write for Perl.

>>cestit+iL
I was writing a comment asking if it was really easier. Then I took a look at Cython. Yes, this looks easier than Perl's XS, which I have some experience with! There are ways to do something similar in Perl these days, notably https://metacpan.org/pod/FFI::Platypus. But these are relatively new (starting in the 2010s) compared to the history of Perl, and Cython goes back to the early 2000s.

>>autarc+xN
Somewhere in the continuum from SWIG through XS and on to Platypus there are also the Inline modules these days. They allow one to put inline sections of other languages into Perl code the way many language tools used to allow one to inline assembly into C or Pascal code.

There are some of these modules for other languages than those listed here, a lot of them as high level as Perl (including Raku and even another Perl system for some reason).

https://metacpan.org/dist/Inline-C/view/lib/Inline/C.pod

https://metacpan.org/dist/Inline-ASM/view/ASM.pod

https://metacpan.org/dist/Inline-CPP/view/lib/Inline/CPP.pod

https://metacpan.org/dist/Inline-CPR/view/CPR.pod

https://metacpan.org/pod/Inline::Lua

https://metacpan.org/dist/Inline-Java/view/lib/Inline/Java.p...

https://metacpan.org/pod/Inline::Guile

https://metacpan.org/dist/Inline-SLang/view/SLang.pod

There are even tools to convert from Inline to XS for C and C++.

https://metacpan.org/dist/InlineX-CPP2XS/view/CPP2XS-Cookboo...

https://metacpan.org/pod/InlineX::XS

>>cestit+UP
True. For whatever reason, these never displaced XS. For wrapping C libraries in particular, it's not clear to me how much Inline::C helps with this. You're still stuck using a lot of Perl C API calls, AFAICT, which I think is the biggest challenge of using XS (I still have nightmares from trying to figure out where and when to add `sv2mortal` in my XS code).

>>autarc+zQ
I haven’t done nearly as much of this as you.

One or two calls into a library with a simple C interface isn’t that bad with Inline. You just use Inline to handle the Perl to C to Perl part, and actually do the interfacing in the inline C. It’s a lot more mess if you’re doing complex things and bringing complex data structures back to Perl, or having Perl make a lot of intermediate decisions and doing a lot of round trips. So if you use Perl to get the data ready to pass in, pass it in, do all the work in C that you need the library for, then pass the results back to Perl once it’s not terrible.

I’ve tried not to get into XS, so I couldn’t really compare.

Using Inline::C with your own C code in places where Perl is too much overhead is certainly easier than wrapping a complex existing library with a lot of interactions across the boundary.

FFI::Platypus or something like it really is the way of the future though for existing C calling convention libraries in other languages.