1. 1

    I’m interested in Haskell but very new to the language. Could someone explain how the design presented in this post would be preferable over something like this?

    {-# LANGUAGE RecordWildCards #-}
    
    data Bicycle = Bicycle
        { cadence :: Int
        , speed   :: Int
        , gear    :: Int
    } deriving (Show)
    
    newAcmeBicycle :: Bicycle
    newAcmeBicycle = Bicycle 0 0 1
    
    newFooBicycle :: Bicycle
    newFooBicycle = Bicycle 0 0 4
    
    printStates :: Bicycle -> IO ()
    printStates Bicycle{..} = putStrLn $
        unlines ["cadence: " ++ show cadence,
                 "speed: " ++ show speed,
                 "gear: " ++ show gear]
    
    changeGear:: Bicycle -> Int -> Bicycle
    changeGear b g = b {gear = g}
    

    I’m guessing that it has something to do with record immutability but is it preferable to actually mutate the record fields rather than returning a new record with the new field values?

    1. 4

      (I’m the author of the post) You’re exactly right, what you’ve written is much better for most cases. I just wanted a more direct comparison; I think changing too many things in the Haskell translation would have obscured the focus of what I wanted to contrast.

      1. 1

        You’re right if you’re using records to store data - it’s usually better to create a fresh new copy with updated field values. However, if you’re doing object-oriented programming (and no language ought to prevent you from doing that if you so wish), you typically want the state and future behavior of objects to change in response to messages. For this reason, objects are modeled in Haskell as records of methods whose fields are (functions returning) IO actions.

        1. 1

          Thank you for the explanation. That’s very helpful for my understanding.

          Would implementing a message passing design have any benefits over just using records to store the data and functions that operate on those records? It seems like the design presented backs them into a corner where they lose ‘object’ polymorphism and instead need to implement a conversion function for each type of bike, like acmeToBicycle.

          Would this be considered the idiomatic way of addressing designing this system or am I reading a little too much into a design that was merely meant to show parallels between two seemingly unrelated concepts?

      1. 3

        I’m interested to see more about the bad interactions with the community. While I don’t agree with the evangelism of the community, as a whole they are usually knowledgable and helpful.

        As I potential Rust user, I personally have been less repelled by the overall community than by snarky remarks by core developers. When speaking with those who don’t agree (or sometimes don’t understand), certain developers adopt a defensive and often aggressive tone that is less than inclusive. Some appear to just adopt that sort of tone by default, regardless of interactions. While I’m sure these are smart and kind people who want their project to succeed, their online personas and interactions instead drive me away.

        1. 7

          I’d be interested in hearing more about this, if you’d like to contact me privately. Or, as always, feel free to reach out to the mod team as well.

        1. 41

          I don’t think syntax highlighting is a sign of weakness or not understanding a language.

          1. 7

            I wonder if someone would see it as a weakness to use proper formatting or to use obviously named variables. It’s just a preference like tabbed spacing or anything else.

            1. 6

              On one hand, humans have color perception for a reason, so not using syntax highlighting is consciously handicapping yourselves.

              On your other hand, the article argues that syntax highlighting distracts you from semantics, so maybe what we should really use is semantic highlighting. But even then you’d still be using colors, so either way.

              1. 14

                What I’ve found is that, especially in Vim, because just about everything is highlighted, it ends up just looking like a big jumble of colours and nothing stands out (it’s also very inconsistent and the syntax files are a mess). And then you’ve got issues like native types being highlighted, while custom types aren’t recognized which is just confusing. I’m a fan of minimal highlighting, and I’ve gradually dialed my personal colour scheme right back to only highlighting comments and ‘TODO:’, ‘NOTE:’ (so they really catch my attention), and a few very specific things like function/method definitions to make it easier to visually scan a file.

                1. 7

                  I think colors are best reserved for marking important things. Splashing the code with a rainbow of colors prevents anything from standing out.

                  1. 6

                    I wrote on this topic; I agree that going without syntax highlighting is making it harder on yourself (e.g., not noticing that the code you are looking at is in a huge comment block or that you used an incorrect escape sequence), but too much highlighting and nothing particularly stands out. I made my own theme where most text is in one color, and I highlight comments, string literals, function definitions and a couple of other constructs. I particularly like the highlighting of function definitions, it helps my to quickly see where one function starts and where another begins.

                    I don’t have any particular talents in art, color theory, design, UX, and all that, and I’m sure that a competent theme designer could take only 3-4 colors and create a theme that really highlights the value of syntax highlighting.

                    1. 3

                      not using syntax highlighting is consciously handicapping yourselves

                      While understanding that syntax highlighting, like editor and programming language choice, is highly subjective, I disagree with this statement.

                      I personally find that disabling syntax highlighting, and all colors in my terminal, helps me to focus on the actual semantics. I find that I actually read the code more carefully and retain more of the substance than when using highlighting.

                      I also find that disabling highlighting is particularly useful for viewing files written in programming languages I’m less familiar with. While yellow may mean parameter in one language, it may mean class declaration in another. Disabling colors completely removes any chance of information bias based solely on a first glance.

                      I would love to see any studies you have to support the theory that not using syntax highlighting when reading code is an intentional handicap. I would also love to know in what ways you think it is handicap. Is my understanding of the code compromised? Am I slower and less productive? How do you measure how handicapped I am?

                      1. 3

                        I personally find that disabling syntax highlighting, and all colors in my terminal, helps me to focus on the actual semantics. I find that I actually read the code more carefully and retain more of the substance than when using highlighting.

                        “On your other hand, the article argues that syntax highlighting distracts you from semantics, so maybe what we should really use is semantic highlighting.” :P

                        I would love to see any studies you have to support the theory that not using syntax highlighting when reading code is an intentional handicap.

                        Here you go!

                        1. 2

                          “On your other hand, the article argues that syntax highlighting distracts you from semantics, so maybe what we should really use is semantic highlighting.” :P

                          Yes, that’s why my statement was prefaced with “I personally”. I interpreted your use of “on your other hand” (emphasis mine), to mean you were incredulous of that argument. I was adding my own personal experience and preferences to the discussion.

                          I can’t speak to the papers, as I’m reading them now, but I appreciate the sources. You did not, however, answer how I am handicapped. Simply trying to authoritatively state that forgoing highlighting makes me perform at a lesser degree than someone using highlighting is a broad and vague statement.

                          1. 2

                            That’s fair. My position is more philosophical: colors are very information dense for humans, so we should leverage that for parsing code. That doesn’t mean any particular syntax highlighting scheme Is Good, or even that our current position on syntax highlighting Is Good- I think it’s helpful, but there’s a lot of room for improvement.

                            One thing I haven’t really seen, but am really into the idea of, is semantic highlighting. That would be things like “color any function that’s imported somewhere else in the codebase” or “highlight any variable I later mutate.” Those would potentially be a lot more powerful than just coloring keywords and such, but would also be trickier to write a highlighter for, which might be why nobody’s done it yet.

                            Edit: “your other hand” was a typo :/

                            1. 2

                              That’s also fair. I was mostly just wanted to dig into the theory that anyone not using highlighting is intentionally handicapped. I, clearly, disagree there but I definitely accept that feelings around highlighting, like most programming-related meta-things, are highly subjective.

                              While I do not use highlighting, I’m also interested in seeing how tools can improve to help people perform their tasks to the the best of their ability. I’m not opposed to highlighting existing and would love to see improvement made to make highlighting more useful. Semantic highlighting would be very interesting and I would definitely give it a try.

                              I just don’t don’t buy that I’m at a disadvantage by not using normal syntax highlighting.

                            2. 2

                              Neither paper actually says I am at a handicap. What they do say is that syntax highlighting is useful among certain portions of the programming population for quickly identifying certain characteristics about a program. Neither explores whether the users already used syntax highlighting, or the same tools and same colors used in the study, or how the highlighting affects the understanding of a program in someone who normally does not use highlighting,.

                              I believe you are misrepresenting the data in those papers as “not using syntax highlighting is intentionally handicapping yourself” when in fact the first paper says syntax highlighting can be beneficial for identifying certain program constructs (first paper) and the second paper clearly states that “the magnitude of the effect [syntax highlighting has] decreases as programming experience increase”, though it does say it can reduce context switching.

                              So, my question is still, why do you think I’m at a disadvantage and how does this manifest?

                            3. 1

                              Very interesting links, thanks for sharing. When I was debating a similar subject, I was looking for similar documents but could never find any.

                          2. 2

                            On one hand, humans have color perception for a reason, so not using syntax highlighting is consciously handicapping yourselves.

                            I’ve never seen this brought up about IDE’s. That’s a great point. It’s reinforced in many other areas such as UX and marketing materials. Hell, even the milk I buy is always red since many generic, grocery items are categorized by color for instant recognition. It’s proven to be a useful psychological effect in general. So, we should leverage color for categorization in IDE’s. How to best do that is obviously still an open topic but keywords vs functions vs type vs etc have been useful so far.

                            1. 1

                              keywords vs functions vs type vs etc have been useful so far

                              I don’t agree with this at all. I appreciate that people like it, but I bet many orders of magnitude more time have been wasted trying to tell the difference between $accountCount and $accountCⲟunt than between private and personal.

                              Maybe even more when you consider colour fatigue tricking the programmer into thinking there’s no difference between the lines…

                              1. 1

                                Hmm. We could make the keywords all one color with the usesr-supplied identifiers on a given page being different colors. How about that?

                                1. 1

                                  Maybe. It certainly sounds more useful than what vim and sublime editor do. There’s some risk though, and it’s unclear how common purposeful variable shadowing is:

                                  let accountCount=get(); 
                                  do_something(function() {
                                    let accountCount=get();
                                    ...
                                  });
                                  

                                  The two “accountCount” variables above should be different colours, and while shadowing occurs frequently in my programs, in other programs it might be a bug.

                          3. 2

                            Obligatory quote: http://aiju.de/rant/syntax-highlighting

                            That is what overly highlighted code looks like to me.

                            For me, proper indentation / spacing and code layout is way enough for reading.

                            For writing, highlighting strings reveals to be appreciated to me, but still, in languages such as shell script, you can quote every single word or let it unquoted. Syntax highlighting for strings then become totally pointless.

                            When I use vim, I switch between :syntax off for less rainbow reading and writing and :syntax on when I have a doubt about a string quote in a shell script or such.

                            Proper color theme is also a good compromise.

                            1. 2

                              What I am often looking for with a syntax highlighter is a good linter instead. A syntax highlighter is also a linter that display the result as colours on the text…

                          1. 3

                            Why not both? Valve pushed the concept of the T-shaped employee in their handbook. Broad-range generalist with a deep focus on a single area.

                            1. 2

                              GHC and/or Cabal is also broken for projects with a large number dependencies. Beware if you’re a Haskell user and depend on Stack-sized projects (Yesod and Stack both appear to use every package on Hackage).

                              1. 3

                                I love how a well-regarded software developer uses learning a new instrumental composition, rather than building software, to illustrate their point.

                                I once had an instrument-specific instructor who liked to stress that the point of teaching was to train you to teach yourself. It was expected that I would be able to identify the hardest parts of a composition by analysis, prior to even touching my instrument, and tackle them on my own. Much like Joe, after tackling the hardest sections individually I was required to play the piece in it’s entirety, though I was also required to provide observational analysis on the performance to myself.

                                Once a week we would meet and I would play a piece I learned. Often, he’d proffer a piece of information unrelated to my actual performance but something which would nevertheless improve my understanding of what I was playing and how to improve my interpretation. My favorite example of this was with a piece by Bottesini (Elegy No. 1 in D).

                                After finishing what I thought was a good performance, he asked whether I knew that Bottesini actually wanted to be an opera composer. I was befuddled. Who cares about the ambitions of a composer long past? He then remarked that if you look at the piece, the juxtaposition of passages played in the upper and lower ranges almost seems like a duet between a male and female singer (see: ~2:40 in the video). This little fact changed my entire view of the piece. No longer was it simply a composition played on an instrument but rather an elegy for the love between two people, both parts playing out on a single instrument.

                                Sometimes the technically difficult parts are actually the easiest. Anyone can create software, good or bad. It’s the context that gives what you created power and the interpretation that gives it meaning. Go out and build whatever your going to build in whatever language or systems you want. Bottesini did. He couldn’t write an opera but he could sure play the bass like no other. He instead made the best opera he could using what was available and the result was an enduring piece in the classical repertoire.

                                1. 2

                                  the point of teaching was to train you to teach yourself

                                  Hah. I’ve had this thought but with regard to therapy. Where it’s also true, except therapists generally don’t seem to know it. I guess it applies to a lot of things. :)

                                  Thank you for the anecdote, it’s moving and relevant. And got me to read the article, which I’d probably have skipped otherwise.

                                  1. 2

                                    I’m happy someone read it! While it doesn’t address everything in Joe’s post directly, I thought it might be a interesting companion piece for someone.

                                    I agree that the idea of teaching yourself how to teach yourself seems to be almost universally applicable. I would really like to read any formalized studies on the topic. There seems to be many books, especially self-help text, that focus on specific aspects but I don’t think I’ve come across anything about the subject as a whole. Maybe auto-didacticism is a mystical art.

                                    I have found the books that deal with the specific portions of teaching yourself to be very helpful, however. I’ve recently been re-reading The Inner Game of Tennis, which focuses on achieving a flow state by silencing negative criticism given to yourself by your self. It also makes a few references to Zen in the Art of Archery, which apparently is a seminal text on a similar subject. it’s on my to-read list.

                                    If anyone has any similar recommendations, I’d love to hear them!

                                    1. 2

                                      I recently read The Inner Game of Tennis as well and have found it helpful in my physical pursuits. Have you found any applications related to programming and learning? I struggle to apply his ideas to programming because I find my internal dialogue generally functions as the middleman between my unconscious and conscious when programming. Analytical tasks (at least in my brain) are mediated through a combination of visual and verbal thoughts. If anything, I often find something like Rubber Duck Debugging helps me simplify or understand complicated solutions.

                                1. 2

                                  So, in bash, I could solve this problem by finding the curl executable. If it doesn’t exist, well, then I add an alias, all as part of my .bashrc. Surely PowerShell has some sort of startup script which could do something similar?

                                  Of course, this might still be backwards incompatible, since the builtin might have different output, in the basic case. But, if PowerShell’s builtin is similar to curl -s, aliasing a found curl executable to curl -s seems like a great compromise.

                                  1. 6

                                    According to the comments on the PR, you add these to your profile:

                                    Remove-Item Alias:Curl
                                    Remove-Item Alias:WGet
                                    
                                    1. 3

                                      I assumed there was a way to remove the aliases. But, by default they are there, which is potentially confusing to users – Daniel’s point. It just seems like the default profile should do the right thing if those binaries are found. But, I reserve the right to be wrong here. :)

                                      1. 2

                                        I may not have made it clear but I completely agree. The aliases have also existed since the beginning of PS, apparently, breaking curl (and who knows what else) on Windows itself. This is not just about breaking *nix tooling, it’s about overriding behavior of 3rd party programs across a huge deployment whose updates happen irregularly (by OSS standards.)

                                        If nothing else, this is a fascinating case study in how historically insular companies and communities address concerns when moving to open source.

                                  1. 2

                                    Other programs are also overridden with possibly breaking behavior. cpp is aliased to Copy-ItemProperty, for example.

                                    1. 1

                                      Do the streams implement the reactive streams standard?

                                      1. 2

                                        Is there a standard? I’m only aware of the collection of libraries that fall under that banner, not a spec.

                                        1. 2

                                          It’s a standard in the same way JSON API is a standard ;)

                                          http://www.reactive-streams.org

                                          1. 2

                                            Interesting! I’ll have to dig into that page. Thanks!

                                            (Oh, and I guess this is implied, but I’m almost certain that the answer is no. This makes really heavy use of rust-specific features.)

                                            1. 1

                                              This makes really heavy use of rust-specific features.

                                              How is the specification of behavior related to the implementation?

                                              1. 1

                                                How is the specification of behavior related to the implementation?

                                                in Rust, different language features have very different performance profiles, and that also comes with restrictions on what you can do. So this library, for example, was designed to be as low-overhead as possible, and therefore, has certain behaviors that allow it to achieve that basically-zero performance.

                                                In a language that’s not as performance-sensitive, you do a lot of things that can add overhead. So for example, imagine that the specification of the behavior here required runtime reflection. Doing that is extremely difficult in Rust due to performance reasons.

                                                1. 1

                                                  That different language features might have different performance is true, but it’s completely unrelated to the spec.

                                                  There are 43 rules. Can you pin-point a rule which would require runtime reflection to implement?

                                                  1. 1

                                                    Can you pin-point a rule which would require runtime reflection to implement?

                                                    I haven’t read this particular spec yet, I was spec-ulating (near-pun intended) based on my previous experience: no GC means that my APIs end up very differently in Rust than they do, say, Ruby.

                                                    1. 1

                                                      Sure, but the API can look anyway it wants. Why would the spec care how the API looks like? Provide the most idiomatic, rusty API you can think of.

                                                      1. 1

                                                        Why would the spec care how the API looks like?

                                                        Because behavior affects how APIs are developed. For example, a spec that says “this can return any value as long as it implements a foo() method” is simple in dynamically typed languages, but more complicated in statically typed ones. And especially if the specification isn’t performance-oriented, it might require behavior that’s significantly less performant than other behavior.

                                                        1. 1

                                                          Can you be specific which of the rules would cause issues?

                                                          1. 1

                                                            I haven’t read this particular spec yet,

                                                            1. 1

                                                              Then why keep speculating?

                                      1. 5

                                        If anyone uses sam (or another editor that would be considered more “primitive” than something like vim or Emacs), I’d love to hear what you have to say about it. Why use that particular tool, what does it give you that other editors don’t or what does it enable that is important to your workflow? Thanks!

                                        1. 6

                                          I’m a long-time sam user. So far sam is the best graphical editor I’ve used, and one of the very few that actively invites me to use the mouse when editing text; it’s just so natural. I should note that I’m a long time user of the chording patch (now in the deadpixi version), which make moving text much faster and easier than it would otherwise be. sam doesn’t have very much special power for editing text, but it works smoothly. Also, like vi (and unlike Emacs) it has the virtue that it plays well with other Unix tools in that you can do things like select areas (or the entire file) and pipe them through programs like fmt. As vi users know, this is a great way to leverage the power of everything on your system.

                                          One subtle thing about sam is its command window and the command lines that you enter there. These give you extra visibility on what you’re doing and also let you successively refine large scale modifications, since you can see, reuse, and extend commands. It’s routine for me to start by doing just, say, the part that will select the text I intend to modify; when that’s selecting the right thing, I’ll redo it with the change command. Did something go wrong? Undo, modify the command, re-send it to try again.

                                          I personally quite like how sam deals with editing multiple files. I find that it makes it very easy to go back and forth between several files without pain, although having several on the screen at once is not as easy as it is in something like Emacs. Part of this may be that I have never really learned how vi does this and find what I do know somewhat awkward. sam has a clear conceptual model where it has all files loaded in at once, some or all files may be modified from their on-disk version, and so on. Emacs does this too, but sam has the nice popup menu of all the files that makes moving around among them easier for me.

                                          I mostly don’t use sam for large scale programming in most languages, because Emacs has all sorts of very nice superintelligent autoindent and this and that. But for quick modifications, or for languages where Emacs doesn’t do what I like, or for text, sam works great for me.

                                          (sam’s multi-file structured editing also makes it the best tool for certain sorts of mass modifications, because you can easily run a single modification over a whole bunch of files all at once. But at least for me this is a relatively uncommon thing that I might do only once or twice a year.)

                                          I go back and forth between sam, vi(m), and Emacs depending on what I’m doing. Emacs is my big-programming editor; sam is my generally preferred editor if I’m in an X environment where I have it set up; vi(m) is my sysadmin editor because it’s always there and works in any environment and starts and runs fast.

                                          1. 4

                                            Any chance you could make a screencast? Very curious to see how sam is used as a general purpose editor and how it mixes with the rest of the environment.

                                            1. 1

                                              I would love to see that too; although I don’t use Acme myself, Russ Cox’s video on Acme and its features is something I watch a couple times per year just for fun.

                                            2. 1

                                              Thank you so much for taking the time to write this response, very interesting!

                                              1. 1

                                                Also, like vi (and unlike Emacs) it has the virtue that it plays well with other Unix tools in that you can do things like select areas (or the entire file) and pipe them through programs like fmt.

                                                C-u M-| begs to differ…

                                              2. 2

                                                note: using vim as main editor.

                                                Sam is nice in many ways. Using it for quite some time for editing small files and replying from mutt.

                                                Also used Sam in a work project, using fzf to select files and open them using B. Quite elegant and simple.

                                                What I like: - ability to organize your workspace. It’s like a floating wm. Like it way more than acme’s “tiling” structure - command window - ability to use proportional font for reading long chunks of text

                                                The only thing I found cumbersome, was that there was no way to navigate using keyboard between open files.

                                                Tried to build Sam fork from deadpixi on OpenBSD, but failed miserably. Seems very nice though. :)

                                                1. 1

                                                  The deadpixi version has Ctrl+K for switching between current editing window and the command window, the b command in the command window has fuzzy matching support, and you can use Ctrl+{W,S,D,X} to move up, left, right, down (not very ergonomic if you was me).

                                                  1. 1

                                                    The latest version of the code lets you rebind keys at compile time. Check it out. :)

                                                    http://www.github.com/deadpixi/sam

                                                  2. 1

                                                    Please check out the latest source on GitHub. It should compile correctly on OpenBSD now; look at the comments in config.mk for information on how to compile.

                                                  3. 2

                                                    I’m a huge fan of ed (and sam). I have tried numerous times over the last decade to use ed as my main editor but consistently find myself falling back to something more ‘modern’.

                                                    There are relatively few things I miss when using ed but there are a couple of pain points that prevent me from using it as my daily driver:

                                                    • I really want my line editor to have a line editor. rlwrap gets me 90% of the way there but having a built-in version would be nice. One that supports vi-like bindings would be doubly great.
                                                    • Better regex. Sam’s structural regex is very nice but even something as ‘simple’ as pcre would be very useful
                                                    • Have the change command populate the line. There are some occasions where I can’t accomplish what I need with the basic regex and have to change a line. Populating the line buffer with the contents of the line would be very helpful to avoid typing out a majority of the line again.
                                                    • Mini multi-line buffer: This is something I’ve been thinking about a lot. When in insert mode, it would be nice to edit previously entered lines. Anything between an ‘i’ (or ‘a’ or ‘c’) and ‘.’ becomes a editable multiline buffer. Yes, this really goes against the idea of a line editor but it would be so useful I don’t think I’d care.
                                                    1. 1

                                                      Do you know vi’s “open mode”? E.g. ex-vi implements it.

                                                      1. 1

                                                        Very interesting! Can you explain how you navigate a file using ed? I know enough to modify a file or write a small script, but I’m not sure how I’d navigate in a multi-thousand line file.

                                                        1. 2

                                                          Firstly, I make heavy use of a terminal multiplexer. I use tmux splits to open multiple files side-by-side and copy mode to view previous output in the scrollback. Sometimes I keep two splits open with the same file, one for browsing and one for editing.

                                                          I use the z command with reckless abandon. Without specifying a number of lines, most implementations will use the windows size as n and display n lines. You can also use zn to print the lines numbers but three keystrokes to browse with line numbers is a little much.

                                                          If I need to address a line and I’m unsure of the address, I’ll just use a simple search to find what I’m looking for. If there’s only a few lines using the var $foo, I can /\$foo and keep hitting enter until I find the line I want. If I’m really lazy, sometimes I’ll just ,n to print the whole file with line numbers and use tmux’s search.

                                                          The real trouble I run into, which forces me back to something like vim (or vis, these days), is large refactors. I find it very difficult to effectively move around blocks of text and adjust their indentation without immediate feedback.

                                                          The change command, as mentioned above, can also be a pain. There are times when you may need to change a small part of a line but you either can’t find a regex that works or you can’t get ed’s minimal regex implementation to play nice. I ultimately wind up using the c command to change the line, requiring me to type out the whole line again.

                                                          Indentation sometimes gets me in trouble with my colleagues. I use tabs exclusively when working in ed and have to remember to format prior to committing. This is easier in languages which provide official formatters (go and rust) but requires more diligence with other languages.

                                                    1. 6

                                                      I saw this yesterday and spent some time thinking about strategies. Without the requirement to be an unbiased juror, I’m inclined to say that anybody willing to sit in jail for seven months is either hiding something bad, or seriously dedicated to principle. THe fact it’s a former cop makes the second possibility even more remarkable.

                                                      Forcing him to reveal the password may be a 5th A violation. But then I thought (playing armchair lawyer), there’s also a kind of second order violation. If he chooses to remain in jail, doesn’t that leak information about how damning the contents are? That’s almost a form of testimony itself.

                                                      What should someone do in these circumstances? I think I’d rather take my chances getting the evidence excluded after the fact, possibly on appeal, than fighting this order. Resist for two days, then argue it was a coerced confession.

                                                      1. 23

                                                        If he chooses to remain in jail, doesn’t that leak information about how damning the contents are? That’s almost a form of testimony itself.

                                                        I can’t bring myself to think that an absence of evidence can be considered evidence. There are plenty of reasons to refuse decryption. One thing that has always troubled me in cases like this is what if you -cannot- decrypt it because you have forgotten the key, or some mechanism prevents using the key you do have?

                                                        There’s also the tricky situation of the Supreme Court ruling that you cannot instruct a jury to infer guilt based on refusal to testify . People are free to draw their own inferences, I suppose, but that’s pretty shaky ground to base a serious criminal ruling on.

                                                        1. 2

                                                          I can’t bring myself to think that an absence of evidence can be considered evidence.

                                                          Legally, I believe that it cannot and should not (in the US), but logically, absence of evidence is evidence (of absence).

                                                          1. 2

                                                            I’d be cautious with your last point, since it’s not correct in general. For example, let’s say I have the flu, but I take a test and it comes back negative. So then the “absence of evidence” (that I have the flu) is NOT “evidence of absence” (that I don’t have the flu). If the evidence in the first clause is not the same as the evidence in the second clause, then I guess it may still be logically correct.

                                                        2. 12

                                                          We should never take silence as an indication of admission of guilt.

                                                          1. 5

                                                            I’m a huge believer in the right to remain silent. Language is messy and the right to remain silent and non-cooperative. It’s tough for prosecution, but thats the way things work: people have to prove your guilt, not the other way around.

                                                            Seeing lines of reasoning like this sometimes makes me feel that the right to remain silent is more under attack then the right to speak freely.

                                                            1. 4

                                                              If the police conduct an illegal search and find a dead body in somebody’s trunk, that evidence will be excluded from trial and the suspect possibly set free. But that doesn’t mean the dead body doesn’t exist! We, as outside observers, can still say there was a dead body in the trunk. We can even discuss the relative likelihood that the body was placed there deliberately or mistakenly.

                                                              We’re not conducting a legal trial here.

                                                              1. 2

                                                                If the police conduct an illegal search and find a dead body in somebody’s trunk, that evidence will be excluded from trial and the suspect possibly set free.

                                                                Possibly.

                                                                If the warrant was not properly issued, but the affiant, issuing judge and searching officers acted in good faith, the evidence may be admissible. If the car was parked on the street where the police found a one foot wide blood trail leading from my front door up the back of the car, and a bloody handprint on the trunk release lever, the evidence would likely be allowed as it would have been inevitably discovered.

                                                                The law isn’t always so clear cut. Compelled decryption has a similar history. In one case, a man brought a laptop with child pornography across the border, and the pornography was observed by border agents - but when they shut down his laptop, it was locked thanks to PGP FDE. He was compelled to decrypt the drive as the government already knew with certainty that illegal materials were on his drive.

                                                                But in another child pornography case, it was found that forcing the defendant to decrypt the disk would be testimonial, so the fifth amendment applied.

                                                                We’re not conducting a legal trial here.

                                                                No, but this entire discussion focuses on legalities. Why wouldn’t we discuss them?

                                                                We may be free to believe that Rawls has child pornography on his laptop – and, based on the facts we’ve heard, I’d wager he definitely does – but debating that point doesn’t really bring anything to the table, does it?

                                                                1. 2

                                                                  I have no objection to discussing legalities. I’m pushing back against people objecting that I should only discuss legalities.

                                                                  Sometimes people find themselves in situations where quoting their civics 101 textbook isn’t the optimal strategy.

                                                                2. 1

                                                                  If the police conduct an illegal search and find a dead body in somebody’s trunk, that evidence will be excluded from trial and the suspect possibly set free.

                                                                  Note that this is the situation in the US, but for example not in Germany, where I come from.

                                                                  The way of reasoning, I see in both.

                                                                  I don’t see the right to remain silent as a pure legality.

                                                              2. 3

                                                                I’m sitting on a trial right now that, while not related to this in any way, has opened my eyes to the effectiveness of certain defense strategies.

                                                                Even a middling defense could probably mount a strong a case for reasonable doubt, depending on the other evidence and testimony. Playing up the debate about encryption could resonate with some jurors but the subject matter could also cause them to swing the other way. However, since this is federal case, I would imagine that the other evidence against him is strong.

                                                                I personally think not choosing to decrypt would be the best strategy, since you’re then relying on possibly circumstantial evidence and the testimony of others. You can find testimony incredulous but it’s harder to argue against actual possession.

                                                                1. 1

                                                                  What should someone do in these circumstances? I think I’d rather take my chances getting the evidence excluded after the fact, possibly on appeal, than fighting this order. Resist for two days, then argue it was a coerced confession.

                                                                  I think in the case of child porn, it’s bad enough to be accused of it! If there’s actual evidence (usable in court or not), it’s simply game over.

                                                                  But, in terms of strategy, I think the only thing you can reasonably do is figure out a way to use the fifth amendment to avoid decryption. That might cast doubt on him, since “why fight for the right to not incriminate yourself” if you’re not guilty, but if this is the only evidence against him (unlikely), it might work. A good lawyer would bring up the fact that loads of people sided with Apple against the FBI; good people, with nothing to hide, still feel that encryption is a right, and being compelled to decrypt is a violation of privacy, etc.

                                                                1. 3

                                                                  There are too many static site generators in the world, right?

                                                                  1. 2

                                                                    Nevertheless, isn’t zodiac awesome?

                                                                  1. 1

                                                                    I’ve subscribed to this method for a long while but I tend to substitute ed for vim and add tmux for splits. If only there was a newer line editor that had line editing capabilities with vim keybindings…

                                                                    1. 4

                                                                      I still love ed as an editor; I’m still not comfortable doing actual coding work in it; but I reach out to ed more and more for small config edits after reading “Actually using ed” (http://blog.sanctum.geek.nz/actually-using-ed/).

                                                                      Anyone here actually using ed … for real development tasks?

                                                                      1. 5

                                                                        I actually use it for about 90% of my daily work. I realized after years of Vim usage that I was mostly just using ex commands anyway. I’ve become fairly productive with ed aside from one issue: changing a line. That’s where the ‘line editor with line editing’ thing came from. Instead of just replacing the line, I’d love to just populate the line with the content and use a line editor to actually edit it.

                                                                        I have directories filled with stalled attempts at this; there’s half-completed Go-implementation with a fork of golang.org/x/crypto/ssh/terminal, a rewrite of plan9 ed in c99 for modern *nix with linenoise, and an attempt to add linenoise with modifications to the heirloom version of ed.

                                                                        More modern regex support would probably be convenient as well. On the whole I find that ed integrates well with my workflow and presents only minor annoyances. I would love to see a resurgence and remixing of the traditional line editor, however.

                                                                        1. 3

                                                                          Have you checked out sam from plan9/p9p? Probably, as you mention working with plan9’s ed. Heck, it might be the same editor.

                                                                          I’d be interested in your thoughts on it.

                                                                          1. 4

                                                                            You know, I used it for a bit but mostly kept getting sam commands confused with ed commands. Something like 157,189n just falls out of my fingers and I wound up just reverting back to Plan 9’s ed (which is still the version I use). The structural regular expressions are great though and I’d love to see them implemented in other editors. I should try using sam again. The few differences in commands is worth it for the structural regexs alone.

                                                                            I’ve also been meaning to track down the sources for qed for archaeological purposes.

                                                                            1. 2

                                                                              Wow, it’s neat to see that mentioned. I’ve never used it, but I read about it extensively many years ago when I was more interested in text editors. It’s always a surprise when someone else remembers!

                                                                            2. 1

                                                                              Care sharing one of said directories somewhere?

                                                                          2. 2

                                                                            vi + open mode?

                                                                            1. 1

                                                                              I didn’t even know open mode was a thing but I remember reading about open mode in ed from an interview with Bill Joy:

                                                                              But while we were doing that, we were sort of hacking around on ed just to add things. Chuck came in late one night and put in open mode - where you can move the cursor on the bottom line of the CRT.

                                                                              The real question is how do you enable open mode in vi/vim without having a hardcopy terminal?

                                                                              1. 2

                                                                                vim/nvi doesn’t have it. Use ex from ex-vi, then, e.g.:

                                                                                % TERM=dumb /usr/bin/vi /etc/passwd 
                                                                                [Using open mode]
                                                                                "/etc/passwd" [Read only] 24 lines, 1520 characters 
                                                                                root:x:0:0:root:/root:/bin/bash                     
                                                                                ...
                                                                                
                                                                                1. 1

                                                                                  Installed. It’s very interesting. It’ll take a little getting used the ex commands.

                                                                                  ex

                                                                                  "/tmp/ed" [New file]
                                                                                  :i
                                                                                  No lines in the buffer
                                                                                  :a
                                                                                  the quick
                                                                                  brown fox
                                                                                  jumped
                                                                                  .
                                                                                  :.
                                                                                  jumped
                                                                                  :,
                                                                                  jumped
                                                                                  :q
                                                                                  No write since last change (:quit! overrides)
                                                                                  :q
                                                                                  No write since last change (:quit! overrides)
                                                                                  

                                                                                  ed (plan 9)

                                                                                  ?/tmp/ed2
                                                                                  i
                                                                                  the quick
                                                                                  brown fox
                                                                                  jumped
                                                                                  .
                                                                                  ,
                                                                                  the quick
                                                                                  brown fox
                                                                                  jumped
                                                                                  q
                                                                                  ?
                                                                                  q
                                                                                  

                                                                                  One big thing I like about ed is the ability to look through the scrollback and see changes as they were made, even after closing a file or while editing another file. The use of a full screen interface removes this ability. I’ll definitely play with this a bit more though. Thank you for the recommendation.

                                                                                  :i  
                                                                                  this
                                                                                  is a t^A^E^[^[
                                                                                  
                                                                          1. 3

                                                                            $dayjob: Actually in the office (I usually work remotely from the other side of the country) working with various business units on a neverending Puppet 3 upgrade. Anti-Tip: use strict_variables but good luck teaching your org about initializing all values to undef

                                                                            $extra: So, a few weeks ago I got really frustrated with all configuration management products. Simply, I was really annoyed by the language dependencies, pain of deployments, lack of speed, etc. (Before you mention it, yes I have used $cfgmgmtappX. That one is frustrating too.)

                                                                            To scratch that itch, I created a very simply library (in C) which does the ‘how’ of configuration management. I created some unix-y binaries:

                                                                            [root@b6fdd7c544c6 ~]# cm-group -h
                                                                            usage: cm-group [options] GROUP
                                                                            
                                                                            Options:
                                                                                    -a, --absent         ensure group is absent
                                                                                    -g, --gid GID        group gid
                                                                                    -h, --help           display this message and exit
                                                                                    -n, --noop           print but do not commit changes
                                                                                    -p, --pass           encrypted group pass
                                                                                    -v, --verbose        enable verbose output
                                                                            [root@b6fdd7c544c6 ~]# cm-group -v foo
                                                                            [group] foo: is absent and should be present
                                                                            [root@b6fdd7c544c6 ~]# cm-user -v -g foo -d /home/foo -s /bin/bash foo
                                                                            [user] foo: is absent and should be present
                                                                            [root@b6fdd7c544c6 ~]# cm-dir -v -o foo -g foo -m 0700 /home/foo
                                                                            [dir] /home/foo: is absent and should be present
                                                                            [root@b6fdd7c544c6 ~]# cm-file -v -o foo -g foo /home/foo/one
                                                                            [file] /home/foo/one: is absent and should be present
                                                                            [root@b6fdd7c544c6 ~]# cm-pkg -v ed
                                                                            [pkg] ed: is absent and should be present
                                                                            

                                                                            and some python FFI bindings as well.

                                                                            This week I’m working on recursive changes to state for dirs, ruby FFI bindings, thinking through the ‘when’ of configuration management, and how to handle duplicate declarations.

                                                                            1. 1

                                                                              This seems appropriate: http://xkcd.com/927/

                                                                              1. 1

                                                                                I wasn’t really aiming to implement standards, just to make the usage of configuration management in large and small scale environments align more with the internal language and architecture choices of the organization. I thank you for your generous and extremely well-worded input, however.

                                                                                1. 1

                                                                                  Yeah, after sleep I realise my reply was unnecessary. You took it extremely well, and I apologise to you and congratulate you on that.

                                                                                  1. 1

                                                                                    No worries, at all. Enjoy being a stay-at-home dad, it’s the best gig (or so I hear)!

                                                                            1. 5

                                                                              Over the past few weeks, I’ve been desperately searching for a project to occupy my time. Something I can really learn from, something which could actually have value, something I can work on for more weeks, months, or years. A project that’s frustratingly hard and excitingly useful.

                                                                              I’m comfortable with working on tedious but not technically challenging projects at work. Those tasks are great exercises in patience and detail, they can provide actual business value, and they help keep things running smoothly for both the infrastructure and the engineers who rely on them. I almost relish them for the coordination and discipline they require, like a morning run or cleaning your house.

                                                                              Things are different when I get home. Despite having plenty of hobbies away from the computer, lately I’ve been finding myself sitting at my desk staring at the cursor block next to my shell prompt. Just staring into the white abyss of possibility my computer offers, unable to actually chose what to work on next. Sometimes I pace, running through the scores of ideas I have stored in my head and notebooks, trying to find something that’s actually worthwhile, but mostly I just sit and stare. No idea seems worthy of the time and energy. No idea seems worthy enough to exist in the world.

                                                                              So this week I’m going to step away from that blinking cursor, leave my notebooks and ideas at home, and just exist in the world. I’ll give thanks to all in the world who are able to use that little cursor block to create things. I’ll raise a toast to those who find and work on truly difficult problems. I’ll have a shot or two for those who work on the things they think are important, regardless their adoption rates or GitHub stars.

                                                                              Maybe in stillness one can find motion.

                                                                              1. 2

                                                                                Been there for a while too. Hang on! And don’t try to force yourself to pick up a project until you are 100% sure you are looking forward to any challenge that comes with it. In other words, rest well! :-) And know that even those demigods who appear to be productive all the time really aren’t.

                                                                              1. 30

                                                                                Here’s one of mine: vim/emacs do not significantly increase productivity.

                                                                                The undue fixation on editors is common among younger devs, who usually use dynamically typed languages and have to write a lot of code. They routinely confuse the time spent editing code as the time spent programming. And since they’ve just put significant time into their editor, few are about to admit that it was wasted time. Maintaining extensive configs for vim/emacs is a timesink in and of itself.

                                                                                This is part of the over-emphasis that devs place on the act of writing code vs maintaining it. The hype cycle of industry is firmly locked to the dopamine hit of “wow, it works?!” Devs would rather chase this fleeting, temporary feeling over building robust, reliable systems with more boring tech. It’s like they’ve internalized that software development always has a certain pain threshold, and they’ll ensure that they reach it, no matter what.

                                                                                1. 31

                                                                                  controvertial counter opinion. People who use vim or emacs do not use it for productivity gains, but for the pleasure they give. The justifications are about productivity, but the real reason is pleasure. The same pleasure you get mastering a musical instrument.

                                                                                  1. 7

                                                                                    Absolutely. Editing text in vim is so good. I just wish it would understand what I’m writing more.

                                                                                    It’s not that I wish people use them less, but that they’d expect more from their tools.

                                                                                    1. -5

                                                                                      To what end? Imagine the ultimate IDE. You take the anal probe and stick it in. It immediately creates a program that you are thinking about, and maybe some you didn’t realize you were thinking about (think porn aggregation). You squeeze your but cheeks and it runs.

                                                                                      Why an anal probe and not something that you wear on your head? Because there is no pleasure in wearing something on your head, as there is no other pleasure using that type of IDE.

                                                                                      As soon as programming stops being enjoyable, you can count me out.

                                                                                      P.S. I hope you can see the humor in my response. I really do think tools need to improve.

                                                                                    2. 3

                                                                                      I have always admitted that this is exactly why I use emacs. I have no illusions that it makes me more productive; I consider it a vice to be honest.

                                                                                    3. 4

                                                                                      Can’t agree with this one enough. When people ask me what my preferred development environment is, I usually say it’s whichever has the best support out of the box for whatever language or technology I’m using.

                                                                                      I usually spend a lot more time thinking than writing code.

                                                                                      1. 4

                                                                                        Hell, I still use ed as my main editor and tmux manages my editor windows. It’s surprisingly easy and robust.

                                                                                        1. 3

                                                                                          I need to play with tmux more. Sometimes, I’d love to be able to split my screen and focus more. I need to wean myself off graphical Vim first, though.

                                                                                          1. 4

                                                                                            I still like VIM-like keybindings, so I use a setup similar to this gist. I’ve gone ahead and annotated each line so you can get an idea of what each one does.

                                                                                            Additionally, I’ve found that the following shell aliases are highly useful (I can never remember the session management commands):

                                                                                            • alias tn='tmux new -s' # create a new session
                                                                                            • alias ta='tmux attach -t' # attach to a running session
                                                                                            • alias tl='tmux list-sessions' # list running sessions
                                                                                            1. 2

                                                                                              Nice, just added to my bashrc. Number of characters in commands is TOO DAMN HIGH

                                                                                        2. 3

                                                                                          I like this one, even as an adherent. Especially as an adherent. There’s definitely a whole lot of fiddling-for-pleasure.

                                                                                          On the other side, do you think that there are cognitive tradeoffs to using IDEs? (I know that’s not your original point, which is programming vs. thinking, but curious)

                                                                                          1. 6

                                                                                            I think IDEs dispose you to think in terms of larger, more monolithic projects. You can believe you need to decouple and ship the smallest pieces possible, but if the primary workflow is one of amalgamating source files into one giant project, that’s what’s going to occur, because it’s easiest.

                                                                                            I also think IDEs make you care too much about them, such as manually merging project files (silly). The UIs are usually bloaty, start-up time can be anywhere from great to terrible, and they often smell of Big Software Syndrome, where most of the features you aren’t meant to use, but instead are for checking boxes for an enterprise paper pusher.

                                                                                            IDEs usually have crappy editors and decent-good code analysis tools. Actually, I think I believe less in IDEs and more in analysis tools that are integrated with the editing experience. Still lots of room for improvement here.

                                                                                            1. 2

                                                                                              “IDEs usually have crappy editors and decent-good code analysis tools. Actually, I think I believe less in IDEs and more in analysis tools that are integrated with the editing experience. Still lots of room for improvement here.”

                                                                                              I like e.g. ensime, for when I’m working in Scala

                                                                                        1. 22
                                                                                          • Bash is harmful. Only POSIX shell should be used (note: this mostly applies to production scripts but I adopt the same ideology for daily use too)
                                                                                          • POSIX shell should be the only scripting language you use.
                                                                                          • Databases should be avoided. Use hierarchical filesystems instead. For relational shell programming, see this
                                                                                          • Most of the time you’re better off writing custom shell scripts than using any of the modern configuration management solutions
                                                                                          • ANSI/ISO/Standard C is still the only systems programming language worth using for major projects
                                                                                          • Lobste.rs > HN
                                                                                          1. 9

                                                                                            Ok. You win.

                                                                                            Your opinions are controversial. ;-)

                                                                                            1. 7

                                                                                              Databases should be avoided.

                                                                                              As a DB engineer, I disagree. But people do need to be more judicious about what databases they use, people pick the wrong DB most of the time.

                                                                                              Also, a filesystem is a database. It just has different access patterns and a different API than a relational / other database. If it fits your performance and feature needs, it’s a legitimate, understandable, and portable database choice.

                                                                                            1. 3

                                                                                              Last week I made a prototype of the async background task queue I mentioned a few weeks ago.

                                                                                              The prototype we’ve created combines a job queue and worker management. Queues are local to machines they run on. Queues are declared in a crontab-like file, along with the maximum concurrent workers for that queue and the command the workers will run.

                                                                                              image 5 /usr/local/bin/convert_image
                                                                                              audio 6 /usr/local/bin/process_audio
                                                                                              

                                                                                              Jobs are just an ASCII formatted string of the queue name and args to pass directly to the command.

                                                                                              echo 'image --file foo.jpg --format png --size=1024x768' | nc worker.foo.com
                                                                                              

                                                                                              Upon receipt of a job, either a new worker will be spawned or, if the maximum number of workers are already running, the job will be placed in the queue until a new worker can be spawned.

                                                                                              It’s written in standard C with no external dependencies. Memory usage is moderate, ~1MB/10k jobs. We’re still exploring redundancy patterns and have a few nice-to-haves in the todo list (reload conf on SIGHUP, graceful shutdown both with and without queue persistance, per queue uid/guid).

                                                                                              Background: One of our applications accepts user-supplied audio, video, and images. Jobs are put onto a task queue to be processed. Our current configuration uses Gearman as a queue, the main web app as the producer, and assorted scripts as the consumers. While it mostly works fine, we’re of the opinion that it’s a little heavy to maintain several consumer processes over numerous machines to just run gm or ffmpeg.

                                                                                              1. 1

                                                                                                This sounds like a pretty lightweight queue implementation, I’d be interested to hear more about how you handle redundancy in the system as you explore it.

                                                                                                Presumably you’re securing this with firewalling, rather than an authentication protocol in the workers themselves?

                                                                                                1. 4

                                                                                                  Correct. In our case, servers are on a VLAN which has no direct routes from the outside world (in addition to firewall policies, just in case.)

                                                                                                  The more I think about the redundancy, the more I don’t think it’ll take anything special. It can mostly be handled like anything else: load balance or have the client send jobs to all queues and ensure the commands can synchronize state. In our case, the latter is very easy since we’re reading media file from temp storage anyhow. If it’s there, continue, else exit.

                                                                                                  The more interesting problem we’ve found is how you handle failed jobs and lost queues. Is it up to the producer or consumer to resubmit failed jobs? How do you track fails? What happens when you’re just constantly failing and resubmitting? In a one way system (producer -> consumer), how do you synchronize state?

                                                                                                  I figure the worst case scenario is that you wind up with something like, say, a Python script that runs the job and updates a table in MySQL (or some other shared state) with the status of the job. Ultimately we’re still ahead because we still don’t need to manage processes and we don’t need any extra hardware for our queue and it’s redundant spare.

                                                                                                  I’m all ears for thoughts and opinions! Like I said, it’s just a prototype to explore the space and see if we can improve on the current architecture.

                                                                                                  1. 4

                                                                                                    Regarding fail loops, exponential back off with a max number of retries.

                                                                                                    Using a relational database to manage jobs isn’t bad. You need a pretty high volume of jobs for the DB to become the problem there. Presumably you are doing async jobs because each job is expensive, which implies a lot about how much load will really be put on the DB: not a lot. You can also prevent long-term degradation of DB performance on the active jobs table by moving completed jobs to a separate table. Then you get a full job history as a side effect, which can be really useful in the long run, or at least fun to query from time to time. =)

                                                                                              1. 20

                                                                                                Open source exists to support forks. Don’t petition, don’t whine, just fork the project and do your best to create the thing that you think should exist in the world.

                                                                                                1. 7

                                                                                                  It’s better for everyone if participants make an attempt to engage in discussion before forking. I know everyone hates politics but it does have a purpose.

                                                                                                  1. 1

                                                                                                    Discussion with whom? Certainly one should attempt to resolve the issue with the developer, company, or sponsor that is driving you to fork a project prior to actually declaring a fork. I do not agree that you need to try to incite the userbase to support your ideals prior to forking with a petition or a threat to fork.

                                                                                                  2. 3

                                                                                                    Dialogue is good, forking a major project is a ton of work and to be avoided if possible. Threats are normal over serious issues. During the exciting times leading up to xorg, Theo de Raadt famously warned:

                                                                                                    This is final; if that license stands, there will be forking.

                                                                                                    1. 1

                                                                                                      The OpenBSD team are not afraid of forking - or writing replacements.

                                                                                                      That license didn’t work out well for XFree86 :~)

                                                                                                  1. 3

                                                                                                    Due to some family issues, I was unable to even begin my toy shell project last week. I only got a small amount of personal screen time and used that time to play with static linux distros.

                                                                                                    I managed to get Moprheus built with relatively recent packages once I figured out the dark art that is musl-cross. I really think that suckless team is doing great work toward GNU-less Linux systems with their coreutils alternatives, sbase and ubase, along with their rewrites of heirloom utilities, hbase.

                                                                                                    For work, I’m still (and probably will be for a while) updating loads of Puppet modules and servers to Puppet 3.

                                                                                                    1. 3

                                                                                                      I am currently sat in the middle with my netbook - I have CRUX installed on it, but have replaced the initramfs/boot partition with musl’d sbase/ubase/smdev/mksh/cryptsetup. It also let me build a fun crypto setup: I boot to an encrypted partition which only has ubase/sbase/etc on it, whose /sbin/init runs integrity checks on my MBR and /boot, then cryptsetups my real partition and pivots into it.

                                                                                                      I don’t want to jump to a full musl system because of package headaches, but the stuff I have moved over so far is working nicely.

                                                                                                      1. 1

                                                                                                        That’s a great setup. Is your real / partition running dynamically linked suckless utils or are you just using coreutils? What’s the total size of your musl’d boot partition?

                                                                                                        I think that without a solid upstream package build system it is very difficult to maintain a fully statically linked system. Despite that, I still love the idea and will continue playing with Morpheus and Sabotage.

                                                                                                        1. 1

                                                                                                          I’ve been looking into Nix to take care of that, but I haven’t had a lot of time to devote to it.

                                                                                                          1. 1

                                                                                                            I’m using coreutils. Tried and tested. And/or I just enjoy having –colour=.

                                                                                                            /boot is 10MB and the pivot partition is 15MB. I could cut a few MB off the latter by using sbase/ubase-box and deleting the man pages, but I made the partition 4GB initially so there is no point. (I started with CRUX on it because I didn’t know how to get to where I am now)