What I Learned from porting my projects to FreeBSD
github.com
github.com
You should also forbid your tools to access these URLs directly (--nonet), as it would be incredicly slow and you rather want your build to fail in this case instead of downloading on-demand.
xsltproc --nonet http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl foobar.xml
If you prefer to work with files instead of passing long URLs on command line, use a small wrapper file to import the real stylesheet and pass that on command line instead of using the URL. The advantage is that you can also put additional <xsl:param> tags to customize the output right into this file. <?xml version='1.0' ?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:import href="http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl"/>
<!-- put additional xsl:param here -->
</xsl:stylesheet>This is less fragile and requires less dependence on replacing make in the $PATH.
All maintained and ready to go.
When installing Solaris, Sinix, AIX etc, you'd typically install the GNU tools immediately.
I understand the FreeBSD folks' frustration, though.
At least the OpenBSD developers hated the Linuxisms so much that they made a song "Aquarela do Linux!" to name and shame this:
To be fair: Nothing in GNUiverse teaches you interoperability; I too learned it the hard way when switching from Linux to BSD.
My personal pet peeve with POSIX Make is that you can't export an environment variable for one target only without calling $(MAKE)[1].
I use GNU-specific Makefile features all the time - here's a list of some of the cool features:
- Built-in functions (see https://www.gnu.org/software/make/manual/html_node/Functions.html for a list)
- User-supplied functions
- Much better pattern substitution
- Ways to tell Make that some files can be skipped in certain cases (.INTERMEDIATE and .SECONDARY modifiers)
- Ways to adjust Make's behavior (SECONDEXPANSION, DELETE_ON_ERROR, ONESHELL)
As a software packager, I'd advocate for autotools or CMake over a raw Makefile every time (assuming your project is a library or some binaries).But with that said, I use GNU Make all the time for "glue automation" - like if I had a folder full of files that needed some processing, I'd probably write a Makefile instead of a shell script. I also use top-level Makefiles on projects that have their own build systems, so that I don't need to remember how they work every time. People use shell scripts for that stuff too, but Make is better IMO.
It annoys me quite a bit when someone decides not to use autotools or meson, or other standard build tools. I have a build system set up to build static packages for several architectures, and most of my packages are described like this:
name=some
ver=123
url=https://where-to-get/some-$ver.tar.gz
build() {
autotools_build --some-option
}
And it does the right thing for all packages that use autotools.If you roll out your own Makefile, I have to figure out how to build the targets, how to install them, whether you use DESTDIR, whether you respect cross-compile options, how to build static library, how to configure your package... and code all this by hand to build() function.
The same goes for my custom Arch Linux packages.
Make the packagers job easy and just don't roll your own if you want your package to be distributed widely.
That all said, it’s still clearly managed to be important, and is indeed something the authors can be proud of, though I have personally come to find joy and good success in plain Makefiles.
For personal projects I use either meson, or if they are sufficienlty complex (targetting multiple architectures in a single project and other tricky things) and the environment is known/fixed, I genereate build.ninja file from a PHP based configure script and it's unbeatable as to the flexibility, predictability and build speeds.
The best thing is that I can change anything and I can be sure that the incremental build will be the quickest and the result predictable. No more need for "make clean all" after changing some flags/variables in a Makefile.
It's the benefit meson/ninja combo will give you too, but meson is replaced by an actual well known programming language like PHP in my case.
For known environment builds, it's really nice. Much easier than fishing around the web for random recipies on how to do stuff in m4/meson/autoconf/automake/whatever custom language someone invented.
I really love the intentional simplicity of ninja build.
https://builds.sr.ht/~sircmpwn/job/9348
I'm also working on OpenBSD and NetBSD, other kernels, and non-x86 architectures. If anyone is interested in using this to make their software more portable, please let me know! Email in my profile.
* https://github.com/travis-ci/travis-ci/issues/1818 * https://github.com/travis-ci/travis-ci/issues/6671 * https://github.com/travis-ci/travis-ci/issues/5473
Do you plan on providing Github integration? Providing other OSes and platforms (e.g. ARM64, ppc64el) would be really useful for testing low-level projects like .NET Core runtime, node.js / libuv, etc., and integrating with Github would make it really easy for people to start adding this to their existing projects.
If you do end up providing Github integration, consider listing a paid option for your service in the Github marketplace: https://github.com/marketplace/category/continuous-integrati...
https://github.com/swaywm/wlroots/pull/1341
(click "show all checks")
I may add it to the marketplace once it's open for public registration and more polished.
We currently test Rust under qemu-system for FreeBSD and have no real good solution for OpenBSD and DragonflyBSD. It would be very interesting for us to do "native" testing.
If you'd like an invite, feel free to reach out - sir@cmpwn.com
OPNsense was created to fix that. Now it is better than pfSense.
On both issues, PFSense left me with a non-working router, which is unacceptable when every other router software and hardware appliance out there will bring itself up in a hobbled state to pass traffic.
An optional ethernet port disappearing is not a good reason for your router to halt and catch fire.
We ended up ripping out PFSense at a few medical practices due in part to this issue.
It's probably a bad idea. But HIPPA is a specific and public block of text, which says less than most people seem to imagine it does. (I'm no lawyer. I've just read the thing).
The UI controls setting up the network and other services. Please explain how to do this without root access. (Write another process which runs as root and controls the settings and is talked to over a Unix socket actually isn't a bad idea, however, it is not void of its problems either.)
Also "most commonly exploited languages" is a bit of hyperbole, no? First, C probably takes that slot. Second, being one of the most common languages for web development makes it a target. Third, most php exploits are bad code, which, while easy to write in php (and c!), can be and is done in all languages.
Isn't the administrator interface on _any_ router essentially root access on said router? Do you complain that juniper or Cisco equipment is insecure because you can login?
BMCs (Baseboard management controllers) are something with very ... questionable ... security, yet network segregation is used to ensure its use securely. Given that many HIPAA complaint organizations such as AWS and GCP (Google Cloud Platform) I find it hard to believe that a management interface would disqualify something from HIPAA compliance.
Which part of the HIPAA audit did pfsense fail? Was it simply an abundance of caution" on your part? If so, what did you replace it with that didn't have a management or has a management interface with no bugs (hint: even Cisco and juniper have CVEs for the management interface)?
Also, php in no way makes it hard to write good code, it's just easy not to.
Maybe fourth - learn how to use it
No, you had as many problems as there are '%' and '$' symbols in this web page : http://www.cs.colby.edu/maxwell/courses/tutorials/maketutor/ multiplied by the number of permutations of tools in the different platforms you want to support, e.g. (gcc-mingw-windows, clang-cl-windows, msvc-windows (this one counts as 10), xcode-macos, gcc-macos). And let's not even get started with cross-compiling.
okay, please provide a makefile which:
* detects if, say, libpng is available
* compile a library, an executable and a unit test if that's the case
* links the executable to the library and the library to libpng
* does so for mac, windows, linux, creates a .app for mac, an installer for windows, a .deb package for linux
* can be used from IDEs, with IDEs understanding where your code has to be fetched, what the includes are, etc
here's more-or-less the CMake version :
project(myapp)
find_package(PNG REQUIRED)
add_library(mylib lib.c)
add_executable(myapp MACOS_BUNDLE WIN32 app.c)
target_link_libraries(mylib PRIVATE PNG::PNG)
target_link_libraries(myapp PRIVATE mylib)
install(
TARGETS myapp mylib
RUNTIME DESTINATION bin
ARCHIVE DESTINATION lib)
include(CPack)
you can't seriously say that this (which covers an immense part of software project needs) is easier to do in make, right ?You just compile with -lpng. If libpng is available, it will work, otherwise it will fail with a clear error message. What else do you need?
> * links the executable to the library and the library to libpng
LDLIBS = -lpng
BIN = foo bar baz
OBJ = lib1.o lib2.o lib3.o
LIB = libmine.a
default : $(BIN) $(LIB)
$(BIN) : $(OBJ)
$(LIB) : $(LIB)($(OBJ))
clean : ; $(RM) $(BIN) $(LIB) $(OBJ)
check : $(BIN) ; ./foo -test
This will compile the code from lib*.c into libmine.a, and then compile the source code of a few test executables from foo.c, bar.c and baz.cThe .a is useless often, but there you have it just in case. Otherwise, just remove all references to $(LIB) and get a shorter makefile.
> you can't seriously say that this (which covers an immense part of software project needs) is easier to do in make, right ?
This is rather subjective. In my case the makefile seems easier. It will work for all unices, but probably not for windows, and will not create an "app" package, your are right about that.
But the makefile covers indeed all my personal needs, and it is much more powerful and easier to use than the cmake/make combo. For example, you can test multiple compilers and compiler options with a shell loop:
# test all compilers in debug and release modes
for i in gcc clang tcc icc; do
for m in "-O3 -DNDEBUG" "-g"; do
make clean check CC=$i CFLAGS=$m
done
done
doing that in cmake would be a nightmare, wouldn't it?well, no you don't "just compile", because one of the most used compilers out there does not support "-l". Also because you may have multiple libpng versions on your machine - debug, with special testing flags, in your ~/work/libpng_build, etc.
Also, you may have libpng.so but not the headers. You may be compiling on Nix or GoboLinux or whatever system which does not respect the FHS. It won't work as is on OS X because you have to add -L/usr/local/lib. Users won't know what to do when they see whatever missing include error the compiler spits out.
> doing that in cmake would be a nightmare, wouldn't it?
.. it would be mostly the same than your example ? just tested and this works fine (normal practice with cmake is to build outside of src which helps):
for i in gcc clang; do
for m in "-DCMAKE_BUILD_TYPE=Debug" "-DCMAKE_BUILD_TYPE=Release"; do #not using -g because that's something compiler-specific
rm -rf ** ; CC=$i cmake ../ $m ; cmake --build .
done
done(The combination I've always had to deal with is Linux, OS X and Windows/VC++ - but any combination that includes both Windows/VC++ and a POSIX-type OS is probably enough to make it worthwhile. The POSIX/non-POSIX differences are rather annoying to deal with otherwise, and that quite apart from how most Windows programmers will quite reasonably want to use a Visual Studio project rather than a Makefile.)
506c
The posted makefile example fails right away on multiple platforms since headers are often in somewhere else than in /usr/include directly, for example in Debian the right (atm) path would be /usr/include/libpng16 and Makefile does not handle that.
And that's the intended behavior. Finding system headers around your disk is not a problem that a build system must try to solve. This is the task of a distribution or a packaging system, which is a different problem as you say.
> Also, you may have libpng.so but not the headers.
Then how on earth are you supposed to compile it? You write the definitions verbatim on your code?
> It won't work as is on OS X because you have to add -L/usr/local/lib.
For that case it is better to not mess with compiler options and set up the compiling environment so that -lpng works, e.g. by setting LIBRARY_PATH=/usr/local/lib, and similarly for C_INCLUDE_PATH. These variables are recognized by all unix linkers and compilers that I care about.
Of course, this attitude may not be appropriate for everyone. Yet, I am in the happy position to be able to say say "this program requires gcc, clang, tcc or icc to be compiled, otherwise, please edit the makefile to suit your needs". Are there really other C compilers around? (notice that visual studio is not a C compiler, and cannot compile modern C code, so it does not enter into the discussion if you are a C programmer).
what I mean is that an user might download your source archive, run `make`, and have hard-to-understand failures because of this.
[0] http://gittup.org/tup/make_vs_tup.html <edit substitutes the make comparison link instead of the main page>
A modern build system by default should be able to provide utilities to make sure your build is correct and reproducible. Those features need to be coded into your Makefile and aren't available easily or by default.
If you need to code those rules, then you don't have a build system, just a way to run commands and possibly add some (usually poor) logic around them.
A typical example that most handcrafted Makefiles will fail is that changing a build flag should only rebuild the files affected. Most will either require a full clean (aka ignoring the flag change) or rebuild everything.
If you change a build flag, how aren't all the files affected?
Then to build one particular bit of software, there is a dependency upon a particular version of cmake, which you don't have.
Or you have to upgrade Maven. Or install some software you do not have by default on your environment.
I've never had to do that with make.
I've been told that other tools are better because the are simpler ... that is ... until you run into one of those aforementioned compatibility issues with the build tool.
This isn't an infrequent occurrence for me, I see lots of hardwiring for various packages that I don't have installed by default in some projects.
Then you get the gophers/rust folk, and their need to run on the most recently released kit. With all its undiscovered bugs. The gophers want to replace make with mage ... well, to be more correct, they want to replace every non-go based tool with one built in go, because ... go. A modern version of the insufferable pythonistas of years past.
Throughout this, I've been using and building with Make just fine. My make files do the heavy lifting in my projects. And I get a good laugh each time I hear "oh I have to fix my magefile/CMakeFile.txt/yadda yadda yadda".
As the great philosopher Inigo Montoya once opined ... you keep using that word [better]. I do not think it means what you think it means.
I tried using meson for https://github.com/shlomif/mini-factor , and while it worked fine locally it turned out to require python 3.6 which made it hard to install on Travis-CI. I ended up created a complementary cmake build system.
One of make's great strengths is that it is so generic.
Writing ninja files by hand is tedious and those extra features make provides can make it easier to use, but in principle ninja should be able to handle anything make could.
It also works in windows.
This is gold!
GNU/Linux was initially developed from scratch to behave like UNIX to a certain extent (hence the name "Unix-like"). In other words, it's a rewrite inspired from a model.
macOS has a marketshare in server market segment of around 0% (client of around 5%, iOS substantial though), and Linux is the defacto standard in that area. Which OS do people learn nowadays? Linux distributions. So it makes sense to see it from that PoV. Because chances are that you're going to use that defacto standard. And even if you prefer UNIX(tm) or BSD or Solaris you'd rather use Linux than Windows or OpenVMS. Cause the latter are aliens from outer space.
More philosophically, insisting on a definition of UNIX which includes z/OS and excludes Seventh Edition Unix isn't going to win you many friends.
http://www.opengroup.org/csq/repository/norationale=1&norefe...
And speaking of aliens from outer space, z/OS is a JCL-eating Martian speaking EBCDIC through its virtual cardpunch. ;)
Also many of these are actually GNU idiosyncrasies, and from it's name GNU suggests that there is a standard, and they are going to be different.
PCs were these toys for people who had no acces to real computers, until they were the standard. Microsoft provided toy OSes until they wiped out almost anybody else. Java, MySql and subversion are other examples.
I've read somewhere that every succesfull product has a phase where the world laughs at it. If that hadn't happened, it would have been smothered in the cradle by the behemots of its time. Being laughed at gave it time to grow.
Has created some incredible UI paradigms and elements, but...
Linux isn't a static environment. The closest thing to static is POSIX, and by and large every Unix environment, including various Linux environments as well as BSD environments, asymptotically approach POSIX compliance.
If you want to maintain a project long-term (5+ years), attempting to minimize deviations from POSIX is a solid strategy in terms of avoiding bit rot and long-term maintenance burdens. Sometimes it's unavoidable, but the point is to weigh your options carefully and don't undervalue the benefit of POSIX compliance. If you want to maximize the chance that your software will compile and execute correctly on a Linux distro 5+ years from now, a good first step is making sure it builds and runs natively on some of the BSDs.
There's a trend to discount the value of POSIX and to even actively break POSIX compliance in a way that makes it very difficult to support both POSIX semantics and some feature du jure. Developers should be wary of those who do this because if such projects and their maintainers don't see any value in POSIX they're not likely to see value in the long-term maintenance and stability of whatever feature they're selling you on today.
Else thread somebody says that they see Linux as the new SunOS. I agree.[1] But where is SunOS today?
[1] Except that Sun put much more emphasis on backwards compatibility. The Linux kernel developers emphasize backward compatibility, but the distros don't, and if the distros rip something out then inevitably it gets removed from upstream. OTOH, while the kernel developers rightfully have said they won't compromise sane design for POSIX, it turns out that such situations have been exceedingly rare and in general they take POSIX compliance seriously.
The problem is that POSIX only provides a tiny subset of the API surface that an application might need today. Just to give two random examples: how can an application inhibit system sleep or use a webcam? The best one often can do is rely on some widely-used library and hope that they (will continue to) support multiple platforms.
But where is SunOS today?
Comparing apples and oranges. For a large part of its lifetime, SunOS was a proprietary UNIX that only worked with Sun hardware. If we include SunOS 5/Solaris, they open sourced Solaris way after Linux already had a stronghold in the market.
Linux is now so dominant in mobile phones, servers, network devices, and IoT, that even it will take much longer to disappear than SunOS.
- http://www.daemonology.net/blog/2011-12-17-POSIX-close-is-br... It's impossible to reliably close a file if you have active signal handlers that might be triggered.
- https://www.sqlite.org/src/artifact/c230a7a24?ln=994-1081 (discussed at https://news.ycombinator.com/item?id=17601581 "POSIX advisory locks are broken by design.")
- Seemingly anything to do with terminal devices or job control. (Allocating ptys, sending control sequences like ^D or ^Z, adding processes to a group that will all recieve terminal signals together, etc.)
- 'Basic' regular expressions (as in `echo baaar | grep 'a+' || echo WTF`).
- The existence of hard links as anything beyond a destination cache for symlinks.
Most operating systems have problems like these, but POSIX proceeds to enshrine them as unfixable 'features' rather than "DEPRECATED: DO NOT USE". (On the plus side, F_SETLK(W) and close seem likely to be fixed at some point and close doesn't tend to get maliciously exploited the way eg integer overflow does by C compilers.)
The semantics of POSIX advisory locks were inherited; they codified the most widely used existing implementation. The ergonomics suck, but they offer one distinct advantage: you can query the PID of the lock holder, something not possible when a lock can be inherited. This can be useful for PID file locks where you can query the PID directly rather than trying to write and read it from the PID file; there's no loaded gun lying around, although there's still the TOCTTOU race between querying and kill'ing. In any event, "file-private" advisory locks are likely to be standardized and are already implemented by both Linux and FreeBSD. See http://austingroupbugs.net/view.php?id=768 The semantics are not coincidentally very similar to BSD flock, and the types similar to POSIX. Which is noteworthy because it's an example of how paying attention to POSIX and portability issues can help you triangulate the evolution of Linux interfaces down the road.
It's not like Linux is without its warts. The kernel's implementation of setuid & friends is per thread. That's not only horribly inconvenient semantics for 99% of use cases, it's a security nightmare. And glibc and musl must implement an obscenely complex dance to get process-wide, atomic behavior. There are also many legacy Linux interfaces that the project is committed to supporting because of its commitment to backwards compatibility. I don't understand the logic of pointing out all the anachronisms of POSIX (e.g. advisory locks) while ignoring the anachronisms of Linux.
I never said POSIX was perfect, and I'm not arguing to only stick to POSIX. There's no substitute for using your own good judgment. I'm simply saying that too many people don't appreciate the benefits of POSIX and portability more generally, which are substantial. The benefits aren't just the standard itself or the ability to use an alternative OS like FreeBSD--if you didn't care before you're almost certainly never going to--but the fact that every Unix vendor tracks the standard and, to a lesser extent, avoids gratuitous incompatibilities with other POSIX environments. Standardization signals important information about the stability of an interface, and the process of standardization channels the evolution of interfaces long before they become standardized (if ever). POSIX and the BSDs matter to Linux development; and they should matter to Linux developers even if they'll never run code outside of a Linux environment.
It's also worth mentioning that Red Hat basically steers POSIX, now, judging by the Austin Group Bugs issue tracker. So while some teams are rather antagonistic toward POSIX (e.g. Poettering and systemd team), others put considerable effort into it.
Like everything, this is a trade-off: what you are advocating is that people use a more or less frozen sub-set of features, and avoid improvements that are already de-facto standard.
I looked at what would happen if my employer standardised shell scripting on "sh", rather than "bash", and quickly concluded that it was a bad tradeoff for us: Bash is, has has been, the standard shell in every place that we would want to run non-trivial shell scripts: if we ran Alpine Linux containers, we could just treat those as a special case.
> Perl is portable shell
Which ironically I do use in this way but never formulated it in such a compact and witty way.
I found Perl to be available basically by default on every platform I could encounter, from AIX 3 to Windows (it comes along with Git for Windows, which gives you bash too).
There is a port system where users can build the packages from sourcecode on their own machines. Its +- like gentoo.
There is also a binary pkg system. It is faster to install since the packages are already built (binary).
To upgrade from minor versions ie. 11.1 to 11.2 it is very simple and well documented. Just see in the manual freebsd-update
There is native support for ZFS also which is great.
Virtualbox works very well, so its possible to install other OSes in virtualbox. VMware i dont think is supported.
(I continue to wonder what's stopping everyone from just ditching `grep` altogether and switching to `ag`/`rg`)
But that should go away by streaming the file. e.g.
cat haystack | ag 'Needle' ag Needle < haystack
No need for catPipes are a good tool, and so are many others. Having a good command of other basic mechanisms of the shell is going to hugely pay off, try to have a brief shot if you want [0].
[0] https://www.gnu.org/software/bash/manual/html_node/Redirecti...
grep needle haystack
Surely grep needle < haystack
is much closer to that form than cat haystack | grep needleWill work too, and now it's in the logical order.
ag and gmake and several GNU or linux-specific extensions not.
They're also likely a little bit slower, especially on large datasets. It's really hard to beat GNU grep. (Which is famously 3 cycles/byte in the trivial case. Great exercise though.) But for the most part performance is secondary to feature partity.
Looking at the whole benchmark that that page links to, the difference is within a few percent for the actual searching, but it is also the only software in the author's own benchmark that is even close. The other software that was mentioned in the comment above is some 5x worse.
Nobody is going to change the standard grep for performance reasons.
It really depends on what you're searching. In some types of searches, GNU grep can get very very slow. The page you were linked to includes some benchmarks for that. In particular, cases where you're searching large amounts of non-ASCII (but UTF-8) text. There are some benchmarks for that case here: https://blog.burntsushi.net/ripgrep/ specifically: https://blog.burntsushi.net/ripgrep/#subtitles-no-literal
Also, it's probably not about "feature parity" per se, but standardization. In terms of feature parity, there is very little that grep can do that, say, ripgrep cannot. But there is quite a bit that ripgrep can do that grep cannot do, mostly by design.
"replacing" grep with ripgrep has at least a dual meaning, and it is the source of unending miscommunication. In the one sense, I know plenty of people that have replaced grep with ripgrep (or whatever) in daily usage. This is a perfectly valid thing to do. In another sense, nobody is going to replace grep with ripgrep in a distribution because they almost certainly do not want to stop being POSIX compatible. That is, asking to "just replace" grep with ripgrep is equivalent to asking distributors to stop being POSIX compatible in exchange for some other feature that ripgrep provides. That question is a non-starter, but a lot of people either don't realize that or are confusing what it means to "replace" something.
ripgrep is split into libraries, so if someone wanted this, they could just go do it themselves. :-) It would actually be pretty easy to get something that smells like POSIX. But the details make up a very long tail, and some of those tasks are fairly significant (supporting BRE syntax, supporting POSIX-style alternations, supporting POSIX locales).
Shouldn't it be less than that in the best case, by means of Boyer–Moore?
http://pubs.opengroup.org/onlinepubs/9699919799/utilities/gr...
Using ag et al in a script makes your script non-portable, which is the opposite of the goal here.
By ag, do you mean ack-grep (https://beyondgrep.com/install/)?
Which still has many of the terrible problems of the shell, because its original design was an imitation of several different shell scripting languages.
If all you know is Perl and you're incapable of learning any other languages, or for some perverse reason you like the way Perl scripts look just as incomprehensible as shell scripts, and you're absolutely sure nobody else will ever need to look at or maintain your code, then by all means use Perl. But if you don't hate the people who will have to clean up after you or decipher and maintain what you're done, then please use Python or JavaScript instead of Perl or shell scripts.
Sorry but Perl is perfectly fine even by today’s standards.
Actually, I don't know many languages that have a good way to call subprocess in stdlib. Ruby's Open3 comes in mind, however the API is kind horrible.
Of course JavaScript has an external library for sane subprocess calls, and is perfectly fine and commonly used for writing process management and system administration scripts. Please google "node.js" and "npm".
[Edited for tone -- thanks mkesper.]
No, JS shouldn't be used as a systems language IMO. It gives you enough rope to shoot yourself in the foot (multiple mixed metaphors for a reason).
[1] https://charlieharvey.org.uk/page/javascript_the_weird_parts
Python's subprocess actually run the process inside a Python process, so there is no possibility to hang youself up in case of a vulnerability in shell code. You can explicitly run the subprocess in shell script if you need shell capabilities (glob expansion comes in mind), however you shouldn't.
In the end it really depends on how much the developer is suffering from some form of impostor syndrome: if they're not, you have a good chance they will create code that will be unmaintanable even for them in a few months time. Regardless of language.
Can you name any schools that teach Perl to undergrads on a non-trivial scale? Maybe there's a reason you can't. But I can name a lot of them that teach Python and JavaScript.
https://ocw.mit.edu/courses/electrical-engineering-and-compu...
And of course Python code is more readable and maintainable than Perl code, by its very design and nature, and also by its widespread culture and philosophy, which is 180 degrees opposite of Perl's philosophy and culture.
It's not just a matter of "There's more than one way to do it" -vs- "There should be one -- and preferably only one -- obvious way to do it." The Zen of Python goes much deeper than that.
https://www.python.org/dev/peps/pep-0020/
There's also the idea that instead of using arbitrary idiomatic and personalized punctuation and line noise in "more than one way" to accomplish the same task, you should simply use letters, by combining them to form words, connected by underscores or CamelCaseCaps to form coherent phrases, which have meanings, that communicate with the person reading the code, explaining the ideas and intentions behind the programmer who wrote the code. Subtle little things like that, you know.
Line noise and random punctuation do not make self documenting code. That's why it's traditionally used as a stand-in for censored obscenities, because it's meant to obscure its true meaning.
I encountered this last in the mid oughts with insufferable Pythonistas. Seems not all of them have had time to think deeply as they gaze at go/rust/julia coming along to eat their lunch.
Perl continues to advance, people continue to start projects within it. Code continues to be contributed. CPAN (and CPAN6) continue to grow.
Quite sad.
By "nobody else" you really mean "other people with the same mindset who aren't willing to invest some time in getting used to perl syntax". Thing is that modern javascript is just as incomprehensible to sysops/devops people who're not familiar with the new JS syntax. You come from one world and think that's the "normal", they come from the other and expect that everyone already knows perl as it is half bash, half C. And in the end it's really much more about how much time did you spend working in it, than in one language being so much clearer than the other.
http://geekfeminism.wikia.com/wiki/Randal_Schwartz
"He's the Hooter's guy, right?"
https://web.archive.org/web/20080328132126/https://www.oblom...
http://blogs.perl.org/users/joe_mcmahon1/2012/08/why-im-cons...
And have you ever tried to hire a competent experienced Perl programmer? They're extremely hard to find, and very expensive, and usually would rather be working with some other language. Sure, incompetent ones are a dime a dozen, but hiring those and setting them loose just starts the vicious cycle again.
All of the competent Perl programmers have long since been hired up by companies desperately trying to find people qualified to work on their old toxic legacy code bases that they're stuck with. Like Booking.com for example.
And writing new code in Perl is insane. There's absolutely nothing special about Perl 5 or Perl 6 that solves any problems you can't easily solve in most other languages.
Perl's much larger problems totally overwhelm the minor conveniences from its "syntactic syrup of ipecac" that perversely appeals those few people who think saving a few keystrokes at the expense of readability, instead of spelling words out with letters instead of line-noise punctuation and acronyms, is the sole goal of software development.
Perl 6 is a joke, a slow moving parody of itself that missed the boat decades ago, and it's absolutely never going to catch up with JavaScript or Python.
If you really want to optimize your career for programming toxic legacy code that's too ugly for anyone else to touch, you should have learned COBOL before the Y2K "crisis". But in the long term, you might have regretted it:
Perl is doing well, thank you. Perl6 is interesting, but I don't have a project for it yet. There are jobs in perl, there are needs, and we (perl devs) aren't appreciably more expensive than non-perl devs, though some of us may be better at negotiation than the dime-a-dozen developers in more "common" languages.
There is just so much that is wrong with the post above. Its actually sad.
Perl is still one of the best glue/high level systems languages around, partisan missives not withstanding. Debian's apt system is based upon it, as is git (though it uses C for parts that are intensive), and many other tools.
Python is fine as a systems language if you don't mind the insane indentation issues, and the extra boilerplate you need to do for "simple" things.
Honestly, I see Julia as the up and comer here. Julia has IMO the best syntax, is JIT compiled, is a real programming language, and is IMO python done right.
If you are stuck believing python is a good language to develop new projects in, great. Knock yourself out. I personally find myself most productive in Julia, Perl, C, Octave/Matlab, and yes, even Fortran.
I think Julia is very exciting, and yes, the core language is very good. But so far I see very little uptake outside numerics. Hopefully it will get there.
It is JIT compiled, though some of us who like to deploy apps would love to have an AoT compilation. Likely we could work around that with a singularity container on linux.
Unlike many other languages, parallelism is a first class citizen, be it SIMD, GPU, distributed machine, and combinations.
It also works very nicely on FBSD 11.x. I've tried compiling it on recent 12.x nightlies, but not had great luck.
I am actively looking to find projects to work on in it.