1. 2

    I believe all the programmer stuff here just confuses. Mathematics are a lot better way to approach matrices even with programming. Just plain type theory brings you a good starting point to matrix multiplication. The type for matrix multiplication resembles function composition:

    (*) : forall x y z. Matrix x y -> Matrix y z -> Matrix x z
    

    This because it’s a linear transformations of items from one bunch of numbers to another bunch of numbers, it’s technically a certain kind of a subclass of a function.

    1. 2

      It doesn’t resemble function composition, it is function composition. Every matrix A is isomorphic to a linear function a, and AB ≅ a ∘ b.

    1. 1

      So they’re looking to replace BSD/POSIX socket API with something else. Outright this sounds bad because it would mean all software need to be patched afterwards.

      There’s more on Reo coordination language. Then there’s the api.

      It looks like interesting and I’ll perhaps read more into this later. It actually kind of looks like it’d make sense.

      1. 2

        A compatibility layer for applications using the socket API can use connectors underneath. But then the application cannot use the benefits of connectors, such as connecting with multiple peers and gathering session information.

      1. 2

        I recently tried haskell-language-server and overall I liked using it. From now on I regularly use it when programming Haskell.

        There’s a feature, I do not know if already present, but I’d really like to be able to expand cases. Example:

        matchByText :: Node -> Maybe String
        matchByText s = _
        

        I’d like to set cursor on s, then tell editor to expand this case and retrieve this:

        matchByText :: Node -> Maybe String
        matchByText (Element _ _ _) = _
        matchByText (Text _) = _
        

        That I could then fill up to my liking.

        1. 2

          That feature is advertised in 0.5.0 released a few days ago.

          Check out the cool animations! https://github.com/haskell/haskell-language-server/releases/tag/0.5.0

          1. 2

            Then it goes to install right away!

            Now I’m just wondering how do I access the case splitting from LanguageClient-neovim plugin?

          2. 1

            I believe that’s one of the features mentioned in this article as something that’s coming.

          1. 6

            If you want a really good user interface then give it modes like how Vim has them.

            This is the first thing they told me NOT to do when doing GUIs at university. In fact, it is said that Ctrl-C/Ctrl-V is so popular, because it’s modeless. I think there’s actual research that shows that modes in GUIs are bad, for various reasons but it’s been a while since I studied HCI.

            1. 3

              That’s what I’ve read, too, especially in Jef Raskin’s The Human Interface. I suspect the copy/paste work was from Larry Tesler, who reportedly had “NOMODES” on his license plate?

              That all said, I definitely see that all the software I use actually has quite a few modes…and, when trying to make software for people, people tend to like having modes (at some level) to “guide” them around a process. Is that because they don’t want to spend the time learning a new interface as compared to something that is familiar? Or because of a different valuations between long-term efficiency as compared to the initial learning curve? I don’t know. :-)

              Out of curiosity, from when you did study HCI, do you have any recommended texts or resources?

              1. 3

                Maybe the disrepancy here is due to how a broad concept a mode is. I believe the problems are there. Wikipedia has a section about mode errors in user interfaces.

                There’s certain kind of behavior that is terrible, but it’s not entirely captured by vilifying modes (well, if we’re precise then it is though).

                1. Notification pops up when you’re trying to do something and you click the notification away accidentally, while also messing up whatever you were doing.
                2. Something steals the focus while you’re writing a command.
                3. A prompt grays off everything else in front of you, the answer causes an irreversible change, but to answer it you’d have to look up something first.

                I’d be quite furious if Vim abruptly shifted --INSERT-- to --VISUAL-- when I’m typing text. That has never happened though.

                So maybe the rules of good modes can be captured in this way:

                1. The mode changes immediately upon an user request of mode change.
                2. The mode never changes due to an external action.
                3. The mode always displays itself properly.
                4. The mode change is an irreversible action in itself.
                5. The volatile internal state that is destroyed on exit from the mode is identifiable for the user.

                I’d think this may be good enough to be added there into the post. What do you think?

              1. 9

                It really bugs me that things like this continue to perpetuate the idea that web is the only kind of development. “Frontend” and “Backend” are not the only two categories of development, and continuing to perpetuate this idea is causing far too many people to focus on moving everything to the web, because they can’t see outside of the narrow sliver of the breadth of technology. I wish we could acknowledge that the web isn’t, and shouldn’t be, the end-all be-all of software development or technology delivery.

                1. 2

                  I think that is because the majority of user-facing applications are web based. It seems to me like web-based software is just the most reliable, simple, and cross-platform way to deliver content. Because there are so many use cases, it has accumulated a lot of depth and knowledge, making guides like these necessary. It could also be a cultural thing - low level stuff, like kernels, operating systems, etc., have a culture formed around them of “just read the manual”.

                  I’m curious what other technology / kind of development you think could use a roadmap. My personal interest is in PLT+formal methods, but I guess I’m early enough in my learning that I can’t imagine a roadmap as large as the ones presented in the original submission. Maybe embedded development? Database systems?

                  1. 3

                    My interest is in PLT as well, and I think that there’s actually quite a huge opportunity for a roadmap there. I know that as an autodidact in PLT I’d have loved a structured roadmap for how to understand type systems, category theory, compiler design, etc. I’ve seen roadmaps like this for data science; I bet you could also create them for mobile development, security, devops, game development, or just about any pursuit. Almost all fields these days are built on a large amount of prior work and any time there’s a lot of prior work I think creating a pedagogical ordering for people to pick up concepts can be helpful.

                    1. 2

                      Hi Rebecca, I haven’t thought about a roadmap, but I’m planning to build up a structured sitemap for boxbase blogposts and eventually extend to articles that cover things you mentioned, type systems, category theory, compiler design. I think it’ll come with the next upgrade on the site. Sometime next month when I think I’m ready to do that.

                      If there’s some related subject I could cover that you immediately need, I’d appreciate to know.

                      1. 2

                        That sounds like a great roadmap! It would be really great if there was something that covered the path to modern type systems from like the typed lambda calculus and denotional semantics through systemF and then concluded with something like homotopy type theory. I know that I’ve struggled to get through all the literature on cubical type theory because there’s a bit of math and some more recent work that I’ve not been quite sure what the right order to pick it up is.

                1. 1

                  I’m using Idris for some programming language research, I’m glad Idris2 is getting along because it’s a much faster implementation.

                  1. 1

                    It’d be time for a new keyboard standard. Split keyboards are incredibly useful, but there is bit of a disagreement how their layout should be oriented. Also I find location and modern use of modifier keys an atrocious design. Ctrl+something to run a command, why? Ctrl+Alt+Something, what? Who made this up and who still keeps this up?

                    Plus, who’s trying to remove the esc-key from the keyboard?

                    1. 2

                      I’m writing a response to this post right now. It’s longer so I’ll put it into my blog.

                      The last one I did send here ended up being merged on without a bump-up on the original post. I guess the same happens now and the thread will be buried 4 pages down the board before I’m ready to send it.

                      But I guess I’ll send it in anyway.

                      1. 2

                        I’d be curious what you think of this talk.

                        It includes clips of interviews from decades ago from some of the originators of OOP as we know it today, talking about what their goals were and how they aimed to achieve them.

                        https://youtu.be/6YbK8o9rZfI

                        1. 2

                          There’s that thing again.. It’s more of a wording issue but eventually translates into a thinking issue. Functional programming doesn’t erase or “remove” side effects. It just separates side effects from reduction rules.

                          Also after I watched this video and thought on it a bit, a question arose: Is the modern stuff OOP at all? Has the definition been extended to cover every use of class-like structures?

                        1. 5

                          Just gonna take one potshot at the new merged article:

                          Are you sure about polymorphism? First of all you took it from type theory and that’s itself getting popular featuring stable forms of parametric polymorphism, while your version of polymorphism is shifting shape like crazy.

                          You have it backwards. ML cited CLU’s type system as inspiration, which cited SIMULA as inspiration. Parametric polymorphism may be more elegant in typed FP, but from a historical engineering perspective it migrated from OOP to FP.

                          1. 1

                            Type theory itself is older than either ML or Simula, but it’s worthwhile to add this in. I’ll put a note in there sometime soon.

                          1. 1

                            I used to really hype over MLsub but eventually moved on to hype over type theory and category theory. The MLsub inference algorithm was indeed quite complex. I guess I’ll take a look at this and review the paper in my blog.

                            MLsub is still interesting but for a different reason though. When I’m coding Idris or Haskell, awful often it seems like everything should be a typeclass. This is also presenting up in category theory. Adjoint functors seem to form “arguments” that introduce evaluation rules as well, resembling typeclasses. MLsub constraints resemble typeclasses.

                            1. 8

                              Gets it wrong. Title ends up being ironical as the concept is buried into bunch of rustica.

                              Wadler’s paper doesn’t explain much of what a monad is. He shows that it can be used for sequencing side effects in a functional programming language.

                              Monad is a functor with two natural transformations that are coherent in a certain way.

                              The text entirely misses the idea that it’s a functor.

                              1. 9

                                So IDEs are merging with compilers? Just 2 days ago I wrote about similar stuff, except in context of compilers and build systems. Olle Fredriksson wrote about query based compilers before that.

                                1. 3

                                  Seems queryable AST idea become a trend recently. There is another article the other day: https://nshipster.com/as-we-may-code/ Curious what drives the explosion of these thoughts.

                                1. 1

                                  I think it’s nonsense. It confuses abstraction and organization.

                                  Abstractions select details you are treating. Shifting volume of a sphere into a function is not abstraction because you still care about what the formula is.

                                  The same repeats in the “bloated method”. It reorganizes things but details do not change, nothing is abstracted away.

                                  “Awkward class”, same thing. Still talking about shapes but splits classes. Code is reorganized, not changing abstraction.

                                  The final example is just different expansions of the same thing. It’s like dung beetle rolling pieces around. The “pushback in a PR review” feels like a cherry on top. This is silly.

                                  1. 2

                                    I think you might be taking the definition of abstraction to be a bit different than what is intended. Note that “lambda abstraction” is a technical term, and is the primary approach to building “Abstractions” in code.

                                    Yes, this is all just code reorganization. The important point is that some of it is helpful for maintaining code, while some of it is detrimental. In my opinion, this blog post does a wonderful job of providing insight into when and why you should use “abstraction”, and, more importantly, when and why you should not.

                                  1. 3

                                    The premise in the post is good but functional promoting posts are almost always silly. This one isn’t an exception.

                                    You got this misconception that functional programming is about maintaining state. The people then answer to you that state is needed anyway. But that’s not the point because this maintaining state -viewpoint kind of misses the point because it’s too narrow.

                                    Types encode the known behavior of the program. If we take the recipe example in this thing, your type might be:

                                    2 eggs 
                                    ⊸ 2 cups flour
                                    ⊸ Oven heated at 400F degrees
                                    ⊸ kitchen equipment
                                    ⊸ 60 minutes
                                    ⊸ (10 cupcakes ⊗ oven ⊗ kitchen equipment)
                                    

                                    The proof would contain the recipe, the strategy you use to produce 10 cupcakes and not lose the oven and your other equipment. You use the logic-correspondence of the types to present the problem. For convenience I used linear types here because it’s a kitchen recipe. I assumed your tools don’t break when you use them.

                                    Now consider how much easier it’s to navigate through a program where it’s explicit what we are expecting from it, and written such that the program cannot violate the expectations, at least not completely?

                                    Of course this means you need pure and typed, and maybe even non-turing complete language, but I think functional as-it is just hype.

                                    1. 3

                                      Hmmm. As someone with zero professional functional programming experience, I thought the post was pretty good at explaining why I might be interested in learning more about the paradigm.

                                      To be honest, I am not sure I understand your comment–some of the terms are new to me :) .

                                    1. 0

                                      Going back to using typed languages is a downgrade from Python if you don’t have knowledge about dependent typing.

                                      Also if your language enforces compile from scratch/run cycle, it sucks just like Python sucks when it does that, precisely because it’s interpreted but not properly typed language.

                                      1. 9

                                        Great news! I am eager to try this!

                                        Turn on -XLinearTypes, and the first thing you will notice, probably, is that the error messages are typically unhelpful: you will get typing errors saying that you promised to use a variable linearly, but didn’t. How hasn’t it been used linearly? Well, it’s for you to puzzle out. And while what went wrong is sometimes egregiously obvious, it can often be tricky to figure the mistake out.

                                        So, basically, GHC just got its own “Syntax error” a la OCaml… just a bit more specialized :p.

                                        1. 11

                                          Maybe it’s just me, but to me OCaml’s errors are terse and unhelpful and GHC’s errors are… verbose and unhelpful. ;)

                                          There are interesting papers that show working ways to improve both, but I wonder why none of those improvements are in the mainline compilers.

                                          1. 2

                                            Good error reporting is easiest if it’s built into the compiler front end from the start. If a new algorithm comes along to improve the error information it’s almost never going to be a simple job to drop it into an existing compiler.

                                            You need type information & parse information from code that’s potentially incorrect in both spaces, so any error algorithm usually has to be tightly integrated into both parts of the compiler front end. That tight integration usually means that improving compiler errors is a significant amount of work.

                                            1. 3

                                              It varies. What puzzles me is that a lot of time ready to use, mergeable patches take much longer to merge than they should.

                                              Like this talk: https://ocaml.org/meetings/ocaml/2014/chargueraud-slides.pdf

                                              1. 1

                                                Do you also have a link for a patch for the improved error messages?

                                                A lot of work has been going on to move OCaml to a new parser and improve error messages. Even though there is a lot still needed to be done, latest releases have started improving a lot. Maybe we can still extract some useful bits from that effort and try again

                                                1. 2

                                                  Turns out it was even made into a pull request that isn’t merged yet: https://github.com/ocaml/ocaml/pull/102

                                                  1. 1

                                                    Thanks. It is quite an informative PR actually, and explains why the change is not there yet and once can infer why it is easier to add informative messages in new languages and complier but it may be quite hard to retrofit them to seasoned ones

                                          2. 7

                                            Would you be kind enough to give me an ELI5 about what linear types are and what you can do with them?

                                            1. 29

                                              In logic, normal implication like A implies B means whenever you have A, you can derive B. You have tautologies like “A implies (A and A)” meaning you can always infinitely duplicate your premises.

                                              Linear implication is a different notion where deriving B from A “consumes” A. So “A linearly implies B” is a rule that exchanges A for B. It’s not a tautology that “A linearly implies (A and A).”

                                              The classic example is you can’t say that “$3 implies a cup of coffee” but “$3 linearly implies a cup of coffee” makes sense. So it’s a logical form that reasons about resources that can be consumed and exchanged.

                                              Same in functional programming. A linear function from type A to type B is one that consumes an A value and produces a B value. If you use it once with an A value then you can’t use it again with the same A value.

                                              This is nice for some performance guarantees, but also for encoding safety properties like “a stream can only be read once” etc.

                                              1. 6

                                                Keynote: Linear Haskell: Practical Linearity in a Higher-Order Polymorphic Language https://skillsmatter.com/skillscasts/11067-keynote-linear-haskell-practical-linearity-in-a-higher-order-polymorphic-language

                                                1. 5

                                                  It can be used to model protocols with type signatures. The following is in theory what you should be able to do.

                                                  data ConsoleInput
                                                      = Input String ConsoleOutput
                                                      | ExitInput
                                                  
                                                  data ConsoleOutput
                                                      = PrintLines ([String] ⊸ Console)
                                                      & PrintLastLines ([String] ⊸ ())
                                                  
                                                  greet :: ConsoleOutput ⊸ ()
                                                  greet console
                                                      = let PrintLines f = console
                                                        in step2 (f ["name?"])
                                                  
                                                  step2 :: ConsoleInput ⊸ ()
                                                  step2 ExitInput = ()
                                                  step2 (Input input console)
                                                      = let PrintLastLines f = console
                                                        in f ["hello " ++ input]
                                                  

                                                  If you combine it with continuation passing style, you get classical linear logic and it’s a bit more convenient to use.

                                                  If you model user interfaces with types, they should be quite useful.

                                                  I’m also examining and studying them: http://boxbase.org/entries/2020/jun/15/linear-continuations/

                                                  1. 1

                                                    Wikipedia gives a reasonable overview. The closest analogy would be something like move semantics – for example ownership in Rust can be considered as manifestation of linear types.

                                                    1. 6

                                                      Rust ownership is linear affine types. Linear types are similar but differ in the details. A shitty way of understanding it is affine types mimic ref counting and prevent you from having a ref count < 0. Linear types are more a way of acting like RAII in that you might create a resource but just “know” that someone later on in the chain does the cleanup.

                                                      Which I’m sure sounds similar but affine types allow for things like resource leaks but linear types should guarantee overall behavior to prevent it.

                                                      This all assumes my understanding and explanation is apt. I’m avoiding a ton of math and i’m sure the shitty analogy doesn’t hold up but behaviorally this is how I have it in my brain.

                                                      1. 2

                                                        Linearity Design Space: https://i.imgur.com/s0Mxhcr.png

                                                        1. 2

                                                          I’m personally of the stance that the 2020 linear ghc stuff is more <= 1 usage, and kinda misses out on a lot of really fun expressivity that can fall out of making full classical linear logic first class. But that’s a long discussion in its own right , and I’ve yet to make the time to figure out the right educational exposition on that front

                                                          1. 1

                                                            it definitely seems more limited in scope/ambition compared to the effort ongoing for dependent types, for better or worse. Can’t say I know much about what first class linear logic would look like, but perhaps now there will be more discussion about such things.

                                                            1. 2

                                                              The really amazing thing about full linear logic is it’s really sortah a rich way to just do mathematical modelling where everything has a really nice duality. The whole thing about linearity isn’t the crown jewel (though wonderfully useful for many applications ), it’s that you get a fully symmetric bag of dualities for every type / thing you can model.

                                                              The paper that really made it click for me was mike shulmans linear logic for constructive mathematics paper. It’s just a fun meaty read even at a conceptual level. There’s a lot of other work by him and other folks that taken together just point to it being a nice setting for formal modelling and perhaps foundations of category theory style tools too!

                                                          2. 1

                                                            Not sure I can agree that Uniqueness types are the same as Linear types. Care to explain they’re similar sure but not the same thing and your… screenshot of a powerpoint? isn’t very illustrative of whatever point you’re trying to make here.

                                                            And from my experience with Idris, I’m not sure I’d call what Rust has Uniqueness types.

                                                            1. 1

                                                              They are different rows in the matrix because they are different, of course.

                                                              it’s from this presentation about progress on linear ghc a little over a year ago https://lobste.rs/s/lc20e3/linear_types_are_merged_ghc#c_2xp2dx skip to 56:00

                                                              What is meant by Uniqueness types here is “i can guarantee that this function gets the unique ptr to a piece of memory” https://i.imgur.com/oJpN4eN.png

                                                    2. 2

                                                      Am I the only one thinking this is not how you ship language features?

                                                      If the compiler can’t even report errors correctly, the feature shouldn’t ship.

                                                      1. 15

                                                        If the compiler can’t even report errors correctly, the feature shouldn’t ship.

                                                        Its more this is an opt-in feature with crappy error reporting for now using computer programming design features not in use in most programming languages. Its going to have rough edges. If we required everything to be perfect we’d never have anything improved. Linear types like this also might not have a great way to demonstrate errors, or the domain is new so why not ship the feature for use and figure out what kind of error reporting you want based on feedback.

                                                        1. 13

                                                          Many people do not realize that haskell is a research language and GHC is one of the main compilers for it. This is an experimental feature in a research language. If it works out well, then it will be standardized.

                                                        2. 5

                                                          Other people have sort-of said it, but not clearly enough I think. This is not a language feature being added. It is a feature-flagged experimental feature of a particular compiler. Most such compiler extensions never make it into real Haskell, and the ones that do take years after they are added to a compiler to make it to a language spec.

                                                          1. 4

                                                            for all practical purposes isn’t “real Haskell” defined by what ghc implements these days?

                                                            1. 2

                                                              Yes, all the other implementations are dead. They still work, but they won’t run most modern Haskell code, which usually uses a bunch of GHC extensions.

                                                              1. 1

                                                                You might say “isn’t it not popular to write standards-compliant Haskell these days?” and you’d be right. Of course it’s often trendy to write nonstandard C (using, say, GNU extensions) or nonstandard HTML/JavaScript. However, ignoring the standard being trendy doesn’t mean the standard doesn’t exist, or even that it isn’t useful. I always make sure my Haskell is Haskell2010, and I try to avoid dependencies that use egregious extensions.

                                                              2. 2

                                                                Honestly curious: are there any other Haskell compilers out there? Are they used in production?

                                                                Also, what is a definition of a true Haskell? I always thought it’s what’s in GHC.

                                                                1. 5

                                                                  There’s a Haskell which runs on the JVM - Frege. But it makes no attempt to be compatible with the version of Haskell that GHC impements, for good reasons. Hugs is a Haskell interpreter (very out of date now, but still works fine for learning about Haskell.) There a bunch of other Haskell compilers, mostly research works that are now no longer in development - jhc, nhc98 etc etc.

                                                                  But GHC is the dominant Haskell compiler by far. I don’t think there are any others in active development, apart from Frege, which isn’t interested in being compatible with GHC.

                                                                  (“True Haskell” is the Haskell defined in the Haskell Report, but real world Haskell is the Haskell defined by what GHC + your choice of extensions accepts.)

                                                                  1. 2

                                                                    There are other compilers and interpreters. None of them is anywhere near as popular as GHC, and usually when one does something interesting GHC consumes the interesting parts.

                                                                    There is definitely a standard, though: https://www.haskell.org/onlinereport/haskell2010/

                                                                    The whole reason language extensions are called “extensions” and require a magic pragma to turn on is that they are not features of the core language (Haskell) but experimental features of the compiler in question.

                                                                  2. 1

                                                                    In short, GHC Haskell is a language designed by survival-of-the-fittest.

                                                                    1. -2

                                                                      If you haven’t noticed, the language spec is dead.

                                                                    2. 3

                                                                      Overly terse error messages are bad, but they are better than wrong error messages. Some things are much harder to give helpful error messages for than others.

                                                                      I wish people spend more time improving error reporting, at least in cases when the way to do it is well understood. There is no reason for say TOML or JSON parsers to just say “Syntax error”. But, YAML parsers are pretty much doomed to give unhelpful errors just because the language syntax is ambiguous by design.

                                                                      And then some errors are only helpful because we know what their mean. Consider a simple example:

                                                                      Prelude> 42 + "hello world"
                                                                      
                                                                      <interactive>:1:1: error:
                                                                          • No instance for (Num [Char]) arising from a use of ‘+’
                                                                          • In the expression: 42 + "hello world"
                                                                            In an equation for ‘it’: it = 42 + "hello world"
                                                                      

                                                                      How helpful is it to a person not yet familiar with type classes? Well, it just isn’t. It’s not helping the reader to learn anything about type classes either.

                                                                      1. 1

                                                                        I’ve seen some good suggestions on r/haskell for improving the wording of these errors.

                                                                      2. 2

                                                                        The error they’re talking about is a kind of type error they’ve not worked with. It’s produced if you forget to construct or use a structure. I I’m guessing it’s technically “proper” but the produced error message may be difficult to interpret.

                                                                        They’ve ensured it’s a feature you can entirely ignore if you want to. Everybody’s not convinced they need this.

                                                                        I otherwise dunno what they’re doing and I’m scratching my head at the message. Something like “Oh cool you’ve done this… … … So where are the types?”

                                                                        1. 2

                                                                          So you never got a C++ template error in the good olden days? Seriously though, it just got merged. It’s not released or “shipped” in any means.

                                                                          1. 0

                                                                            So you never got a C++ template error in the good olden days?

                                                                            No, because I looked at the language, figured out that the people involved completely lost their fucking mind, and moved on.

                                                                            Seriously though, it just got merged. It’s not released or “shipped” in any means.

                                                                            They took 4 years to arrive at the current state, which I’ll approximate at roughly 10% done (impl unfinished, spec has unresolved questions, documentation doesn’t really seem to exist, IDE support not even on the radar).

                                                                            So if you assume that there will be a Haskell version in the next 36 years, then this thing is going to end up in some Haskell release sooner or later.

                                                                            1. 2

                                                                              So if you assume that there will be a Haskell version in the next 36 years, then this thing is going to end up in some Haskell release sooner or later.

                                                                              Could you elaborate on this? If practical users of linear types will only use them if they have good error messages, and early testers want to work out the kinks now, what’s wrong with having a half-baked linear types feature with no error messages permanently enshrined in GHC 8.12?

                                                                      1. 4

                                                                        Could you throw some sack on Lever? This is author’s request, you will be welcome to do that.

                                                                        1. 2

                                                                          I can try!

                                                                        1. 27

                                                                          I am a very vocal person about systemd.

                                                                          With that said, I find the articles opening statements to be quite fair in all regards- However, it does seem to fall right into the trap of comparing systemd with sysvinit.

                                                                          Without fail whenever someone extolls virtues and waxes poetic on the subject of systemd being “easy” it is always with the preconceived notion that sysvinit was the alternative.

                                                                          My typical argument against systemd is precisely in that it’s so complex and ever changing as to be effectively a closed system; integration with systemd specifics ensures that there can never be a successor, we are locked in to systemd forever more. So it had better be damned near perfect architecturally; and given the compromises and nature of exploits I do not have faith that it is.

                                                                          evidenced by the lengthy but great run down of the events surrounding systemd and the recent system-down exploit.

                                                                          There were alternatives; runit being a good example, but now swapping out your init for any other will cause many bits of useful software (notably gnome, but more as time goes on) to no longer work.

                                                                          1. 13

                                                                            Even without comparing it with anything. What valid reason is there to increase the scope of what is generally percieved as an init system by some 1000%?

                                                                            I, like most people, like being able to define services just by creating a 4 line unit file rather than having those silly ad hoc old init scripts. But why not doing just that? Why do I all of the sudden need an application just to check logs?

                                                                            1. 6

                                                                              Counterpoint: with systemd the logs are now collected in a pretty consistent way instead of spread eccentrically around /var/log. I find it convenient that I don’t need to define what my logfiles are going to be called or what rotation will occur, etc. Those aren’t interesting problems to me.

                                                                              1. 5

                                                                                the logs are now collected in a pretty consistent way

                                                                                Few adjectives are missing: error-prone, inefficient, insecure. You can insert them after pretty and then your sentence is 100% spot on.

                                                                                Links:

                                                                                If you ask me if I want to trade the previous logging stack to this, I would say no.

                                                                                1. 3

                                                                                  That’s your prerogative. I have not experienced any of those issues but have experienced issues with the traditional approach. In any case, all systems have faults.

                                                                            2. 7

                                                                              Most likely a system such as systemd is not correct or even possible to implement correctly because they’re not doing any formal verification to ensure every D-bus component conforms to their agreed upon interface.

                                                                              I’m just waiting for a cardhouse to fall.

                                                                              1. 2

                                                                                many bits of software, you mean

                                                                                1. 1

                                                                                  Did any distros actually use runit?

                                                                                  I used daemontools for a tiny project for awhile, and while it’s very elegant, I got the sense that you were also swimming upstream. It was more a thing I used on top of a distro (on top of sysv init or systemd), not really a replacement.

                                                                                  I don’t know the details but I’d hope and expect that the projects that integrate with systemd would accept patches for non systemd inits.

                                                                                  1. 8

                                                                                    Did any distros actually use runit?

                                                                                    Void uses it, Artix recently added it as an option, and Project Trident recently switched over to Void as their base so I believe they also use Runit now too.

                                                                                    I don’t know the details but I’d hope and expect that the projects that integrate with systemd would accept patches for non systemd inits.

                                                                                    I doubt it. Most programs I’ve seen that depend on systemd often have it as a hard requirement. Which forces users to use tools like elogind or consolekit or eudev, or patch the program themselves to not use systemd. It’s a trivial thing when using a distro like Gentoo, but I’m sorry for those who use distros like Debian because it’s near impossible to escape from systemd there.