1. 8

    Sad thing is I remember that there was quite a treasure trove of old humorous things under the https://web.mit.edu/jemorris/humor URI, but it seems that the access to browse the directories has vanished with some update on MIT side.

    For what it’s worth here are some of the other links I could find when it was still possible:

    1. 5
      1. 3

        You may want to look at https://archive.org/ and also archive existing stuff.

      1. 7

        Does anyone know of a good book that treats systemd somewhat comprehensively?

        At this point, I’ve decided my feelings about systemd don’t matter; it’s clearly here to stay. System administration is not my day job, so I’ve been able to get by with only minimal and superficial knowledge of it. I’ll have to re-learn a lot of tasks that I knew how to do (or could at least figure out how to do) using the previous init systems.

        Whenever I do, I find I’m always googling (or reading man pages) in frustration. It’s a very extensive system. Command names are long and non-obvious. That’s okay. After all, if I managed to learn git, I should be able to learn systemd.

        But I’d like to do so at a leisurely pace, instead of scraping documentation together from (frequently severely outdated) blog posts and man pages.

        So is there a good book that’s up-to-date? Or is Red Hat certification study material my best hope?

        1. 15

          At this point, I’ve decided my feelings about systemd don’t matter; it’s clearly here to stay.

          That’s not totally clear to me. The two biggest bits of the Linux ecosystem are Android and cloud deployments. Android does not use systemd, it uses its own thing. Cloud deployments increasingly use things like Kubernetes to deploy containers. They may use systemd on the oustide (does containerd depend on systemd yet?) but typically the containers don’t use systemd on the inside. Over time, I expect the things on the outside to be simplified and systemd is an obvious contender to go because it doesn’t add much value in this space.

          Systemd is really only dominant in individually managed servers and desktop deployments, neither of which are particularly large or growing parts of the overall ecosystem.

          1. 5

            Plus, nothing is permanent in the world of tech :). At this point, systemd is mature enough, and deployed widely enough, that I’m beginning to see a bunch of anti-patterns. In my experience, this is when people begin thinking of the next step. Anti-patterns aren’t just a symptom of incompetent users/developers, they’re a sign that a technology is reaching its limits.

            A pattern that I’m seeing increasingly often in embedded systems is something that I’ll just go ahead and call the “big init service”, for lack of a better word. Basically, there’s a unit file that runs a shell script, which runs all the application-specific programs (random example from the latest gadget I’ve worked on: a zeromq-based daemon, a logging service – I don’t know why that’s a thing, I was paid just to make the previous daemon stop crashing –, a pseudo-watchdog timer, a license manager, some serial-listening daemon, and a Wayland session in kiosk mode). Basically anything that didn’t have a Yocto package in a base layer so that you could just list it as enabled/disabled at build time.

            Being the helpful idiot that I am, I asked one my customers why those aren’t separate init services (I generally know better, but we had a history together and figured it wouldn’t hurt). They told me they knew it was possible but it was a lot of hassle, and they frequently had to launch some of these programs with various extra flags or environment variables for debugging or development purposes, or tweak various parameters when testing. Plus they were all designed to work together anyway. It was a lot more convenient to be able to start them all at once, stop them all at once, and tweak how that’s done by just changing a few lines in a shell script, than to mess with half a dozen unit files. I offered a few suggestions about how systemd can manage that. Turns out they’d tried each and every one of them, and never managed to get it to work reliably – and figured they’d rather write a clunky script than risk dealing with all sorts of flops in the field.

            (Edit: to be clear, I think systemd can actually handle that case pretty well – but, indeed, I guess it is a lot of hassle, especially if you want to ensure it works the same way every time, which is very much important for unattended devices where interactive access isn’t always easy to get).

            1. 1

              What advantage does systemd bring in this use case in the first place? It sounds to me that they’re basically bypassing systemd? Or are there other parts that bring value?

              1. 1

                There aren’t, at least not for them, but at this point it’s so hard to yank it out of (some) systems that they’d rather bypass it.

            2. 3

              I tend to use containers over VMs specifically because I don’t have to configure a process manager or a log collector or an ssh daemon or host metrics or anything else. More importantly, developers don’t have to know how to do these things, so now they are empowered to own a greater share of the “ops”, and they aren’t bottlenecking on communication and coordination with an ops function.

              1. 2

                They may use systemd on the oustide (does containerd depend on systemd yet?) but typically the containers don’t use systemd on the inside.

                You must work in a much more aesthetically pleasing corner of the software world than I do! At this point I’m rarely surprised to find systemd in an Enterprise Container™.

                1. 2

                  That might be true, but while Gartner might have some say about what kind of work I’m likely to do in the future, it has very little influence on my personal choice of desktop, and the people who maintain open source desktop linux have mostly chosen systemd.

                  1. 1

                    That might be true, but while Gartner might have some say about what kind of work I’m likely to do in the future, it has very little influence on my personal choice of desktop, and the people who maintain open source desktop linux have mostly chosen systemd.

                    I don’t disagree, but I suspect that systemd will make part of the ecosystem increasingly disconnected from everything else. I wouldn’t be at all surprised if Android started to encroach on the desktop Linux market. Android works surprisingly well on devices with keyboards and mice instead of touchscreens and now supports split screen mode, which is what fans of tiling window managers have been telling us all for ages is better than multiple windows. If you use F-Droid, you can install a load of F/OSS apps, including a chroot environment for GNU/Linux things and even an X server so you can run graphical non-Android *NIX apps. There’s even a native OpenOffice port. At the same time, you can run things like MS Office or any of the rest of a huge pile of other supported proprietary software.

                    If you’re a hobbyist developer, writing an Android app rather than something for GNOME or KDE gives you a lot more potential users, a lot more potential collaborators, and a set of more marketable skills if you want to eventually move into commercial (open source or proprietary) development. How long do you think GNU/systemd/{GTK/Qt}/{X11/Wayland}/Linux is going to be more popular than Android for desktops?

                    1. 1

                      That’s an interesting question. Popularity - for me - is not a reason to jump ship to another system, at least not for personal use. You’re a FreeBSD developer; if you’d listened to the cool kids on slashdot back in the day you’d have abandoned that doomed ship a long time ago ;)

                      But you’ve made me wonder what my criterium for choosing a platform is. I’ve always told myself it’s about antifeatures (as defined by Benjamin Mako Hill), which is why Android doesn’t appeal to me. But arguably, systemd qualifies as an antifeature, and it nevertheless went on to dominate Linux distributions.

                      1. 1

                        You’re a FreeBSD developer; if you’d listened to the cool kids on slashdot back in the day you’d have abandoned that doomed ship a long time ago ;)

                        In hindsight, that might have been the right call. At the moment, I’m working more on Linux than on FreeBSD. Some things are nicer on one, some on the other (my ideal *NIX would have clone, futex, ZFS, capsicum and jails, for example). If Linux were not GPL’d, I think I’d be working now on bringing the features that I miss from FreeBSD across and give up on FreeBSD entirely. That said, I see Windows and *NIX as legacy systems at this point and I’m more interested in working on the things that will replace them.

                  2. 1

                    Just you wait a few months, and systemd will also do container orchestration! j/k :)

                    1. 1

                      Well, there is systemd-nspawn. Which is a sorta alternative to LXC. I haven’t tried either yet, so I can’t tell anything about their respective qualities.

                  3. 11

                    I’ve found the systemd man pages to be somewhat complete and comprehensible. Give man systemd a try and then you can gradually discover other tools by jumping from one to the next in the “see also” sections. It’s not the best approach to learning, but it’s not bad either.

                    1. 6

                      Exactly. This is what I’ve come to appreciate about systemd. Compared to what Linux had, it’s reasonably consistent, coherent, and thorough. Sure, it makes a few questionable decisions, sure it has had a rocky road at times (I recall my system locking up on shutdown in the early days thanks to something in journald), and sure there are individual parts of it for which I might personally prefer an alternative (runit for process management, cronie, syslog), but taken as a whole I feel so much more comfortable with what we have now. It gives a certain level of polish I’ve always felt lacking in Linux (OpenBSD has this coherent feel too, without systemd, but I can appreciate both approaches). And most importantly, despite the fears, it doesn’t seem to have affected the viability of alternatives. There are still plenty of distributions that avoid systemd entirely.

                      I’ve recently been looking for a Linux distribution supported (by default) by cloud providers that feels reasonably clean. I’ve been using OpenBSD but sometimes a Linux just makes certain things easier and I needed the option. Long story short I ended up on Fedora and the one part I really didn’t like was NetworkManager. It felt a bit of a mess with documentation scattered all over, disorganised manpages, and legacy formats (ifcfg-rh) just to confuse things. Then I realised that I could just use systemd-networkd which was well documented, far more simple, easy to configure with familiar syntax, and pretty broadly available (in base installs) in case I ever need to switch. l actually ended up using NetworkManager’s keyfile plugin, but discovering that was a chore, and I just want these things to work.

                    2. 6

                      One of the early adopters of systemd, Arch Linux, has fine cheat sheet -like documentation that goes through many things: https://wiki.archlinux.org/index.php/Systemd

                      Systemd isn’t so complex that you should be looking at certifications.

                      1. 2

                        Newest edition of UNIX and Linux System Administration Handbook has a good chapter about systemd, I believe, but I am not sure if it will be as comprehensive as you’d want it.

                      1. 1

                        Are those %D intentional? Seems like a bug in the example code… and I guess the intended was something like :

                        $ # this
                        $ date "+%Y-%m-%d %H:%M:%S"
                        2020-04-24 16:31:31
                        $ # more then this:
                        $ date "+%Y-%m-%D %H:%M:%S"
                        2020-04-04/24/20 16:33:53
                        

                        or better yet (in my opinion):

                        $ date -Iseconds
                        2020-04-24T16:32:37+0200
                        
                        1. 2

                          This is from 2007, I believe, hence the history tag.

                          1. 2

                            Well, the footer notably states that the site was started back in 1994 which is even more impressive given the content presented! The earliest snapshot in Web Archive is from 1999 and the website that is now served first shows up on the first snapshot of 2002. Great find! Thanks for sharing!

                          1. 4

                            Very nice to read. I’m quite the Postgres fanboy (as a MySQL refugee, Postgres feels like an oasis of sanity), but it’s good to be aware of pitfalls. Personally, the only annoyance I’d ran into was the limit on identifiers (they can be only 63 bytes), which is usually easily worked around.

                            The corruption-spreading replication sounds especially nasty, since we’ve been considering using replication as a more light-weight form of backup than an half-hourly pg_dump, which can be heavy on the server.

                            1. 1

                              I wonder if having a logical replication in place would’ve be a solution to this particular scenario, as the text only implies the problem exists with binary streaming. The replica then could be used for creating reliable backup’s if the load on the main server is a problem. Also there’s always barman or pgbackrest for implementing complex backup & restore policies with point-in-time recovery, which might be a better solution than only using pg_dump.

                              1. 1

                                I really like the way the historic aspect has been presented. It is awesome to have this higher level overview of “the story of sorting in Postgres” in one place, which offers the ability to learn a little bit more about the process of improvement in an open source codebase (as well as the details of sorting & the reasoning behind their approach).

                                I sometimes wonder about the value of “non-reaserch” work that is similar to this presentation in academia. At my university the R&D topics for obtaining a diploma were more often then not passed over as they were dubbed “more laborious” by other students. Seeing this presentation I must say that “less laborious” is the easy way out of this kind of work and I wish that more people would take the approach of this presentation. This was really in-depth tour through history of the codebase, which makes me think that we should invest more in spreading the knowledge we already have dispersed in different places in more approachable way.

                                Thanks for sharing this video.

                                1. 4

                                  All generalizations suck, but it needs to be stated that this isn’t a problem of untyped text streams, as much as the author (and others) would like to make it so.

                                  The problem can generically be stated as organic accretion, but there’s probably a bit of human laziness underneath it all. I’d summarize it as “Compound piping among several commands is tough. Adding new options is easy!” While not true in each and every instance, and for many of these cases probably adding the option was tougher than the composition, it’s “true enough” where that over a period of decades the cruft begins to add up.

                                  I wonder if further standards around the Unix Philosophy might help here, specifically in regards to code budgeting (tm) and other purposeful artificial (and perhaps functionally orthogonal) constraints on design.

                                  1. 5

                                    Organic accretion is a property of software. If something exists that works, it’s easier to add to it than remove from it. This ends up being desired by users too - you’re absolutely free to run Slackware 3.1 or at least the command line tools from it, but people don’t do so voluntarily.

                                    But, imagine if command line options didn’t exist - we’d end up with a lot more binaries, and distributions where the number of binaries grows over time. Is that better or worse? It seems like it would be slower (piping means context switches), reading scripts seems of similar complexity since the number of things to know is essentially the same, and it may or may not improve flexibility, depending on the supported combinations of the command line options vs. the composability of separate commands.

                                    It’s hard to read the article without sensing that the real complaint is that software is becoming more capable over time, as opposed to the form of that capability.

                                    (That said, I would like a mini-man that tells me the most common options that’s faster to read, and be able to fall back to the “manual” when something obscure comes up.)

                                    1. 4

                                      (That said, I would like a mini-man that tells me the most common options that’s faster to read, and be able to fall back to the “manual” when something obscure comes up.)

                                      https://tldr.sh/ ?

                                      1. 1
                                      2. 2

                                        Organic accretion is a property of software, and it happens, oddly enough, organically.

                                        I don’t think we’re so far apart.

                                        Let’s take ls. Assume that ls has one and only one output: a series of columns with everything you’d like to know about the filesystem you’re pointing it at. Now there very well may be some command-line options, but they all would be around what the target is: whether to recurse, whether to follow symbolic links, and so on. No command-line options around display.

                                        Would that work? Sure it would. You’d just pipe whatever came out to grep, awk, or whatnot to do the rest of the work that command-line options currently do. But wait! Your point is valid: that’s a lot of piping and context-switching. Heck, you’re tanking performance and you could easily end up with tons of binaries for any simple job. Think of the versioning problem alone. Much easier to add to something that already works (and you know) than use three or four tools you don’t know for the job, increasing coupling and dependencies and making whatever you’re doing much harder to understand later.

                                        But what we’re both complaining about is an implementation detail: how various command-line functions work together and under-the-hood. Could we just smash up long command-line pipes into one executable with one binary, optimizing caching and piping under the hood? Sure we could. We don’t, but such optimizations take place all of the time in programming languages. There’s no reason that they couldn’t take place on the command line, except one: it’s easier to accrete off something you already understand and works than it is to join up several things you might not know so well into something that might be harder for others to grok. If we could smash up and break apart complex command-lines at will, we’d be doing the same thing as adding options without having to modify code or making any one command so bloody complex.

                                    1. 6

                                      Maybe it could be of interest here. The researcher from my alma mater was the initial author of the compression scheme used in this standard. They even created a video promoting that fact. What is more interesting is the fact that the companies tried to patent his work which he wanted to stay publicly available for anyone and this started a long legal battle between him and Google.

                                      1. 3

                                        Yep, the legal stuff around compression is always a headache–see also JPEG2000 iirc. One of the best examples in arguments against patents in software, if you ask me.

                                        1. 3

                                          The original JPEG as well, the arithmetic coding encumbered by IBM well into 2000s.

                                      1. 12

                                        This book was recommended to me by a senior programmer (my boss) back in 2006-2007. He introduced the book to me as, “This will teach the concepts of functional programming to you in a somewhat FP-hostile environment – Perl. But, it turns out that’s a lovely and fun way to learn the concepts.” At that time, FP wasn’t popular in any mainstream languages (e.g. Java was at 1.x versions headed toward Java 7, Clojure was new or non-existent, and FP was uncommon in JavaScript and Python communities). Meanwhile, in our production environment at a BigCo, Perl was the only dynamic language allowed in real apps, because it was commonly used as a portable alternative to shell scripts. This meant I could toy around with FP concepts while writing “production code” (typically, the wrappers & scripts surrounding our “real” app, which was usually written in Java).

                                        Higher-Order Perl was an enlightening read and it also gave me a deeper appreciation of Perl as a language for fun “expressivity hacking”. It was also when I started to go down the FP rabbit hole, which eventually led me to FP in JavaScript, Scheme/SICP/Racket, Clojure, etc. So I recall the book fondly! (It was also my last experience with Perl, so I left on a high note!)

                                        1. 2

                                          It is said in the preface, I think, that Perl can almost be considered a Lisp, so it isn’t at all surprising that it fits into FP mindset so well. I found the quote from the book:

                                          The book Paradigms of Artificial Intelligence Programming, by Peter Norvig, includes a section titled “What Makes Lisp Different?” that describes seven features of Lisp. Perl shares six of these features.

                                          ( Here you can find the original 7 features of Lisp listed in the book mentioned in the quote. )

                                        1. 5

                                          The regex as a value generator, as used in this book, is really quite good. I’ve been dying to see somebody write it up and stick it on CPAN.

                                          1. 3

                                            Which chapter? any link?

                                            1. 6

                                              I think parent comment mentions the Infinite Streams chapter of the book: https://hop.perl.plover.com/book/pdf/06InfiniteStreams.pdf (see page 18 in the link).

                                              1. 4

                                                Section 6.5 on page 272 for those just peeking in a browser. Good stuff! Thank you.

                                                1. 2

                                                  Thanks! much appreciated.

                                            1. 6

                                              Hm, seems like a nice addition to the existing explain service I know - https://explain.depesz.com

                                              Here is a comparison between the outputs from the same query plan:

                                              1. 3

                                                It’s that and also a fork/continuation of PEV, which is awesome and left complete about 4y ago, but a lot of people wanted results to be stored server-side (for collaboration) rather than browser local.

                                                I remember dalibo forking it some time ago, it looks like it’s come a long way!

                                              1. 1

                                                Really insightful! I especially like the way it showed the relationship between different mathematical operations, just by switching the notation. Which reminded me about a similar thing that could be done - changing the usage of pi in mathematics to instead use tau as the basic mathematical constant.

                                                1. 4

                                                  Is there sam sort of a description of the framework (maybe a blogpost or a video) ? Like highlevel description & key differences from the competition in the web framework space?

                                                  1. 2

                                                    Overview of framework here: https://github.com/treenotation/jtree/tree/master/treeComponentFramework

                                                    No video yet, but good suggestion.

                                                  1. 2

                                                    For a while I have been reading Unix & Linux System Administration Handbook. So far I love how they included very opinionated statements about the technologies that are available. It is really refreshing to see the practical side exposed instead of the hype alone, which unfortunately is not what’s often found in various web sources (or other books for that matter). I also like the answer to the why question that’s included in most of the chapters. It is in my opinion very useful, especially when reading about some more obscure topic (or something that isn’t used at the day job).

                                                    1. 2

                                                      I’ve never really needed it as a (mostly) hobby developer, but setting that aside, I think I was initially confused by the concept, that led me to be disappointed in what it, specifically docker-like, actually does. I thought that containers are like minimal VM’s that could be described easily shared without all the dependencies. That different containers could implement interfaces that made scaling and re-placing more seamless. I that an image could be generated and then inspected while it’s running. To be fair, I have no idea where I got the ideas from, seeing that I never used it, and when I tried it once I was very confused.

                                                      1. 2

                                                        “Containers” sort of means two things:

                                                        • OS facilities for lightweight “virtualization” by namespacing all the objects (filesystem, processes, users, network interfaces etc.) — FreeBSD Jails, Solaris Zones, Linux namespaces+cgroups-kind-of-a-mess-but-it’s-flexible-af
                                                        • tools for building and running “lightweight” OS images with filesystem layers and stuff

                                                        The latter usually relies on the former, but it can use real (ha) virtualization too.

                                                        I thought that containers are like minimal VM’s that could be described easily shared without all the dependencies

                                                        Well, the container images can be shared, they’re like glorified tarballs of a filesystem root that has a whole (stripped down) OS with your app and its dependencies.

                                                        different containers could implement interfaces that made scaling and re-placing more seamless

                                                        Anything related to scaling and stuff is a layer above, with all the fancy orchestration systems…

                                                        an image could be generated and then inspected while it’s running

                                                        Well, that sounds true? What do you mean by “inspected”?

                                                        1. 1

                                                          Also to explore these concepts by working through examples I recommend checking out the diyC project.

                                                      1. 1

                                                        Setting up new work laptop - Lenovo T490 with quite a beefy specs (a CentOS derivative). Plus, probably I’m gonna start reading Permanent Record by Ed Snowden.

                                                        1. 5

                                                          My shell prompt is quite involved, but I’m using fish, so I’m not gonna paste the whole code here.

                                                          But I’d like to share one change in approach, that I found a game changer:

                                                          Make it two lines.

                                                          The more stuff you put into your prompt, the longer it gets, so what I do is that I have one line with the path, git info etc and the second line just starts with . So my actual prompt is always on the very left, no matter how long the path. Which also means I don’t have to shorten the path or other things I’ve seen people do.

                                                          For example right now, it looks like this:

                                                          ~/Work/secret-project on master|→25!11?1
                                                          [2] ➤
                                                          

                                                          The git status on the top right means: 25 files staged, 11 changed, 1 untracked. The [2] is the return code of the last execution.

                                                          Of course there’s lots of colors. :)

                                                          1. 3

                                                            That’s also my approach to command line prompt, with the difference that I use Bash (but recently I have been exploring fish as a daily driver as well). I can’t recommend it enough, especially given the fact that current monitors allow for giving up one line like that.

                                                            1. 1

                                                              Similar here in fish:

                                                              ~/Code/somerepo master
                                                              ➫ 
                                                              

                                                              I only did a few small things after switching to fish:

                                                              ~/.config/fish/fish_variables (Set Vi mode)

                                                              SETUVAR fish_key_bindings:fish_vi_key_bindings
                                                              

                                                              ~/.config/fish/config.fish (ctrl-f to accept autocomplete suggestions in Vi mode)

                                                              bind -M insert \cf accept-autosuggestion
                                                              

                                                              Install pure

                                                              ~/.config/fish/conf.d/pure.fish:

                                                              _pure_set_default pure_symbol_prompt "➫"
                                                              _pure_set_default pure_symbol_reverse_prompt "➬"  # Shown in Vi edit mode
                                                              
                                                            1. 2

                                                              Truely, one of the greatest storytellers :D Thank you for posting this talk!

                                                              For people who would like to experience some of the style of storytelling in form different than lecture I strongly recommend reading book about Richard Feynman’s life - “Surely You’re Joking Mr. Feynman!”

                                                              1. 2

                                                                :D It’s on my to read pile, just haven’t got to it yet

                                                              1. 2

                                                                Learning for LFCS exam.