System administration is one of those skills you sometimes wish you didn’t have.
I’ve been responsible for managing a variety of systems, more or less continually, since 1981. Let’s just say that thrill of having “root” has worn off – nowadays I just want to get things done. That’s what’s been occupying my last few days (along with having a big sheet of stainless steel delivered!) – it’s detail-fiddly stuff and it’s inherently annoying to me because there is a complete lack of grand architecture to anything on the internet. This has been an ongoing problem since the 80s, too, but it’s gotten dramatically worse thanks to search engines.
What do I mean?
You might want to change the font on page titles in WordPress, and it would seem like “change font in wordpress page title” would be a useful search. And, indeed, it returns a lot of stuff. The problem is that WordPress changes fairly often, so you’ve got 400,000 search results that are wrong because they are all about how to change fonts in page titles in WordPress circa 2005-2017. Sure, you can search by date, but that probably doesn’t help either. This is in addition to the standard Internet amount of wrongness. So, you have out-of-date information mixing with mis-informed postings, leavened with the occasional nugget from someone who knows what they are talking about, and toxic chunks of advice from people who figured out a really kludgy way to do it that will break on the next upgrade.
Oddly, figuring out how to do something on the internet has become a process of weeding out a gigantic number of equally credible ways not to do something.
This seemed funny in 1996 when I wrote this slide. Now, not so funny.
This all comes back to a problem of maintaining customization. If you think of it, blogs such as this, or a WordPress Q&A site, is being customized and the meaning and intent of the customization is lost (in most cases) unless the custodian of the information is careful to somehow indicate that meta-information. In the case of an administration process, whatever it may be, you want a separation between the core system and the user’s customizations: in other words, you install WordPress and some templates and the blog postings and user’s settings should (ideally) be independent of WordPress itself. That way, you can upgrade WordPress on a different cycle from the postings and content. Sort of. Well, ideally, anyhow. As long as you rely only on the bare minimum of tightly-constrained system features, then it’ll work.
God help you if you want to change a font somewhere, and the font settings are contained in part of the stylesheet. Naturally, you might think “I will edit the stylesheet” but if the stylesheet is upgraded, your edits will be undone. That’s not a big problem – there are other places where you can add overriding style rules – but you have to know that and if you do an internet search for helpful answers, you’ll get answers from 2003 explaining how to do it wrong.
This is not in the form of a complaint, as much as an observation: system administration sucks. Why? Because it is at the tip of the mountain of complexity – complexity that software ‘engineers’ are cheerfully complexifying even more, as fast as they possibly can. One of the things I realized back in the early 90s was that computer security and system administration both have a common problem; it is impossible to ever ‘fix’ anything. Because the environment changes. Computers, which should be logical, and predictable, and more or less static in function, aren’t. That feature you depended on may vanish, or move. If your configuration file needs:
authentication-credential: 0x18ahdead00f
to set the encryption key, what happens when a programmer changes it (as part of a general re-assessment of configuration management for that system) so it should be:
global-key:0x18ahdead00f site-key: 0x18a0dead00f
instead? It’s necessary, for software to inevitably march on its progress to the singularity, that old things must change. And it is necessary that systems administrators keep updating things, endlessly. Software (and computer security systems that depend on correctly-functioning software) rots over time. This is sobering, to me, when I consider airframes that have flown safely since 1956 – still carrying passengers – and computer programmers talk about “uploading” into the cloud and living forever. Nonsense; they’d be deleted during a system upgrade because the old database wasn’t completely compatible and – oops.
The amount of human effort that is flushed down the toilet in terms of system administration, is truly horrific. These computers – these time-saving devices – are perhaps the greatest time-wasters ever created.
As you may have inferred, I am setting up WordPress today. The last time I set up WordPress was 2 years ago when I did the Fuel Rats’ site. It’s not bad, in fact, it’s pretty easy. But lots of little stuff changes with every release, so by the time you’re doing it again after 2 years’ vacation, enough things are different that you have to hunt down change-related breakage. We can’t ask everything to remain unchanging, but damn it, I wish I didn’t have to re-learn 90% of everything, every time. I know that if I were a professional WordPress installer, I’d be up on all the changes and details and it’d all be a snap. But as an intermittent amateur, it just seems like endless pointless annoyance.
James Mickens helps explain how horrible system administration and security are: “most of our hard work is immediately useless“… It’s true!
That… all that… is so deeply, depressingly, deeply depressingly true.
https://www.xkcd.com/1988/
Is this because the barrier to entry is too low? Is this because we think that, if we give people tools that are easy enough to do something with, and permissive enough with mistakes, we’ll make programmers out of them yet? We forget how COBOL and BASIC turned out, we did it again with HTTP and PHP, and it seems we’re finding new ways to make it easy to put together bad systems all the time.
Heh, well you definitely nailed it there (both times). It’s “easy,” and it saves you time … until it doesn’t. If you had to made the whole thing in the first place, it obviously wouldn’t be so damn convenient, but of course you’d get to control when/how it changes, according to your own needs. Then again, the blog(s) may not be priority #1, maybe not even in the top 10, so I get why many people would want to outsource a lot of it to something like WordPress.
I know it’s a different set of problems in various ways, but several years ago, I quit using Finale and switched over to Lilypond for my music notation needs. Sort of like switching from Microsoft Word to emacs … well, sort of, I guess. The whole process from beginning to end is rather different, and it’s hard to even compare what I can do with it — the nice free software (not the expensive junk) is just plain brilliant at doing exactly what I want it to do, with no surprises. It took a little while to learn all of the ins and outs, but I’ve never looked back.
I think it’s just the opposite. People want to be users/consumers who don’t know about anything that happens inside of their magic box. We make things as if that were a coherent design principle. All sorts of junk seems cooked up precisely to never reveal the secret of how the magic trick is pulled off. Because that would spoil all of the “fun” or something, or more likely because it’s more profitable. I doubt you could find out how an iPad works, even if your name was Tim Cook and your life depended on it. Who knows what it might do next, or how that can be fixed/changed/etc.? Nobody. You’re not supposed to know things like that.
cvoinescu@#1:
https://www.xkcd.com/1988/
I believe that’s called a “mashup” nowadays. Or was that back in 2005? My, how time flies.
We used to call it a “kludge.” Or. as we sometimes used to say at NFR, “our kludges are better architected than our competitors’ products.” We actually tracked regions of code that were considered kludgy, and rolled a general replacement into subsequent releases.
Part of the problem with how software is produced today is non-understood dependencies. I don’t know how many times, lately, I’ve seen someone grab something off of stack overflow, or whatever, and just slap it into production code. Sometimes, it’s really great code. Other times, it sort of works unless you depend on it. I used to review the APIs for things we were considering lifting into our system – you can tell a lot by how well the data-hiding and separation between data and implementation are done. Look at the header files. I saw a comment in a header file once that read:
/* drunk – fix later */
When you lift in a chunk of code you get not only the chunk of code’s dependencies, you get its mistakes. I remember one popular library I found embedded in a product that had deceptively simple horror that looked like:
/* OK I am not going to fire up an OpenBSD instance just so I can run this through a compiler… So, point and laugh if you want. */
void free_list_of_stuff(struct stuff *list)
{
while(list != NULL) {
free(list->data);
free(list);
list = list->next;
}
}
On implementations of malloc/free where the free memory block-list is linked with a separate data structure, that works but on implementations written by hardware engineers, the memory blocks are used to store the pointers to the next free block, which means list = list->next is overwritten if the compiler likes to put the ‘next’ field at the beginning of the address space. I saw that in a product and every linked list operation coded by the guy whose name was in the module comments had the same bug.
What I’m getting at is that it hardly matters if your code is good. Your product is going to be full of bletcherous kludgy crap – whether it’s open source, or it’s from Oracle or Google or Microsoft – it’s pointless to try to make your code good, when it’s absorbing toxic bugs from literally everyplace. I used to be notorious in some areas for my strong “no XML” policy. It wasn’t because I thought XML was a disgustingly bloated and badly designed specification, it’s that – until nearly a decade of bug-hunting – nobody appears to have any idea how to write an XML parser that doesn’t contain buffer overruns or memory leaks. It’s simply that writing parsers is hard, and the people who were doing it didn’t know how to write parsers.* But they did, anyway.
Is this because the barrier to entry is too low? Is this because we think that, if we give people tools that are easy enough to do something with, and permissive enough with mistakes, we’ll make programmers out of them yet?
I don’t think so. I think it’s that complexity is too high. Most programmers simply cannot cope with the level of complexity in their own code let alone actually understanding all the dependencies in a product the size of products nowadays. The only thing that is keeping the wheels on are accidentally enforced barriers between modules: consider SQL as a remote procedure call to a database API that handles allocating/deallocating its own memory. That’s totally different than if you have an ISAM library running in your address space and your programmer doesn’t realize they’re not using SQL and they have to free memory after the API calls.
Here’s what really sucks: attempts to modularize/reuse code make the problem bad. I suspect that not attempting would make it worse. But we’re already operating at the point where huge, significant chunks of our applications are complete unknowns that we just trust to operate flawlessly. Ha, ha, ha.
We forget how COBOL and BASIC turned out, we did it again with HTTP and PHP, and it seems we’re finding new ways to make it easy to put together bad systems all the time.
The programmers are gleefully asking to have it made worse. Because most of them don’t understand how bad they are, they want to have the safety systems removed “to make it easier.” Let’s pick a popular example: instead of having to allocate memory by declaring the variables you are going to use, and what type of data they are, let’s just have variables be whatever you assign them to be! So simple! One time, you assign it to an integer, another time, a string! So simple. So:
i = “this sucks”;
i = 0;
i = “0.0”;
/* what happens if we ask whether i == 0 ? */
The number of actual use cases where you want to freely convert types without explicit conversion are mostly what you do right before you implement a software disaster.
At the first USENIX C++ conference I nearly had a multi-way fistfight with a bunch of guys because I asserted the proposition that, if the compiler included, in the object code, the data types with which a function was called, you could do link-time overloading a type matching – and if you did that, you wouldn’t need C++ at all. It would have even improved code, because there would be link-time parameter validation. You know why everyone hated the idea? Because then the compiler/linker couldn’t be single-pass. (groan) Compilation and link speed being mostly a problem of developers not knowing how to modularize code for incremental compilation and linking.
Just shoot me.
[* If you want to understand what I mean, ask one of the parser-writers how they back out what they allocated if a parse fails. “What? That doesn’t happen. The program exits so that’s not a problem.” Oh, really? What if the program doesn’t exit and tries to recover, re-enters the parser, and there’s a partially formed parse tree still in memory? ]
consciousness razor@#3:
People want to be users/consumers who don’t know about anything that happens inside of their magic box.
I agree. In a sense, the magic box is a data-hiding API. It hides how it works inside. You don’t have to know. You can depend on it because it’s magically dependable and it’s pointless to try to understand because it’s going to change anyway.
And then there’s the problem that nobody knows how it works. Your point about iPads is well taken. If the gestalt of the system is too complicated for anyone to understand, then the system is, by definition, a mysterious thingamajig. Got a memory leak? We may as well sacrifice a chicken, that might work.
Our API boundaries become human experts: memory allocation, that’s Fred’s problem. Ask Fred. If Fred doesn’t know, then nobody does.
consciousness razor@#2:
I know it’s a different set of problems in various ways, but several years ago, I quit using Finale and switched over to Lilypond for my music notation needs. Sort of like switching from Microsoft Word to emacs … well, sort of, I guess. The whole process from beginning to end is rather different, and it’s hard to even compare what I can do with it — the nice free software (not the expensive junk) is just plain brilliant at doing exactly what I want it to do, with no surprises. It took a little while to learn all of the ins and outs, but I’ve never looked back.
There are studies about the number of features people actually use in software, and the numbers are distressingly all over the place, so I don’t even know what they mean. Some things like MS-Office have huge feature-sets and you get a user like me who just uses basic Powerpoint because I learned on Powerpoint 1.0 and damn it that was good enough, stop adding features!
The free software movement and Linux seem to have adopted the Microsoft market model, which is more and more features. Rather than a carefully tailored set of features that do just exactly what you need. On the other hand, some of the free software has just exactly the set of features that get the job done. It’s complicated – nobody’s going to use your stuff if you don’t thoroughly solve their problem, but if you try to thoroughly solve everyone’s problems, you’ve got mission-creep and code-bloat.
[…] you’ve got mission-creep and code-bloat.
And you decide it’s a good idea to embed working spreadsheets into presentations, hell, let’s just embed everything into everything, because we already have applications for them, we just need them to talk to each other a bit, and how hard can that be?
What I’m getting at is that it hardly matters if your code is good. Your product is going to be full of bletcherous kludgy crap – whether it’s open source, or it’s from Oracle or Google or Microsoft – it’s pointless to try to make your code good, when it’s absorbing toxic bugs from literally everyplace.
Yes. That’s my main source of sadness here. Not that I could not sit back and take the time and write very good code (I’m no André Bensoussan, but I can try), but that the dependencies I need to bring in to write anything other than the most basic stuff will get me anyway.
Which is why I find myself enjoying writing code for small microcontrollers. Of course, we’re ruining that too: chips that can run an actual OS cost only pennies more, so why not use them? But if they can run an OS, they’re complex enough that they pretty much need that OS. My thing that was going to run the same event loop unerringly for the next decade will now have Wi-Fi, be part of a botnet within a week, and break when they next update the libraries.
On implementations of malloc/free where the free memory block-list is linked with a separate data structure, that works but on implementations written by hardware engineers, the memory blocks are used to store the pointers to the next free block, which means list = list->next is overwritten if the compiler likes to put the ‘next’ field at the beginning of the address space.
One thing I really liked about Microsoft’s compiler (or whoever wrote it initially, years ago, before Microsoft bought them) was that the debug runtime library kept all unused memory filled with known patterns. For example, malloc() would fill the just-allocated block with 0xCD, and free() would immediately fill the released memory with 0xDD. That would have caught this bug immediately. (There were also fences and a few other useful features of the debug heap manager.)
Yeah, I’m sure there’s a lot of variation in general. And probably, the story changes a lot depending on what type of software we’re talking about. I was just thinking to myself the other day (again) how nice it would be if my Windows calendar wasn’t such a useless piece of garbage. You’d think it would be a fairly simple thing and that most people would want the same basic features. But maybe not.
When it comes to making musical scores (not that you really care), I’m one of those people that wants lots of features … all of them, pretty much. And I expect the output to be perfect, not “good enough for government work” or whatever. Even if it would take a little more time/work to do something a certain way, I at least want the option available. One nice thing is that these “extra” features (with Lilypond) don’t really get in the way when they’re unused. You simply don’t make/use that particular bit of code, and the default settings (also under my control) will do what they do. The cost is learning to work this way in the first place, which admittedly is nothing to sneeze at. But if I’m bloating up my own code and/or expanding the scope of the mission (my own mission), then nobody else cares and there’s no creeping to worry about. The thing just has to be powerful enough to begin with, so that everybody can do their own thing without stepping on each other’s toes.
In contrast, a more “user-friendly” (scare quotes!) program like Finale is infested with all of these buttons and menus and whatnot, which constantly get in the way unless you’re actually using them. And the “default” state is not easy to change (if not impossible). The people who made it (MakeMusic Inc.) have to decide what Typical User wants, then decide how to implement that (with minimal work) in order to satisfy Typical User. It’s a very top-down sort of approach. And because of the way the software’s designed and the way people will have to use it (i.e., with little idea of how it works), adding more features for a few people does complicate things for everybody else: more buttons polluting your screen and confusing you, more gadgets that do crazy stuff you’d never want/need, functionality that is counterintuitive or mysterious, etc. All of the real work has to be hidden somehow under the surface, because the surface level (cartoons painted all over your monitor) has little or no relation to how the thing actually does what it does.
consciousness razor@#8:
When it comes to making musical scores (not that you really care)
I don’t understand – that’s very different from “I don’t care“! *
I’m actually generally interested in just about anything and everything. So I am always happy to learn about new things, which is why I appreciate your comment.
We take from everything what we choose, and that’s usually what we understand, it seems to me. So your comment increases (from near zero) my knowledge about musical notation, but it also gives me things to think about regarding a problem that is near and dear to me: the question of what features make sense in software, and how we might figure that out.
I used to work for a fellow whose design approach to software/systems was very different from mine. His emphasis was on being extremely adequate. That’s my characterization, though I doubt he’d disagree with it very much. He was never interested in breaking new ground or making great leaps of innovation, he was all about producing what the customer was willing to pay for. This drove me completely nuts because often what a customer wants is not what they need because they don’t understand the problem. But his approach was much more commercially viable. On the other hand, I felt that he left behind unsatisfied customers who, having asked for something that didn’t actually solve their problem, found their problem unsolved, their budget expended, and a bunch of software running that they shut off after their understanding of their problem improved.
(* my mom spent decades studying musical notation in French court music, so I heard a lot about that topic over the years. Being non-musical, I thought of it as a problem in specification versus interpretation, which is an interesting and important topic indeed.)
Sure. I didn’t mean to count you as one of those people. You’re alright.
What I meant is that it’s kind of an arbitrary choice, in that it’s just a matter of printing/displaying some 2D graphics, like a word document or a web page or what have you…. So you don’t really need to care (even if you do) about the particulars of music notation, interesting though they may be. Perhaps I should’ve chosen an example that’s more familiar. But then again, maybe the familiarity of the others is part of what misleads some people into thinking they already know how it must be, or what must happen if there are lots of features or applications or something to that effect.
Maybe this is getting too meta, but “Western” notation is sort of a strange thing. It was designed (over many centuries) to be a way to give human performers instructions, in a visual format. The composer/arranger is sort of wearing the hats of an architect as well as a construction foreman. “You do this at this time, you do that at that time, etc.” You don’t verbally tell people what’s what, and they’re not imitating a good performance which they learn by ear — it’s a visual representation, sort of like an instruction manual, that any (musically) literate person can “read.” Of course, all kinds of insanely complicated stuff happens in music, which can generally be represented in a stupidly large number of different ways, so this isn’t nearly as simple as I’m making it sound.
Getting to the point…. Every so often, someone (typically people just starting to learn about the subject) will get themselves all mixed up about peculiar features of this style of representation (which are only present due to countless historical accidents), as if this were how a person does music theory. They take it far too realistically. But it certainly doesn’t explain how people hear what they hear, and in general it’s not directly related to any of the mathematical properties of harmonies, rhythms, forms, etc. It’s just a picture that performers are using to do their jobs, and you could definitely present them with all sorts of other pictures (or non-pictures for that matter) that would let them do their jobs just the same. As far as the theory goes, what that looks like is totally irrelevant. We’ve got math and psychoacoustics and so forth, which actually tell us all about those things, and the specific things you see when you look at a score have essentially nothing to do with it. But it can be awfully tempting to cross the streams. Don’t cross the streams.
I had always envisioned the internet like this: A person has a meal. They eat it off a plate. But it’s too hard to wash up, so when they get hungry again they just put a clean plate on top of the old one. Pretty soon that is a teetering stack of plates and not only that it’s inconvenient to eat off them that high, so they stack a stool on top of the original stool. Soon you have a teetering stack of stools next to the teetering stack of plates.
But I like the idea better of a thing that changes all the time, almost like a living organism does. And how depressing to think you can never fix things because the environment keeps changing. Guess we’ll find out what that’s like in real life here on Earth.
This post makes very clear to me why I’ve found so many things on the internet hard to grasp. I mean, why should code *change*? Well, I guess it just got updated. Now I understand at least that tiny bit. Not much else but at least that.
I generally look for very specific things but I do know that most people will buy things that have multiple uses, even though they are not going to use them. If I want a pocket knife, that’s all I want. I don’t also want a corkscrew, screwdriver, saw, pliers, awl, compass and flashlight. But I know I’m weird, and everyone else is normal, so I know there is a huge market for a “pocket knife” that does all that other stuff too.
My example is going to be about graphic design software. I’ll start by saying that I absolutely hate Microsoft Office. After I learned how to use CorelDRAW, I never wanted to even open PowerPoint ever again. The difference is that CorelDRAW has well made basic tools that can be used to make literally anything. PowerPoint is the exact opposite—it has a sky-high number of features, but ultimately it is impossible to use any of them in order to make my graphic design look exactly as I want it to look like. (I’m still using a very old version of CorelDRAW, so I have no idea whether the newer versions have introduced any additional features, I’m talking about my over 10 years old version in these examples I’m going to give now).
If I need to make a page with several text columns, in CorelDRAW I will use the rectangle tool and the text box tool (in CorelDRAW textboxes can be linked together to have text flow from the first one to the next). Both of these tools are well made, and with them I can place my columns exactly where and how I want them to be. My ability to customize my layout is literally endless. Compare that with Microsoft Office, where the basic tools suck (yes, I know that the rectangle tool and the text box tool exist, but they suck compared to how they work in CorelDRAW). I cannot precisely set the exact size or location of my text columns. I cannot even make any unusual arrangements regarding where I want each text column to be located. Instead I’m forced to pick one of the templates, and then the program will create text columns for me. What I’m trying to show with this example is that I want well made basic tools that allow me to make literally anything. I don’t want a feature that forces me to choose one of the templates.
Now, to answer your question about what features I want, let’s start with basic tools. They have to be well made and the user must be able to make anything with them. I assume you aren’t very familiar with graphic design software like CorelDRAW, but Photoshop is actually very similar in this aspect—you can make immense amount of image editing only with the very basic tools.
Next, on to what “advanced features” I’d actually like having. They have to be one of those:
1) the feature allows me to do something that couldn’t be done with the basic tools;
2) the feature significantly shortens the amount of time that I have to spend doing some image manipulation.
The problem with advanced features is that what they can do is limited, they aren’t that versatile, they don’t let me make literally any image.
“Insert WordArt” in PowerPoint is an example of what I consider a useless feature. It forces me to pick one of the templates and thus I’m severely limited in how my finished fancy text can look like. I prefer to use CorelDRAW’s basic tools instead. In CorelDRAW I can pick any font, make it wider or narrower, move letters around, pick a different size for each letter, make various outlines, separately pick colors for each element, utilize transparency or shadow effects, bend letters, move around points in order to edit the curves of each letter separately, create a pseudo 3D effect by duplicating letters and choosing specific color gradients. . . The possibilities of what I can do with some text in CorelDRAW are literally endless. It would take me less than a minute to create some fancy looking text in CorelDRAW that looks a lot better than any of PowerPoint’s WordArt templates.
Now, an example of a useful feature—let’s assume I have taken two overlapping photos and I want to merge them together in order to create a panorama. In Photoshop there’s the “Photomerge” feature. I could merge two images manually, but it takes a bit of time (put both images in the same file, align and rotate them, create a layer mask in order to erase parts of the images in order to create a fluid transition). Simply clicking on “Photomerge” is a lot faster, so I appreciate the feature even though I could live without it.
Of course, there are also plenty of useful features that allow me to achieve various useful visual effects that couldn’t be done in any other way by using just the basic tools. I appreciate having those features as well.
Whenever some product is made with the assumption that the user will be a moron, the result usually tends to be something that’s extremely annoying for me to use.
Let’s start with the fact that not all users are the same—some are more educated and really know what they need while others have no clue about that. I feel like most businesses create their products thinking about the idiot user who will have no clue what they need. Hence they create a product that they assume the idiot user will want. Other users who actually know what they need are bound to get annoyed.
Same goes for me. I don’t really mind additional (for me useless) features as long as they don’t take up space or cause any other drawbacks, but that’s usually not the case. For example, the very first pocket knife I owned was one of those multi tools (I was a kid, and I had to use whatever adults gave me). The blade was the only thing I ever used. My pocket knife was huge, bulky and heavy (after all, it had to fit in all those other tools), simultaneously the blade itself had to be pretty small in order to leave more space for all those other tools. The moment I finally had some money of my own I bought a better pocket knife for myself—one that was lighter, less bulky and had a larger and better blade (and no other tools). Regarding software, often the problem is that all those extra tools and features take up space on the screen and the user cannot hide them. However, even when it’s possible to remove all the unnecessary icons out of my sight, the feature might still cause my computer/phone to waste its RAM and processing power. Never mind the fact that a useless feature can be also a security risk that might allow hackers to utilize some vulnerability it has. And, yes, as you might have already guessed, I am one of those people who are annoyed by the fact that you are not allowed to uninstall useless apps from your phone without rooting it and voiding the warranty. Anyway, theoretically, if some extra feature had no drawbacks and it didn’t disturb me in any way, I wouldn’t mind having it.
I generally look for very specific things but I do know that most people will buy things that have multiple uses, even though they are not going to use them. If I want a pocket knife, that’s all I want.
Multi-tools are for, to put it politely, extremely casual users. People who actually use the tools prefer separate, dedicated tools in most cases.
This can be as basic as the screwdriver with interchangeable bits: ignoring the useless ratchet types you can buy for a dollar or two, even a well-made handle that takes standard bits will be much thicker, and often shorter, than an individual screwdriver of pretty much any common type. Depending on what you do with it, this may be fine, but sometimes it won’t be — so you want the individual screwdrivers for the head types you encounter most. In many cases, you won’t need the “universal” screwdriver at all. (Also, who is the idiot who decides to include Phillips but not Pozidriv screwdrivers in sets? 95% of cross-head screws you find doing DIY around the house are Pozi, not Phillips. Best way to strip a PZ screw? Use a PH screwdriver.)
Or take Marcus: a casual, average user would own one angle grinder and would swap in whatever tool they needed at the moment. Marcus, being neither casual nor average, has several angle grinders, each with a tool he uses frequently.
This is exactly why I have a real bad case of “not invented here”… I hate external dependencies – I’ve been through the lifecycle enough times to know how that works out. Core runtime libraries (yeah, I know, don’t start) only and I’ll write everything else myself. Sure, I could just import a NuGet package to do whatever, but I fucking know it’s going to break, or go out of support, or turn out to be riddled with really obvious SQL injection vulns… Been there, done that.
The next website I put together will be 100% my own hand-cranked code. When I can face it… Meantime, I need to peen my scythe blades.
@consciousness razor: I know nothing about music notation, but I was idly wondering if Lilypond could be used to reproduce the more outré works of John Stump. Of course, it may not be safe for your sanity to make the attempt.
Owlmirror. Yes. But they’re impossible to perform, of course — not even by computers or whatever. I mean physically impossible, because (if I’m interpreting correctly) time travel is occasionally required, among other things.
Really, notation* is just kind of a specialty, since it has various tools designed to handle that. And I should mention it can output MIDI as well. But it works pretty nicely for other sorts of graphic design work too. It can for instance use Postscript code (as well as Scheme), so anything involving that is possible.
*Including things other than “standard” Western notation … ancient stuff, Arabic stuff, Schenker diagrams and other analytical/educational stuff, graphical scores, guitar/bass tabs, and so forth. But it goes beyond all of that, if you’re already counting those as “notation.”