Threads for cmhamill

  1. 12

    The whole Goggle office app suite is just really bad, and it’s amazing because I’m pretty sure it’s gotten worse over time?

    1. 13

      I thought there must be something better until I used Microsoft Office 365 and was much more annoyed.

      I quite like docs and sheets. I guess it depends on your use case. I just need something simple with not a lot of features.

      1. 7

        I use Libreoffice and I can’t say I have any complaints. Mind you I am a programmer mostly and I spend less than 1% of my time at work working with office type documents. I have been subjected to the entire google suite by my current company though and I can definitely say I am not a fan.

        I am not a fan of cloud services in general. I have a big fat self built pc tower, I have no need for thin clients. I see the value of collaborative tools but I really wish everything was just built on top of git.

        1. 8

          I value the real time collaboration.

          Otherwise, I am a big fan of putting things into version control.

          And honestly, the collaboration is 95% about comments which would be handled somewhat well with gitlab, github, another review tool…

        2. 6

          I find it depends on the tool. For presenter tools, I haven’t found anything better than PowerPoint. Early versions of Keynote had the advantage that they implemented only a subset of the features of PowerPoint (which included the minimum set required to make good presentations) but they gradually copied PowerPoint misfeatures (such as shrinking text if you type more, because slides with 1,000 words are obviously better than slides with 100 words). Google’s thing is awful, so is the Libre/OpenOffice one. PowerPoint’s Design Ideas, morph transitions, and SmartArt largely make up for its other shortcomings (such as awful drawing tools, inability to do syntax highlighting for code, and so on).

          I like LaTeX beamer for technical presentations because the combination of the listings package and TikZ lets you make some very clear diagrams including code listing (e.g. control-flow graphs with code in each node) fairly easily and it’s also easy to have a single document that generates the slides and the handouts.

          The only better thing I’ve found is Sozi, which will never gain widespread use because it’s too different. Sozi is inspired by Prezzi. It takes an SVG file as input and creates a presentation by panning, zooming, and (the feature that makes it much better than Prezzi) making layers appear and disappear.

          When it comes to spreadsheets, they’re all pretty bad. Lotus had two spreadsheet products. The bad one, 123, and the good one, Improv. Everyone copied the bad one. Quantrix Modeller is the only surviving Improv clone and it is orders of magnitude better than any of the others. Apple’s Numbers is probably the best for tiny toy spreadsheets, none of them are appropriate for real work. Jupyter notebooks and Pandas are often a better tool than a spreadsheet for a lot of things people use a spreadsheet for. I’d love to see a good open-source Improv clone but the only one I know of is an unmaintained GNUstep app that is very unfinished.

          Word processors are uniformly bad but I’m hugely biased against WYSIWYG. LyX is the only WYMIWYG editor that I’ve tried and it was less slower for me than typing semantic markup directly into a text editor. I’d really like to see a good visual editor for semantic markup. I’d also like to see something with a decent typesetting engine (in 2022, Word still uses a greedy algorithm for line breaking), such as SILE.

          M365 does the collaborative editing pretty well. I can edit in the desktop app at the same time someone else edits on the web and we can see each other’s edits live. I can also turn on track changes and be able to review all of their changes before merging them. I wish it made versioning more explicit though.

          1. 4

            Docs and Sheets are pretty good for basic stuff. The only downside is I’ve never had them work offline correctly, even on a Chromebook.

            1. 1

              Strange.

              Docs has definitely worked for me offline a couple of times on train rides but haven’t used that recently.

            2. 2

              I thought there must be something better until I used Microsoft Office 365 and was much more annoyed.

              Why would trying those two options give you the impression that there isn’t anything better? LOL just kidding. Try Office 2003.

              1. 3

                We probably have different use cases.

                I mostly have docs with a simple format that I want to collaborate on. E.g. comments.

                I believe that Office 2003 is very capable for traditional office tasks.

                1. 2

                  I used Office in 2003 as a student. It might be fine for “office” tasks, but it was totally inadequate for students. Basic reference management just wasn’t there.

                  1. 1

                    Automated reference management seems like more trouble than it’s worth for the sorts of papers I wrote as a student! Until grad school at least, where everything is LaTeX.

            3. 2

              I’m needing to use Gsuite at my new gig and I think on the whole it’s better than the competition.

              But why oh why does everything default to ‘/edit’ and is there an experienced Gsuite user that can point me to a setting or even Firefox plugin or something to fix that? I suppose I could use Tridactyl to rewrite. I very very often just want to read design docs, not accidentally mash some keys into them.

              1. 2

                IDK, I think Google Docs is pretty good. Especially with the pageless mode. I just stick to the default styles and the only formatting I do is setting headings.

                It’s a bit slow but rock solid and the collaboration is top notch.

                1. 3

                  Especially with the pageless mode

                  It blows my mind that they just introduced this now. Been using this software for over a decade (not by choice) and have never once used it to produce anything that ended up on paper, but for over a decade, every document I worked on had page breaks in it that you couldn’t turn off.

                  Absolutely boggling.

                  1. 1

                    I do agree. I think this is a huge step and hopefully they really take advantage of it. I tried Dropbox Paper which ironically is not so focused on actual paper but it was far too buggy and the collaboration was weak. I guess this will be enough to keep using Google Docs for my D&D notes and stuff.

              1. 1

                This continues to be really fun to see develop.

                Regarding the parenthesis-as-expressions, does this make control blocks like if, while, etc, regular commands, semantically, of the form if EXPRESSION BLOCK, where the expression just follows the normal expression mode rules instead of explicitly requiring parenthesis as a grammar rule.

                I wonder if you could push that further? It might lead you into a remarkably elegant Lispy or Haskellesque territory, and give you fully programmable control flow for free. Very possible this is already the case and I’m not seeing it yet.

                I imagine you’ve caught this, but:

                const myexpr = ^[size > 10]  # unevaluated expression
                const myblock = ^(echo $name)  # unevaluated block
                when (myexpr, myblock)
                

                sort of asks to be rewritten as:

                const myexpr = ^(size > 10)  # unevaluated expression
                const myblock = ^{echo $name}  # unevaluated block
                when (myexpr, myblock)
                

                You’re in the verge of ^ as quotation, there, which would be incredible.

                I imagine keeping all of this compatible-ish with Bash is always a constraining factor, so if these are made impossible by that I’d be super curious as to why.

                1. 2

                  Yes great points! I’m glad someone is paying attention :)

                  For the first question, if and while are a special keywords basically because they are in shell, and I implemented them a long time ago. But I posted this same question on Zulip today under this post!

                  https://oilshell.zulipchat.com/#narrow/stream/202008-oil-documentation/topic/Winter.20Blog.20Backlog.3A.20Recent.20Progress

                  So I am wondering if it is confusing that the syntax is the same, but they mean different things. But in practice I’m not sure if there are any real consequences, other than the fact that you can’t redefine if as a function. And I don’t really want that. Testing and feedback is appreciated!


                  And yes there is an inconsistency in the punctuation. I documented that here:

                  https://www.oilshell.org/release/0.9.5/doc/warts.html#two-different-syntaxes-for-block-and-arglist-literals (some old syntax here; just corrected at HEAD)

                  But the basic reason is that we already solve the problem of parsing $(echo hi) and the closing paren, which is actually quite difficult because parens are used in so many places, and can be unbalanced in case statements. (The AOSA chapter on bash which I refer to talks about this problem.)

                  Parsing $[echo x] and ${echo hi} is actually even more difficult, because neither of them are operator characters. Unquoted [] can be globs or the test builtin, and unquoted {} can be brace expansion or brace groups.

                  So I avoided those, and made ^(echo hi) consistent with $(echo hi). (And we also have @(echo hi) for split command sub.) The syntax is basically consistent with shell. If you think about it, shell also has $(echo hi) for command sub and { echo hi; } for blocks.


                  Originally I did specify that command sub was $[echo hi], because [] was supposed to be for “words” and () was supposed to be for expressions. But that collided with reality!

                  So it is a wart, and a documented one, but I’m actually OK with it because I think those unevaluated expressions will be very rare in real code. They are probably only going to be used for framework and library code (which I also hope will be rare!)

                  I did spend a lot of effort trying to make all the sigils and punctuation consistent, and wrote a whole doc about it!

                  https://www.oilshell.org/release/0.9.5/doc/syntax-feelings.html (feedback welcome)

                  Let me know if you see any other inconsistencies :)

                  1. 3
                    • (): is a command

                    • $(): $ means string / scalar, () is a command

                    • ^(): ^ means quoted, () is a block

                    • @(): @ means array / splice, () is a command

                    • %(): % means unquoted, () is an array literal (sequence of words)

                    • {}: brace expansion or brace groups

                    • ${}: $ means string / scalar, {} is variable substitution (its own insanity)

                    • ^{}: ^ means quoted, {} is … nothing? It was an expression.

                    • @{}: is a syntax error

                    • %{}: is … nothing?

                    • []: is a list (sequence in the docs)

                    • $[]: is … nothing?

                    • ^[]: ^ means quoted, [] is an expression

                    • @{}: is a syntax error

                    • %{}: is … nothing?

                    Even with oil and the docs both open, I don’t feel confident with my above listing.

                    Is there a table somewhere? This feels like Perl-level inconsistency.

                    1. 1

                      The appendix is out of date, I just pushed a change [1], although I’m still confused where you got a lot of those. For example () isn’t a command; it’s a type arg list to a command as shown in the blog post.

                      The best overview at the moment is the tour:

                      https://www.oilshell.org/release/latest/doc/oil-language-tour.html

                      Here’s a short way to think about it. Let’s start with the following axioms from shell:

                      • $var and ${myvar}
                      • $(command sub)
                      • most other things about shell are discouraged/deprecated in Oil, particularly $(( )) and bash’s [[ and ((
                      • { echo 'brace group'; } is { echo 'brace group' } in Oil

                      Then in Oil, you have command vs. expression mode:

                      https://www.oilshell.org/release/latest/doc/command-vs-expression-mode.html

                      Expression mode is like Python / JavaScript! Generally this code has very few sigils and “sigil pairs”. It looks like

                      const x = f('mystr', [], myvar)
                      
                      • {} [] () mean what they do in Python / JS – dict, list, parenthesized expression
                      • we also have %(foo bar) which is identical to ['foo', 'bar']. It’s like Perl’s qw//. Words are unquoted.

                      Then in command mode:

                      • Word splitting is explicit rather than implicit. So we need:
                        • Explicit splicing of array variables with @myarray
                        • Split command sub with @(command sub)
                        • These are analogous to the two above
                      • We also have expression sub, which is $[1 + 2].
                      • You can pass { echo hi } as a trailing block arg, which is consistent with shell’s brace groups.

                      Everything else should be quite rare. The inconsistent unevaluated expressions are a wart, but as mentioned very rare. Also, that part is less implemented (though everything in the Tour is verified to work).

                      Does that make sense?

                      %{} and @{} don’t have any obvious meaning I see. I guess you could argue that @{myarray} should mean splicing, but it’s superfluous considering the meaning of $myvar vs ${myvar} (which is purely syntactic).

                      [1] https://github.com/oilshell/oil/commit/7adffce97ba8619f9fb866b1d185c1f0d6cd45b3

                      1. 1

                        Does that make sense?

                        Not really, no. That’s why I asked if there was a table.

                        I’m still confused where you got a lot of those.

                        oil -n -c '…' mostly.

                        1. 1

                          This table is updated (and will be published with the next release).

                          https://github.com/oilshell/oil/blob/master/doc/syntax-feelings.md

                          You have to take into account the valid contexts (command, expression or both), and what’s inside (either commands, expressions, or words).

                          1. 1

                            Thanks mate; I gave a look and it’s a lot more clear!

                            Am I blind, though, or is it missing normal ’ol $variable / ${variable}?

                      2. 1

                        Another thing to note that % does not mean hash, like it does in Perl. $ and @ do mean string and array respectively, so this could be confusing.

                        Oil doesn’t need any sigil for hash, because expression mode is different than command mode. The sigils are used mainly in command mode.

                    1. 2

                      The opposite: “false” is the absorbing element for boolean and, but here we’re talking about “true” - which the identity element for binary and.

                      1. 1

                        Ah, thanks.

                    1. 17

                      Do not delete the path part of that URL, yikes.

                      Anyway, what is “Suckless”? That’s what I was trying to see, and instead got an image of a naked man holding a bottle of wine.

                      1. 16

                        For Suckless, see https://suckless.org/, not the users subdomain.

                        It’s a project/group related to cat-v and classical-unix/plan9 advocacy, rejecting tools that “suck” and wanting to replace them with “simpler” alternatives (dwm for window managment, st for terminals, dmenu for reading keyboard input, …). This often entails that configurations have to be applied pre-compilation and that the default distributions of various tools and projects are pretty lean – hence additional features are collected as patches, which are listed here, showing which can be successfully applied, and which can’t.

                        1. 4

                          I can report that dwm and st are great tools.

                          The only hitch is recompiling them after modifying their configuration files, which are written in C. Many people don’t like this. Some, like myself, don’t mind.

                          1. 3

                            I used st (off and on) for a while (~1yr), and for me the biggest annoyance was having to rebase some patches when multiple patches modify similar lines of code. Once that headache was resolved, it was generally OK unless some st commits triggered rebasing some stuff again. Basically it was all the fun of maintaining your own branch of st with patches someone else wrote.

                        2. 13

                          Suckless was in its heyday around the time of the systemd eruption, as far as I know. This would be around 2010. Slightly prior was this one weird viral video of an artist named Gunther, a self-styled “sex prophet,” who made the rounds with a (completely SFW in the most technical of senses, though apparently not germane to your sensibilities, bheisler, which is fine with me, thus this explanatory note to lessen the blow of freakishness herein) music video called “Ding Ding Dong.” Pop music beats, euro summer beach ditzy style. Not amazing, but pretty good, definitely unique. The naked man is that same gunther. Just wanted to clear that up, because this is a clear case of an overreaction to a misunderstood joke. As far as I know, the suckless community was and is to the extent that it still exists, pretty insular. Probably didn’t anticipate being posted on an HN style board

                          1. 7

                            Probably didn’t anticipate being posted on an HN style board

                            Lobste.rs has even “suckless developer” hat used by several people. Not quite buying the unanticipated part.

                            1. 1

                              Reasonable.

                              Would you, however, admit that Gunther, the individual who presumably is the man behind gunther.suckless org, is not the OP of this link?

                              In admitting this, if you do admit this, are you not therefore forced to agree with me that the post we’re discussing was not intentionally put forth as a display of nudity to eyes averse to that same nudity?

                              If a list of patches to utilities and other programs is hosted at a path of a subdomain which contains the image a naked man holding a vertical wine bottle (with suggestive verticality) is posted without awareness of the suggestive verticality of said bottle, then can’t we conclude that the proximate nature of that suggestively vertical bottle to said list of patches to utilities and programs is in some sense accidental, and therefore unanticipated?

                              By this argument, I intend to demonstrate that your claim, while seemingly reasonable, is eliding the quite clear nature of the circumstances, in an effort to maintain that all suckless developers and subdomain holders should be aware of all possible audiences for their online “speech” (or however you wish to define what the image is), when in fact it is absurd to believe that all speech of all suckless developers would be anticipated to agree with all possible audiences. I’m afraid that, unless Gunther appears to justify his position, we’ll have to remain in a misunderstanding silence regarding the reason why a suggestively vertical bottle and naked man are so closely associated with this list of patches.

                              I tried to explain it, because it seemed necessary to explain, to me. Perhaps one day, your doubt regarding this explanation will itself be exposed to the eyes of someone on a far away news site, and they will be as horrified as if they had seen a vertical and suggestively placed bottle.

                              1. 2

                                @varjag simply wanted to inform you that @FRIGN not only has an account here, but also has the [suckess.org developer] hat. So a lot of the community knows about Suckless (presumably not @bheisler, who asked the question in the first place).

                                I must confess to be in the same position as @bheisler. I knew of suckless, but had no idea what the linked page meant in context of that project.

                            2. 3

                              So the guy probably thought since he had the same name as this weirdo that for internet reasons (remember when memes were cool and unique signifiers of in-group identification?) it would naturally follow to have him around on the ol’ personal page

                              1. 2

                                Sorry for the long-winded explanation, but I miss the old web, and I am not even old! Would you, Herr heisler, have been hip to a tidy game of Flash-powered Sandspiel, even if it were on a subdomain of ebaumsworld?

                            3. 8

                              The suckless project makes and maintains a bunch of Unix programs that meet their definition of “sucking less” - http://suckless.org/philosophy/

                              I’ve been caught off guard by them offering personal subdomains on their site before, too - suckless.org is SFW, but any individual subdomain?

                              I use and like dwm when I can.

                              1. 17

                                They like to send mail from hosts with names like wolfsschanze. You can also see FRIGN’s opinion about diversity as shared on lobsters. Or the time someone pointed out there are torchlit marches at suckless conferences and someone else asked FRIGN to clarify and he basically admitted to being a white nationalist, complete with dogwhistles like “cultural marxism”?

                                I’m not saying that suckless is definitely a white nationalist organization but I am saying someone would have to do a lot of work to convince me otherwise.

                                1. 4

                                  Must we do this everytime someone posts something suckless related? Can we please just talk about technology instead of all this political nonsense and random accusations?

                                  1. 13

                                    Look, for every person who thinks this is “political nonsense and random accusations,” there’s at least one person who thinks this is so damning that they want literally nothing to do with suckless ever again.

                                    And despite Lobster’s general “politics is off-topic” policy, this thread is literally someone asking “what is ‘Suckless’?”, so if it’s on-topic anywhere, it’s here.

                                    1. 2

                                      Please see my reply above.

                                      1. 5

                                        Um. Welcome to lobsters? A couple of words to a wise guy:

                                        1. Your previous comment is not “above” this one. The whole tree gets reordered based on upvotes.
                                        2. That stream-of-consciousness-wall-of-text style may play well wherever @enkiv2 invited you from, but it’s gauche here. At least, I find it exhausting more than amusing.
                                        3. For heaven’s sake, please don’t feed the trolls! No matter how many big buckets of troll slop you may have handy.
                                        1. 0

                                          Thank you, minimax! – for your welcome, since it is utterly welcoming. A couple more words in response, and whether they contain a wisdom equivalent to my similar and apparently inherent quality of same is entirely your determination. I am so grateful to have run into an authority on these matters. Perhaps you can finally solve the trolley problem for us all, and divide good people from bad ones, as you scry into your palantir of forum posts.

                                          To wit -

                                          (1) My previous comment is in a tree of comments.

                                          (a) What is the precise and preferred nomenclature, such that an ignoramus could understand?

                                          (b) In the sense that a tree (such as this comment tree) goes from a single node to plenty of nodes, is it entirely inappropriate to say “above” in order to indicate, where n is the depth indicated away from the origin, trunk, root, or base of the tree, the position n - 1? I understand if your perspective is like the protagonist of Ender’s game, and you feel like n-1 compared to n is down, not up, but Ender held that of his enemies, and I am not yours. Are you mine?

                                          (2) I don’t care. Actually, like a total four-year-old, I feel an evil glee.

                                          (a) When you say, “stream-of-consciousness-wall-of-text,” you are committing a grammatical error by hypenating between “chunks” of words. One noun is “stream-of-consciousness” and the other is “wall-of-text,” and, while neither necessitates hyphens, it is an elegant stylistic choice, and redounds back upon my usage of “implied-by-you.” But the nouns you connected simply don’t need to be joined. In fact, they should be separated by a comma. I’m running out of breath just looking at it.

                                          (b) Gauche – what is the meaning of this word in the sense you’re applying?

                                          (b, cont.) John Ohno is no concern of yours in this regard, is he? What are you, a partisan of webbiness that wants to condemn hypertext? What beef could you possibly have with the guy? How do you even go from his proto-post-communism on the one hand and quasi-Ludditic radically conservative ideals of “small computing” on the other, to me? Am I to consider you as thinking that my response, “below,” (in opposition to ngoldbaum’s unfair condemnation of an entire ideal of technical practice in contemporary FOSS on the basis of his own flawed reasoning, equating cultural marxism, which predates the ilk whom ngoldbaum is, in abject ignorance, confusingly attempting to condemn, by about 45 years) the same as enkiv2’s opinions?

                                          (b, cont.) That you find it exhausting to read: good for you. :)

                                          (3) This would be humorless, except it is meaningless.

                                          Please, oh minimax, solve the trolley problem, since you know how to identify trolls and can give advice to the gauche. I am happy to lay on the tracks if you want to flip that switch to experimentally determine once and for all whether it is worth saving some arbitrary group of people as opposed to me. Regarding the basic subject matter at hand, which is suckless, and someone’s unfair-in-my-opinion (see how that’s grammatical?) condemnation of suckless, I should say that I find a policy of opposition to affirmative action intolerant. I support techne, and it follows that I support suckless. It does not therefore follow that I support what ngoldbaum very confusedly understands to be a persecution of the Jews by FRIGN. This seems absurd to have to point out, but here we are. Again: I find intolerance disgusting. I also find vendettas disgusting. Lastly, I find hubris disgusting. I am painfully aware that I, too, sadly lack the cleanliness that would come with an absence of this very quality. However, you have to admit, your hubris in judging me is incomparably greater than my hubris in defending myself against your allegations of . . .

                                          1. Being a “wise guy.”
                                          2. Having a “gauche” “style.”
                                          3. Having an exhausting and unamusing style.
                                          4. Feeding the trolls, in contradiction to the “sake of heaven.”
                                          5. Having handy “troll slop.”

                                          Your welcome is most welcome.

                                          And you’re welcome.

                                          Regards,

                                          Myself

                                          P.S.: “A couple of words” is merely a figure of speech! And you don’t have to type “um,” even if you habitually say it!

                                          1. 4

                                            This sardonic flippancy is tedious and unwelcome. Please treat others better than this.

                                            1. 2

                                              Noted

                                            2. 1

                                              (a) What is the precise and preferred nomenclature, such that an ignoramus could understand?

                                              I prefer to simply provide a link to the comment.

                                              (2) I don’t care. Actually, like a total four-year-old, I feel an evil glee.

                                              This is not a good attitude to have on Lobste.rs.

                                              (b) Gauche – what is the meaning of this word in the sense you’re applying?

                                              I’m not @minimax, but I would read it as “socially awkward”.

                                              (b, cont.) John Ohno is no concern of yours in this regard, is he?

                                              Actually he is, as he invited you and has a certain responsibility for that invitation.

                                              1. 2

                                                Yeah, um, @lettucehead, please don’t get yourself banned. I would not have invited you if I didn’t expect you to acknowledge community norms & practices.

                                                1. 0

                                                  I just saw your reply to this thread, and I want to thank you again for the invite, and assure you that I won’t be a troll or otherwise possess sardonic flippancy in the future. Well I will try to tone it down. A lot.

                                                  I still have all my questions from this thread (how the heck can somebody using the words “cultural Marxism” to discuss radical forms of Marxism having to do with culture, which are genuine phenomena, be considered an anti-Semitic “dogwhistle?” Why was I considered a troll for pointing out this exhausting and unfair absurdity? Will pushcx ever change his mind about my sardonic flippancy, and see it for the charmingly wonderful firehose of Furby-faced unicorns it really is? Like the center of a Tootsie Pop’s per-lick depth scalar, the world may never know)… Thus I have decided to just let it go. Or maybe I’ll start a tech blog and collect $20 from Drew DeVault.

                                                  I just wanted to make a splash. I will certainly be more careful moving fwd, and not imperil your reputation. Any further than you yourself do all the time with all the “small computing” heresies I hear you’ve been spreading among the faithful, turning Microsoft customers into the reprobate worshippers of Alan Kay. Tsk, tsk. Cheers

                                    2. 1

                                      Hey, because minimax decided to play mod with my “gauche style,” and I suspect he just disagrees with what he believes to be my assumptions about what you said, I have some further, legitimate, serious questions. What can you say to substantiate your reduction of the “stream-of-consciousness, wall-of-text style” (to use minimax’s phrase with my improvement) post by which FRIGN “[clarified,] and … basically admitted to being a white nationalist,” in the torchlit marches link, above?

                                      I’m honestly confused, I just don’t see how you get that from what he said. Can you, please, substantiate your reduction of what he actually said, to what you said he said?

                                      Or, can you remove your unnecessarily politicizing post, in violation of pushcx’s general wishes for this forum? I will happily delete (or respect the deletion of) my replies to it, so that we’re “even.” But let it be known, I do wish substantive answers because I am sincerely curious about your opinion and understanding, and would rather not have the kabosh put on a polite and principled discussion. We’re all crustaceans here, instead of denizens of the orange site, because the discussion is of a much higher quality. At least, that’s what I’m here for, and I care deeply about that.

                                      I should also add that I never would have been aware of any rift between certain members of this community were it not for one of your posts on almost the exact same subject several months ago, and while I have picked on specific points of contention regarding the “dogwhistles,” I was glad to receive the intelligence represented by your… saintly screeds… in this regard, both initially and now.

                                  1. 2

                                    Until I switched to Linux permanently, I always installed a program that reinstated Clarus to her proper place in the OS X print preview window.

                                    In retrospect, I think it should have been obvious as soon as Clarus was removed that Apple was no longer making the operating system I really wanted anymore.

                                    1. 12

                                      The linked Systemd bug is painful to read and terrifying — it sounds like Poettering mighty have zero idea how a CSPRNG works?

                                      1. 7

                                        Can you elaborate? It seems to me that he’s saying:

                                        1. systemd wants cryptographically random keys, but it’s ok if the initial keys aren’t cryptographically secure, because they’ll be resized with new keys later on
                                        2. /dev/urandom gives us that, without blocking
                                        3. reading from /dev/urandom early on does not “deplete its entropy”

                                        I had thought that claims #2 and #3 are true. I guess maybe #1 isn’t obviously true, if there’s some crazy attack vector that invalidates it, but it’s not really about CSPRNGs anyway. So even if it’s wrong, it wouldn’t mean he misunderstands CSPRNGs. Am I missing something?

                                        1. 3

                                          You know, I think you’re actually right. There’s a few statements in there that read like Poettering thinks there’s good and bad entropy, or that the concept of deleting the entropy pool is meaningful, but I think he’s actually only taking about the state of the CSPRNG early in the boot process when it may have not been seeded properly.

                                          On the other hand, I do think the unwillingness to minimize competition for entropy during early boot is a pretty weird attitude.

                                          1. 10

                                            Yeah, #1 is still weird to me. Surely, cryptographically secure keys for systemd’s hash tables are either a security requirement during early boot, or they are not. It feels really weird to see the alleged need for secure keys used as a justification for the current behavior, while also claiming that it doesn’t matter that they aren’t secure. Subjectively, the impression I get is that it’s motivated mostly by a desire to avoid having to reason out what the threat model actually is here.

                                            1. 5

                                              It’s necessary for the keys to be hard to guess for an attacker, which generally means some kind of cryptographically secure. However, there generally aren’t any attackers during early boot, an even if there was, and the attacker could potentially guess the value of the key during early boot, the keys would be periodically re-generated as the attacker is attacking, and as soon as the CSPRNG is properly initialized, any new keys will be hard to guess.

                                              Specifically, the random keys are necessary because in regular hash tables, an attacker who can insert something in the hash table can exploit pathological cases in the particular hash function used, turning the hash table’s O(1) lookup into O(n) lookup. The random key prevents the attacker from doing that without knowing the random key. Also, whenever the hash table gets big enough, a new key is chosen as part of the process of expanding the table.

                                              Systemd knows exactly their threat model; it’s unlikely that there are attackers during early boot, and even if there are, the early boot stage lasts a short enough time that it’s likely not a big issue; therefore, urandom’s semantics of “give me the best random numbers you have available, but if it’s too early to give cryptographically secure numbers, that’s okay” is precisely the behavior they want.

                                              Keep in mind that we’re not talking about an information leak or RCE vuln; an attacker being able to guess keys only results in a partial DoS where O(1) access turns into O(n) access for a limited time.

                                              Also keep in mind that reading from urandom doesn’t actually hurt anything (at least from what I understand); it doesn’t deplete any randomness (because that’s not how CSPRNGs work), and it simplifies systemd’s code in a relatively critical area which reduces the chance of bugs causing vulnerabilities. The only issue, from what I understand, is that the kernel will print warning messages about it and that makes it harder to find actual security issues caused by reason from urandom too early.

                                              1. 5

                                                Yeah, that all matches my understanding of the discussion on the bug. I guess I disagree that the described harm of obscuring other issues isn’t an important one.

                                                It does seem like the most reasonable course of action would be to make sure the code in systemd draws a clear distinction between early boot and later steps, and uses different sources of randomness. The current situation seems really bad to leave in place because nobody can actually reason about which security mitigations are in effect when.

                                                I’m broadly supportive of the systemd approach of making daemom-starting infrastructure into a monolith, but it does come with a responsibility to at least work to keep security parity with the tooling it replaces. Seeing that the maintainer is apparently quite averse to that gives me serious doubts about the wisdom of the project.

                                                1. 9

                                                  I’m broadly supportive of the systemd approach of making daemom-starting infrastructure into a monolith, but it does come with a responsibility to at least work to keep security parity with the tooling it replaces. Seeing that the maintainer is apparently quite averse to that gives me serious doubts about the wisdom of the project.

                                                  This is the recurring, sinking feeling I get every time one of these Systemd issues pops up. In isolation, it’d be easy to ignore, but as a pattern it makes me feel like we have an increasingly large fraction of userspace managed by folks who are unwilling to consider their role in the Linux ecosystem special in any way.

                                                  Sure, Linux got /dev/urandom wrong, but pretending that init doesn’t have a particular responsibility to manage that wrongness is an attitude that worries me.

                                                  1. 2

                                                    Yes. I have definitely seen that attitude on other systemd controversies, as well.

                                                  2. 3

                                                    I completely, 100% agree that systemd should make absolutely sure not to produce messages which obscure actual security issues. It’s scary to see Poettering saying that they aren’t responsible for “misguided” messages for the kernel when any other process reading from urandom before it’s inited would be a security issue. Blaming the kernel and saying it should change is unacceptable, unless it’s actually followed by seriously working together with the kernel people to get the problem systemd is causing fixed.

                                                    I was just trying to correct the misconceptions around this, and point out that this doesn’t represent a security issue or an attack vector they haven’t thought through.

                                                    1. 2

                                                      I definitely think you’ve done a good job of clarifying a situation that there seems to be a lot of confusion around. Before reading the bug thread, I hadn’t realized what a divisive topic randomness apparently is. Your explanation was very clear, and I thank you for it.

                                          2. 4

                                            The author notes that he has seen the issue for the first time on Alpine Linux, which doesn’t use systemd. So while systemd might make things worse, the real culprit is that the Linux kernel should’ve copied what OpenBSD does instead of inventing their own scheme which leads to this exact issue.

                                            1. 1

                                              There are 2 problems at work here:

                                              1. The entropy file that openbsd has and uses to initialize the random generator, is not always available or sufficient.
                                              2. Systemd uses a lot of the entropy which is scarce at boot time, and use of the scarce resource could potentially be avoided.

                                              So we can’t mindlessly apply the solution of OpenBSD and we should know that systemd makes this issue worse. The problem exists because of these two circumstances and could be relevant for consideration in various use-cases.

                                              1. 4

                                                Entropy cannot be used up. Repeat: entropy cannot be used up. To think that it can be is outdated 90s-style crypto thinking.

                                                All you need is a single 256-bit seed; you then can emit random numbers pretty much forever. You don’t need to worry about using up entropy (although it is a good idea to change the seed over time, in order to protect against state compromises).

                                                The Linux kernel CSPRNG is broken, period: it should never not return random numbers, once properly seeded. And seeding is pretty easy, too: write a random number to a file at install time, at boot and at shutdown, and/or use RDRAND, and/or use virtio-rng.

                                          1. 3

                                            There should be a name for this class of vuln, where every program implements its own privilege escalation. The pseudo sudo.

                                            1. 3

                                              Sudon’t?

                                            1. 3

                                              This is the most pleasant thing I’ve used, by far: https://github.com/mbrubeck/compleat

                                              It’s not entirely flexible enough, but it is far more pleasant than anything else I’ve dealt with.

                                              1. 2

                                                Thanks this looks really interesting! But does it have a large body of existing completions? Are you using it, or is it something you’ve written a completion for.

                                                It looks more principled, but yeah I think the DSL approach falls down when you need to handle special cases, and there are a lot of them in shell.

                                                Example corner case: after -c in Python and shell, the remaining things are arguments, not flags. You don’t need to use -- to end the flags in that case.

                                                I would like something more principled than bash or zsh for sure. But I also don’t want to rewrite completions for the world, or even start an entirely new body of completions. I’m open to more info on this though.

                                                1. 2

                                                  So I only know of a a few pieces of software that actually ship with completions written for it (e.g., polyglot), but I do use it actively and write my own completions. It’s my go-to tool whenever something lacks completions and it starts to bug me.

                                                  While it can be somewhat limiting, it does allow you to do some reasonable interesting things since you can shell out. The only issue I’ve run into that I couldn’t work around was trying to write completions for the heroku command, which uses subcommands of the form heroku access:add, heroku config:get, etc. Something about the notion of a word boundary and the colons did not mix. I eventually abandoned the issue since Heroku started shipping decent shell completion with their CLI.

                                                  Some examples of the more elaborate ones I’ve written can be found here: https://gist.github.com/cmhamill/a7e39eb576f83292cfb09f2e3d0090ed

                                                  1. 2

                                                    Thanks for the examples! Yeah this does look nice.

                                                    If I were to do something like this, I’d probably want to let you mention an arbitrary function in the DSL, to solve the problem of needing to do “weird” stuff. I imagine it’s something like parser combinators.

                                                    Also I don’t think the DSL should hard-code its notion of tokenization, which seems like why you ran into : problem.

                                              1. 5

                                                I passed this around a few friends in my professional network who have used AWS extensively in the past, and some of whom still use it now. Results ranged from 3/20 (me, anti-bragging rights, lol) to 7/20. AWS’s visual and interface design is truly in a league of its own in terms of utter hostility to users.

                                                1. 4

                                                  I’m an operations professional who set up the AWS infrastructure for a “hip, well-funded startup,” and I’m here to join the 3/20 club.

                                                  I did get the color of the Node.js SDK right, which I’m proud of, having never noticed the logo consciously.

                                                1. 2

                                                  Here’s a question for the ages: are there any actually-existing good hosted CI providers out there?

                                                  1. 7

                                                    Not if you need speed: http://bitemyapp.com/posts/2016-03-28-speeding-up-builds.html

                                                    I would honestly pay good money for reliable, tested deployment automation that stood things like CI up.

                                                    1. 1

                                                      Who’d you end up going with for the dedicated server / what are the specs on that machine like?

                                                      1. 2

                                                        Approximately this with NVMe RAID: https://www.ovh.com/us/dedicated-servers/infra/173eg1.xml

                                                        tbqh, most the time we saved on compilation was lost to the GHCJS build later on. I was very sad.

                                                    2. 5

                                                      We use buildkite at my company. One nice aspect is that we get an agent to run on /our/ “hardware” (we just use large vm instances). It works pretty well.

                                                      1. 3

                                                        Another vote for buildkite here - their security posture is markedly better and you have much more control over performance.

                                                        1. 2

                                                          It’s probably worth mentioning here that GitLab offers similar functionality with their GitLab CI offering. You can use their infrastructure or install runners (their equivalent of agents) on as many machines as you like. Disclaimer: I haven’t used either yet but attended a meetup event where somebody praised them highly and ditched their Atlassian stack for that single reason.

                                                          1. 1

                                                            Their website looks intriguing could you elaborate on their security posture? Is it just an artifact of the on-premise build agent, or is there more to it than that?

                                                        2. 5

                                                          If you happen to run on Heroku, Heroku-CI works quite well. You don’t wait in a queue—we just launch a new dyno for every CI run, which happens while you blink. It’s definitely not as full features as Circle, or even Travis, but it’s typically good enough.

                                                          1. 1

                                                            At $WORK we run some things on Heroku but we can’t or don’t want to for most things — it’s either too expensive or the workload isn’t really well-suited for it.

                                                          2. 4

                                                            What do you need? I like Travis, they also get vastly better when you actually use the paid offering and they offer on-premise should you actually need it.

                                                            1. 2

                                                              I need builds to not take 25-30 minutes.

                                                              Bloodhound averages 25 minutes right now on TravisCI and that’s after I did a lot of aggressive caching: https://travis-ci.org/bitemyapp/bloodhound/builds/286053172?utm_source=github_status&utm_medium=notification

                                                              Gross.

                                                              1. 2

                                                                I was asking cmhamill.

                                                                But, just to be clear: your builds take 8-14 minutes. What takes time for you is the low concurrency settings on travis public/free infrastructure. It’s a shared resource, you only get so many parallel builds. That’s precisely why I referred to their paid offering: travis is a vastly different beast when using the commercial infrastructure.

                                                                I also recommend not running the full matrix for every pull request, but just the stuff that frequently catches errors.

                                                                1. 3

                                                                  I was asking cmhamill.

                                                                  You were asking in a public forum. I didn’t ask you to rebut or debate my experiences with TravisCI. https://github.com/cmhamill their email is on their GitHub profile if you’d like to speak with them without anyone one else chiming in. I’m relating an objection that is tied to real time lost on my part and that of other maintainers. It is a persistent complaint of other people I work with in OSS. I’m glad TravisCI’s free offering exists but I am not under the illusion that the value they’re providing was brought into existence ex nihilo with zero value derived from OSS.

                                                                  It’s a shared resource, you only get so many parallel builds. That’s precisely why I referred to their paid offering: travis is a vastly different beast when using the commercial infrastructure.

                                                                  We use commercial TravisCI at work. It’s better than CircleCI or Travis’ public offering but still not close to running a CI service on a dedis (singular or plural).

                                                                  I had to aggressively cache (multiple gigabytes) the build for Bloodhound before it stopped timing out. I’m glad their caching layer can tolerate something that fat but I wish it wasn’t necessary just to keep my builds working period.

                                                                  That combined with how unresponsive TravisCI has been in general leaves a sour taste. If there was a better open source CI option than something like DroneCI I’d probably have rented a dedi for the projects I work on already.

                                                                  1. 5

                                                                    You were asking in a public forum. I didn’t ask you to rebut or debate my experiences with TravisCI.

                                                                    You posted in a public forum and received some valid feedback based on the little context of your post ;)

                                                                2. 1

                                                                  How long does it take on your local machine as a point of comparison?

                                                                  1. 2

                                                                    https://mail.haskell.org/pipermail/ghc-devs/2017-May/014200.html

                                                                    That’s just build, doesn’t include test suite, but the tests are a couple more minutes.

                                                                    1. 1

                                                                      Hm, that’s roughly the time your travis needs, too?

                                                                      https://travis-ci.org/bitemyapp/bloodhound/jobs/286053181#L539 -> 120.87s seconds

                                                                      1. 0

                                                                        Nope, the mailing list numbers do not include --fast and that makes a huge difference.

                                                                        You are off your rocker if you think the EC2 machines Travis uses are going to get close to what my workstation can do.

                                                                        1. 2

                                                                          Would you rather pay for a licensed software distribution that you drop in a fast dedicated computer you’ve bought and it turns that computer into a node in a CI cluster that can be used like Travis?

                                                                          Would you rather pay for a service just like Travis but more expensive and running on latest-and-greatest CPUs and such?

                                                                          1. 3

                                                                            Would you rather pay for a licensed software distribution that you drop in a fast dedicated computer you’ve bought and it turns that computer into a node in a CI cluster that can be used like Travis?

                                                                            If it actually worked well and I could test it before committing to a purchase, probably yes I would prefer that to losing control of my hardware or committing to a SAAS treadmill but businesses loooooooove recurring revenue and I can’t blame them.

                                                                            Would you rather pay for a service just like Travis but more expensive and running on latest-and-greatest CPUs and such?

                                                                            That seems like a more likely stop-gap as nobody seems to want to sell software OTS anymore. Note: it’s not really just CPUs, it’s tenancy. I’d rather pay SAAS service premium + actual-cost-of-leasing-hardware and get fast builds than the “maybe pay us extra, maybe get faster builds” games that most CI services play. Tell me what hardware I’m actually running on and with what tenancy so I don’t waste my time.

                                                                3. 1

                                                                  Has anyone done this kind of dependency scan on Travis that this guy did on CircleCI? I suspect you will see much the same.

                                                                  Travis does have one clear advantage here in that it’s OSS so you can SEE its dependencies and make your own decisions. See my note about CircleCI needing to be better about communication above.

                                                                  1. 3

                                                                    Well… “scan”. They posted a screenshot of their network debugger tab :).

                                                                    Travis (.org) uses Pusher, but not their tracking scripts. It integrates Google Analytics and as such, communicates with it. ga.js is loaded from google.

                                                                    The page connects to:

                                                                    • api.travis-ci.org
                                                                    • cdn.travis-ci.org (which ends up being fast.ly)
                                                                    • gravatar.com (loading avatar images)
                                                                    • statuspage.io (loading some status information as JSON)
                                                                    • fonts.googleapis.com (loading the used fonts)
                                                                    • ws.pusherapp.com

                                                                    All in all, it is considerably less messy then circle-ci’s frontend.

                                                                    Also, Travis does not have your tokens or code in their web frontend, code is on Github, tokens should be encrypted using the encrypted environment: https://docs.travis-ci.com/user/environment-variables#Defining-encrypted-variables-in-.travis.yml

                                                                    1. 2

                                                                      You have proven my point perfectly.

                                                                      CircleCI’s only sin here is one of a lack of communication. There is nothing actually wrong with any of the callouts the article mentions, they just need to be VERY sure that their users are aware of exactly who is seeing the source code they upload. This should be an object lesson for anyone running a SaS company, ESPECIALLY if said SaS company caters to developers.

                                                                      1. 4

                                                                        This is not an apples to apples comparison, in my post I cited Javascripts only (which can make AJAX requests and extract source code), @skade cites that Travis loads fonts, images, and CSS from third party domains, which don’t have those properties; a compromise in CSS might change the appearance of a page but generally can’t result in your source code/API tokens being leaked to a third party.

                                                                        As far as I follow the only external Javascript run by Travis CI is Pusher. So, no, it has not proven your point perfectly, in fact it demonstrates the opposite.

                                                              1. 4

                                                                I’ve taken to setting $XDG_CONFIG_HOME to ~/etc, which just seems obviously correct, in retrospect.

                                                                1. 2

                                                                  Why not $XDG_CONFIG_HOME=$XDG_DATA_HOME/../etc/?

                                                                  I think that would look nicely with the pattern of having $XDG_DATA_HOME/../bin/ as an additional $PATH entry.

                                                                  1. 1

                                                                    I’ve done that before, too, but I find that I reach for things in $XDG_CONFIG_HOME often enough that it got annoying. At this point, I feel slightly more likely to set $XDG_DATA_HOME to ~/share. I already have ~/bin, but I tend to make a Debian package out of most tools I write once they stabilize, anyway. I just need to find a good place for $XDG_CACHE_HOME, which I currently have set to ~/.local/cache. It’s the one XDG directory whose contents I never care to get at easily, but I also need to be on reliable storage. I might stick it somewhere in /var/tmp/$(uid) or whatever the one that the FHS says should persist across reboots is. I could just commit to my bull shit and use ~/var/cache, though. Or just ~/var, since it will be the only directory in there. ~/cache feels the most “correct” but also really aesthetically terrible. Oh well.

                                                                  2. 1

                                                                    How is that correct? Everyone who logs in all get the same configs. The whole point of dot files in ~/ was so it would only affect you.

                                                                    1. 2

                                                                      There’s still a tilde, just not a dot.

                                                                      1. 2

                                                                        You’re right. I completely missed that.

                                                                  1. 6

                                                                    What the fuck has happened to Unix?

                                                                    1. 20

                                                                      I like this comment because you could mean it three ways:

                                                                      1. What is wrong with kids these days and their XDG crap? Dotfiles are a perfectly good solution and aren’t visible in ls output by default, anyway.

                                                                      2. What has happened to Unix, that so many programs need to specify configuration data in $HOME? Well-designed Unix programs should be simple enough to need no configuration in the vast majority of cases.

                                                                      3. Hiding files beginning with a . was a terrible idea totally out of whack with the rest of the Unix ethos. It’s up there with filesystem links and BSD sockets for worst additions to the system.

                                                                      I vote for option three, but which one were you going for?

                                                                      1. 2

                                                                        1 and 2. . is a hack, but filesystem links were and are a great idea, and bsd sockets is why you are reading this.

                                                                        1. 3

                                                                          I mean, on the one hand, fair enough.

                                                                          On the other hand, symlinks (in comparison to hardlinks, I should have been more specific) remove the guarantee that the filesystem can be modeled as an acyclic graph. In addition, every program has to handle symlinks: make a decision whether to treat them like the files they point to or like stub files that point to a path name; deal with symlinks to non-existent files; properly follow symlinks to resolve files when needed — it’s not even possible, because of this, to correctly display the current directory in Unix 100% of the time. Bash tries to track where you last were before you ran cd so it acts like you expect, but there’s logic in Bash just for this. The Fish shell, for example, does not do so and always resolves symlinks in the displayed path.

                                                                          Sockets are truly terrible, despite being an enabling technology for the Internet. You need a special set of APIs just for sockets, instead of following the Unix precedent and exposing a device file with a standard file API. This argument is more controversial, and others have made it better than I, but BSD sockets siloed network programming off from other kinds of I/O programming in a way that was unnecessary and, I think, left a lot of gains on the table compared to a (virtual) filesystem approach.

                                                                      2. 4

                                                                        Real Unix® operating systems distribute configuration across ~/.app/, ~/.config/app/ and ~/Library/Preferences/org.foo.bar.App.plist, so I’m quite happy with Linux converging on the XDG spec.

                                                                      1. 9

                                                                        “Guns, Germs, and Steel”. Only read the prologue and intro so far. Will get some good reading time tomorrow night!

                                                                        1. 11

                                                                          Just a friendly public service announcement from someone trained in anthropology: Diamond is great at suggesting stimulating solutions to grand historical questions, but he’s less great at being correct.

                                                                          I’d recommended keeping your skeptical hat firmly on, and to follow up with some of the material from here after you finish.

                                                                          Don’t want to spoil a good read, just feel obligated as a once-anthropologist.

                                                                          1. 3

                                                                            Thanks for the heads up and the recommendation! I’ve read these kinds of books before and have learned to be cautious…most notoriously from the book “1421”, which has largely been debunked. I try to not let it spoil my experience of a good read though :)

                                                                          2. 4

                                                                            I think it is a great book, and easy to read. If you’re not aware of it, there is a documentary that covers the same subjects, shares the name, and involved the author, James Diamond.

                                                                            Link, if you’re curious: http://www.imdb.com/title/tt0475043/

                                                                          1. 4

                                                                            Finally getting around to reading The Parable of the Sower by Octavia Butler, after it’s been sitting on my desk for a few months. It’s very good so far.

                                                                            1. 3

                                                                              I read that a year or two ago and really enjoyed it. Thanks for the reminder that I’ve been meaning to read more of her.

                                                                            1. 6

                                                                              We’ve actually found this to be very inconvenient. We have enough shared memory that every Irene generally does want to use the same cookie jar. We do know larger systems who have separate social-media accounts for individual headmates or subsystems, but they generally still use one cookie jar for all of them.

                                                                              … Oh, wait, it’s not actually a feature intended for people with multiple personalities (which is dated terminology that doesn’t reflect contemporary understanding). It’s a shitty metaphor that makes for a snappy headline as long as you forget it’s about real people, whose existence is erased so that we can keep being a punchline. Right. Why didn’t I realize that immediately?

                                                                              </bitter>

                                                                              Anyway, this does seem useful for having a personal and a work container that share the same Mozilla account. It also seems useful for social media managers, but I haven’t done that kind of work so I’m guessing.

                                                                              It’s interesting to compare it to how Chrome profiles work - you can have any number of them, and each one can sync to a different Google account. I do sometimes need to create empty profiles which don’t have their own Google accounts to test things, and it would be convenient to be able to sync them to multiple devices. So maybe the feature would help with that case, too.

                                                                              1. 7

                                                                                Yeah, the careless language here is pretty unfortunate.

                                                                                1. 7

                                                                                  Update: after some back-channel conversation (lobste.rs wasn’t mentioned), the blog post changed its title. I’ve pulled in the change here as well. I would do that for any other post that was changed upstream, although as noted I have personal feelings about this one.

                                                                                  1. 6

                                                                                    There are other use cases:

                                                                                    • work and private gmail
                                                                                    • use the shopping container for shopping and enjoy not being tracked through the web with repetitive ads
                                                                                    • use the banking container for banking and you can be sure that CSRF won’t work from shady tabs in other containers
                                                                                    • isolate Facebook so its like-button does not track you all over the web I could go on.
                                                                                    1. 0

                                                                                      Big corporate and state propaganda campaigns have been using tools like this for ages. I think the official term of art was “persona management”. We usually call it “sockpuppeting”. https://en.wikipedia.org/wiki/Operation_Earnest_Voice for example.

                                                                                  1. 1

                                                                                    I’d love to hear more details. I also use nmh, but I don’t have a filtering system I’m happy with.

                                                                                    1. 1

                                                                                      By our very own @whbboyd, I found this a fun exercise.

                                                                                      1. 22

                                                                                        This is getting to be a dumpster fire of a thread, but I’d like to add something I haven’t seen brought up, with regards to the sentiment expressed by several crustaceans that the author inserted gender or identity politics everywhere while at GitHub.

                                                                                        Here’s the thing about identity: it’s not a thing. It’s an is. Identity already is, and it already is everywhere. There’s no inserting it, because it just is.

                                                                                        The only groups who don’t know this intuitively are those who are in the sociologically “default” groups. In the U.S., that’s straight, white, males.

                                                                                        1. 14

                                                                                          I’m going to try my best to gingerly step around this and if I manage to make an oaf of it, I’m sorry.


                                                                                          Continuing along this line of thought– when trying to debug a technical issue, there are a lot of things that are that still remain irrelevant to developing a fix or better way forward. For instance: if some machine in AWS fails during traffic failover, the most relevant facts will tend involve the machine experiencing more traffic than expected. Total RAM, disk capacity, systems handling traffic, etc are all pretty safe bets to check out to make progress during either debugging or a post-mortem, while physical facts that can be identified about the machine are much lower on the scale of probable issues. However, it’s complete true that we cannot ever get away from facts about the machine. It will have some physical location, it will have some class of CPU with some memory capacity. You can enumerate any number of facts about the machine that form its identity– these things just are.

                                                                                          In the same way, to quote the author:

                                                                                          In the midst of my discussions with the editorial team, trying to reach a compromise, a (male) engineer from another team completely rewrote the blog post and published it without talking to me.

                                                                                          The core injury, as I can see it, is that another engineer rewrote the author’s blog post without consulting her. That sucks. In solving the core injury, I do not think it important that the engineer is male– one individual’s actions removed agency from another individual here. There may or may not have been good reasons for it, but either way it’s not something I’d like to happen to me or anyone else. To that end, it feels more important to both understand why and prevent that sort of thing happening in the future. Though the other engineer can be identified as male certainly adds insult to this injury, this would still feel be bad if they were female. Or transgender. Or an agender markov chain with a graph coloring problem, whatever.

                                                                                          This is, I think, where we start to see people describing that the author is inserting gender or identity politics. It’s not that identity ceases to exist, because that’s absolutely inescapable, but mentioning the package between another engineer’s legs isn’t likely relevant to fixing the core issue. It could very well be– going back to AWS failover example, all the machines in a specific rack may just be bad and that’s the real problem– but without significantly more data the mention of this other engineer’s gender serves only to bias the reader away from a deeper analysis of the situation.

                                                                                          I personally find it rather difficult to not become distrustful of the author’s stated intent when she uses identity in this way throughout her post rather than spending more care describing the motivations and rationale of other individuals she has written about. That’s not to say that Github is absolutely blameless, either– taking the latter parts of the post at face value, the author’s manager at least could have handled things better. Just that the situation is probably more complex than the author lets on and probably not so overwhelmingly related to the specific gender or commitment to diversity of any individuals she has written about.

                                                                                          1. 4

                                                                                            First of all, thanks for being willing to engage sincerely. These kinds of topics are politically and emotionally charged, and they’re not easy to talk about. It’s very easy to dismiss these issues as the rantings of an “SJW,” a mentally ill person, or a hypocrite (all of which have been done in this thread), but I think Lobsters can (and should) do better than that. Thanks.

                                                                                            On to the point: you are, in principle, right. It’s entirely possible this specific incident did not involve anyone who was motivated by animus towards individuals with a particular gender expression.

                                                                                            However, that kind of argument stretches the credulity of folks who study this, and of folks who are on the receiving end of gender discrimination in our society. In keeping with the debugging analogy — which is really nice, by the way, can I borrow it? — an experienced debugger starts to get an extra sense for when there’s a bad block on a disk, or there’s a race condition in a piece of software, or a bit flipped in a big non-ECC memory array. These are based on patterns and heuristics that are hard-won over years of encountering real problems, finding enough evidence to conclusively decide upon a root cause, and then recognizing those patterns the next time they come around. If you’re right often enough to make a career out of it, or develop a reputation over it, then most people are comfortable saying that you’re correct in your assessments, and that when you smell smoke folks should get ready for fire, even if no one else has smelled it yet. Nonetheless, pick any one of those incidents, and the facts might not be convincing to an observer brought in to examine that incident alone.

                                                                                            The standard of evidence here is not that of the courtroom or the laboratory, though — it’s that of the water cooler (or the blogosphere). This person is posting their interpretation of events that happened to them, in order to offer a warning to others who might be in a similar situation, with similar concerns. Nothing more, nothing less.

                                                                                            You might notice, however, if you’re on the lookout for these patterns, or have had someone spit on you because of your gender presentation a few times, that when someone writes a blog post called “Amazon Burned Me Out and Takes Advantage of College Students,” we end up with discussions about what reasonable labor expectations are, but when someone writes an article called “My Year at GitHub,” talking about their experiences with gender discrimination, we get discussions about how “SJWs are hypocrites,” “this person is mentally ill,” or “aren’t they just looking for gender discrimination and finding it because they want to?” To your credit, you asked the last question, which is by far the most reasonable of the three. But perhaps you can see why it rings hollow to someone who has dealt with this so often, and for their whole life: to them, you’re like the junior sysadmin asking “shouldn’t we be calling support,” while the guy in the corner, with a tube of thermal paste, is mumbling about how he can hear the heat buildup from the loose heatsink on the 9th processor core.

                                                                                            1. 4

                                                                                              Yeah, thanks! It seems to be really difficult to engage with this topic in good faith, so I deeply appreciate your responses as well. As far as the debugging analogy goes, words are pretty thin air; borrow as you’d please. :)

                                                                                              To get to the meat of your reply, it’s… we’ll obviously have different heuristics we can match against the situation the author described here. Even in just our conversation, I don’t feel confidently equipped with a reasonable standard of evidence for water cooler discussions. In my experience these kind of informal conversations carry significantly more weight than expected, but that doesn’t seem to be the case for others. Or maybe I don’t have enough information to make that kind of judgement. And as far as things ringing hollow…

                                                                                              Let me back up a bit and lay out a few assumptions I try and operate with that are maybe(?) relevant.

                                                                                              • The author’s experience qualifies as an ongoing catastrophe. For her, for Github, and for the wider technical community regardless of race, creed, gender, sex, ability, age, etc, etc

                                                                                              • Any system with more than two components (be they individuals, management systems, technological systems, machines, et al.) is a complex system

                                                                                              • My piddly meat-brain does not have the computing power to fully model complex systems of any stripe

                                                                                              • Complex systems fail in complex ways

                                                                                              It’s that last part that I want to emphasize– particularly (from the linked pdf):

                                                                                              1. Catastrophe requires multiple failures - single point failures are not enough.
                                                                                              1. Post-accident attribution to a ‘root cause’ is fundamentally wrong.
                                                                                              1. Views of ‘cause’ limit the effectiveness of defenses against future events.
                                                                                              1. Safety is a characteristic of systems and not of their components

                                                                                              (and basically all the other ones, too. It’s a good read, highly recommend it if you have the time ¯\_(ツ)_/¯)

                                                                                              My difficulty with the author’s work, and a lot of similar work, is that it suggests that these catastrophic experiences are the result of a singular category of root cause. Call it sexism, racism, general discrimination, patriarchy, systematic oppression¹, etc, these all pattern match to me as “individuals of this outgroup inherently don’t like people in my ingroup and because of this treat us badly”. Which is a huge problem! It sucks, it’s counterproductive, and I really wish I knew the words to express that without marginalizing it with the inevitable, “and also…”. Because to me, even with the grossest delineation of components possible, we still wind up with interactions between the author’s past self, Github the sociotechnical organization, and the community discussing the author’s work. Considering I am nowhere near intelligent enough to model three things in my head, I’m comfortable describing it as a complex system. And because complex systems fail in complex ways, there’s significantly more unique faults here than Github’s poor behavior as an organization as written.

                                                                                              At the end of the day, I can’t solve discrimination or stereotypes or the million billion of microaggressions the technical community lavishes onto anyone who isn’t easily type-classed as cis-white-hetero-male-college-graduate-under-thirty-enjoys-social-drinking-reads-hacker-news-check-out-this-cool-framework-docker-docker-mesos-startup-docker without fundamentally solving the disease that we call the human condition². I don’t even know where to begin with that, but the author’s work puts a lot of emphasis on the selfsame identity of individuals they interacted with. To be clear: I think it’s important that we accept this as a candid reflection of her subjective experience without significant evidence otherwise.

                                                                                              And then also, there are other factors that contributed to this catatrophe. Many of which are easier to solve and significantly more productive to discuss than the ways in which identity interacts with bias. For example, we could talk about what respectful, workplace feedback between individuals of any identity looks like– the author’s written communication style seems rather blunt to me, and I can understand why the data scientist described early in the post was upset. A Crustacean elsewhere in this thread had feedback on the survey question itself that I found surprising; it would be interesting to read other opinions on that, too. What kind of tradeoffs should we be making between factually correct and emotionally sensitive feedback? When is it possible to get both, when is it not? Another Crustacean brought up that PIPs were not for improvement, despite the goals clearly stated in the name. Is this a widespread practice and/or can we avoid working for companies who have such policies?

                                                                                              Discussions along these lines lead to contributing factors that are easier to solve or work around than the widespread mistreatment of classes of people by classes of other people³. Above all, it frustrates me (and likely many others) that much of what good, actionable work we can source to make things better feels like it immediately gets tossed out the window when we start discussing identity in these contexts.


                                                                                              ¹ - That *-isms are an emergent property of the complex web of social systems we engage with is the most interesting view to me in that it at least acknowledges the wider context in which we all interact. Unfortunately, it also seems like it’s easy to short-circuit on that description and throw up your arms in learned helplessness at the idea, too. Don’t know of any good solutions though, only tradeoffs.

                                                                                              ² - Poe’s law warning.

                                                                                              ³ - This is a defining and unfortunate trait of humanity as a whole. My fear is that it’s not entirely maladaptive, either.

                                                                                              1. 4

                                                                                                Hey, sorry for the late response, but I didn’t want to just let this hang, because your response is thoughtful and worthwhile.

                                                                                                I’d like to give a point-by-point response, but time is unfortunately short, and I just don’t have the time to do it well. Instead, I’ll focus on two broad points you raised, which I hope might help you to see where the author (and I) are coming from.

                                                                                                First, on the topic of complex systems, I agree that it’s a great read — as an operations guy, it’s basically required reading for me — and I also agree that, fundamentally, every particular interaction has a huge number of variables, and it’s unlikely only one or two of them contributed to the incident. I don’t think that’s actually what’s being argued here, however. In addition, I also think some of your premises are incorrect. In support of that, I’d offer a few points.

                                                                                                While our piddly meat-brains are not good at modeling most complex systems, they’re existentially good at modeling human cultures. It’s literally the condition of their existence. Homo sapiens is to the extent it is cultural, and culture is how we’ve managed to become a technological society. So while we’re certainly not perfect at modeling complex societies in our minds, I suspect we’re very good at kind of principal social component analysis of our existential threats. And while the author’s case was probably not existential, systematic forms of oppression are, in the general case. A lifetime of living at the end of one of those barrels will, of course, make you gun shy.

                                                                                                I also think you underestimate how much we, as a species, know about this stuff. Which is normal, and essentially the fault of academics for being quiet geeks. Nonetheless, a ton of research goes into the study of society, and as a result of reality being such as it is, a ton of research goes into the study of oppressive structures. There’s a tendency among a certain milieu (computer nerds, like me) to dismiss the fields that study this (sociology, anthropology, history, political science), as “not really science,” but I think this is an impoverished (and incoherent) view of what science entails. As someone who studied the anthropology of liberal democracies (yes, we do that!) intensively in the past, with the intent to make a career of it, I am very comfortable in saying that the evidence these systematic forms of oppression are real, and that they contribute to these smaller incidents (“microagressions”) in a real way, is overwhelming. To my ear, the insistence that the debate is somehow wide open on this sounds similar to the suggestion that anthropomorphic climate change is under serious debate. I’m not suggesting that of you, to be clear, but much of that research produces actionable results, which of course is basically stuck in journals that only universities can afford.

                                                                                                A couple things indicate to me that you (like most people) are thinking about the whole situation differently than the author or I. This struck me in particular:

                                                                                                Call it sexism, racism, general discrimination, patriarchy, systematic oppression¹, etc, these all pattern match to me as “individuals of this outgroup inherently don’t like people in my ingroup and because of this treat us badly”.

                                                                                                No one is suggesting this is “inherent,” and it’s really not even a matter of “like,” and moreover, not of “individuals.” I can only speak for myself, but most of the “lefty” persuasion would say that this is a structural issue, which has expression in individual interactions, but it doesn’t necessarily mean that the individual doing the expressing harbors any dislike of the person on the receiving end. Moreover, that’s essentially beside the point. Even if the individual harbored no ill intent, and no feeling of dislike, the structural issue remains. If you’re interested in dealing with problem, you have to deal with those individual expressions, too.

                                                                                                Now, the classic, Marxist answer to this issue is that you should not deal with the individual expressions, you should seize state power and end oppressive relations once and for all. Aside of the difficulty of doing so successfully and without becoming the abyss, as it were, the objection to this that came out of critical theory and identity politics is this: as people, we’re born and stewed in this society, and we’re shaped by it. Just because the workers seize the means of production, it doesn’t mean the white people will want to hang out with the black people, and it doesn’t mean trans folks will stop being murdered at a higher rate than other groups. Besides, the objection continues, did you notice 1970, and the neoliberal “Washington consensus?” Did you watch them deregulate the markets, destroy unions, and have a democrat dismantle welfare? There’s no working class consciousness anymore, we’re not going to seize power in this century, we need to do something in the meantime.

                                                                                                So we try to confront individuals, and we try to get private corporations to put some pressure on the structural issues. This is a ridiculous, almost farcical task, because we know individuals hate being told they’re hurting someone when they didn’t mean to, and we know the corporations don’t really care. We also know (despite some of the more absurd things that have been asserted in this thread), that we don’t have much power. Just look at the demographic distribution of presidents, legislators, judges, local politicians, or corporate leaders and you can confirm it. A five year old could see it. So when the author is critiquing people directly, and critiquing GitHub directly, it’s coming from a place of being cornered, of being threatened, and of having to fight for the right to be treated like everyone else for your whole life. You develop a shorter, direct tone. You don’t preface every criticism with, “I know this person was trying very hard,” or “I’m sure the person at GitHub” who started this program really cared.”

                                                                                                The final point I want to make, and it’s harder to swallow if you feel like you don’t have skin in the game, is that for me, and probably for the author, this is all more than a question of “is (say) GitHub a nice place to work,” or even “is GitHub the kind of place I’d like to work at?” It’s part of a broader question: “which side are you on?” For the author, the social structure chose the side already. For me, it’s a political and moral commitment based on my religious beliefs. But in both cases, for us, the answer to the kind of questions you posed at the end of your comment — like “what kind of tradeoffs should we be making between factually correct and emotionally sensitive feedback?” — are the wrong question in these cases. The right question for us, is “which side are you on, the side of the weak, or of the powerful?” In an ideal world, I would love if the best question we could ask was always about the individual case. But so long as the last is last and the first is first, I feel that I must always be with the last.

                                                                                                I get that my conclusion here is not something everyone is on board with, but I think it’s important to note that an article like this is coming from a different place than most people. It’s shop talk — “hey fellow civilization-destroying SJWs, got a new job this weekend, just FYI they don’t get it, they’re not approaching hiring underrepresented groups as countering structural issues, it’s basically tokenism, probably stay away. Okay, see you next time.”

                                                                                        1. 7

                                                                                          My desk is an IKEA tabletop and a set of legs with a hand crank that were cheap. The stool is also IKEA, and, uh, not comfortable.

                                                                                          My desktop is Debian (Buster, now!) running i3, apt, and a Chrome session with some things I was looking up for work.

                                                                                          1. 4

                                                                                            So, UNIX’s predecessor, MULTICS, had a stack where the data flows away from the stack pointer where an overflow drops incoming data into new memory if available. Then, CPU-enforced segments to isolate memory regions. I’m not sure on the heap but imagine it was isolated/segmented as well. Secure kernels such as GEMSOS did something similar on custom and Intel CPU’s since it worked before. Imagine my shock when I first read a paper saying the stack and heap flowed toward each other… in systems using unsafe languages, ignoring security features on CPU’s such as segments, and possibly doing this in privileged code. I predicted problems since they’re always there by default when different things smack into each other not designed strongly for security.

                                                                                            And here they are in a nicely-written report. Apparently, they’re still doing weak mitigations against problems whose root causes were eliminated by 1960’s designs. Be interesting to see if cleverness + keeping root causes works this time or penetrate-patch-and-pray game continues. :)

                                                                                            1. 4

                                                                                              Apparently, they’re still doing weak mitigations against problems whose root causes were eliminated by 1960’s designs. Be interesting to see if cleverness + keeping root causes works this time or penetrate-patch-and-pray game continues. :)

                                                                                              Unfortunately, “penetrate, patch, and pray” has some kind of evolutionary durability worked into it, given the constraints of late capitalism.

                                                                                              1. 3

                                                                                                That plus Richard Gabriel’s Worse is Better seems to describe the situation quite well. The other thing is the bandwagon effect where people are usually jumping on one to solve their problems. If it worked well, they’ll defend it. If some properties were incidental, they might also believe they were designed that way on purpose for some advantage. Prior advantages might also be a detriment later one with main example being some aspects of C and UNIX came straight from PDP-11’s limitations. The low-level nature of the language + huge piles of code needing to be rewritten meant they kept the old approaches when new hardware came out.

                                                                                              2. 2

                                                                                                I wonder what is going to happen to operating systems like Secure64’s SourceT micro OS, more info available https://secure64.com/secure-operating-system/ here, now that the Itanium2 has been EOL’d. As mentioned, the OS takes advantage of Itanium-specific features such as independent read/write/execute privileges per page, protected stack architecture, and 4 ring levels.

                                                                                                It seems that many of the design decisions relegated many of the “enterprise” features to Itanium chips only and they were left out of x86_64 specifically to keep the higher-end systems locked into the more expensive CPU. For example, only 2 ring levels and differing implementations of memory protection keying.

                                                                                                1. 4

                                                                                                  It seems that many of the design decisions relegated many of the “enterprise” features to Itanium chips only and they were left out of x86_64 specifically to keep the higher-end systems locked into the more expensive CPU. For example, only 2 ring levels and differing implementations of memory protection keying.

                                                                                                  That’s not really consistent with history. X86 came out long before itanium and does have four rings. X86-64 was developed by AMD as a direct competitor to itanium. They weren’t leaving features out in a deliberate attempt to gift Intel more market share.

                                                                                                  1. 3

                                                                                                    I’ve also heard, but not investigated - so consider these unsubstantiated - claims that many of the Itanium specifIc features that are unlike x86 were made to keep parity with and this ease transition from PA-RISC chips. This seems likely as PA was very popular with large enterprise, and supported HP-UX, etc.

                                                                                                    1. 1

                                                                                                      The other take on that history I’ve heard is that Itanium was used as a testing ground for weird features, prior to potentially bringing them into x86, without risking getting the huge customer base hooked by backwards compatibility on something that might accidentally turn out later to not be useful enough to justify the expense in transistors, mm², design effort, power or whatever. I have no clue about whether that’s true.

                                                                                                      1. 1

                                                                                                        Seems unlikely, given the target audience, big enterprise, cares about back compact more than anybody.

                                                                                                        1. 1

                                                                                                          The marketing said it had RAS features x86 didn’t plus speed boost from piles of registers and their VLIW or whatever stuff that didnt pan out. On top of security improvements. It was advertised as better than x86.

                                                                                                          Then, backward compatibility prevailed and high-end x86 achieved parity on Itanium stuff. Now it’s a liability to Intel. OpenVMS is also getting hit since they got on Itanium bandwagon. SGI did too in past. Those two had other problems though haha.

                                                                                                      2. 2

                                                                                                        I’ve wondered that exact thing. They chose it due to advanced security and fact that CTO (or some high up) had helped design those chips. Knew them well. Now, it’s EOL’d. I didn’t see any news release on it. Their contact page has no email, a toll-free number that hung up, and a contact form. I sent them a request for comment about current plans to deal with Itanium EOL plus a few options. I’ll message you if they reply. The “thank you” screen was blank, too, but might have been NoScript’s fault. (shrugs)

                                                                                                        1. 4

                                                                                                          I currently know 3 employees and have know Dr. Gersch personally for a couple years. Let me shoot some emails and see if I can get a response.

                                                                                                          EDIT: I also noticed that they have some x86 devices in the Datasheet section: https://secure64.com/resource_library/data-sheets/

                                                                                                          1. 2

                                                                                                            Yes, I’d be very interesting in hearing the response as well, thank you.

                                                                                                            I know that most operating systems that take advantage of IA64 features are moving to x64 with help from the compilers, and that NonStop and OpenVMS specifically are taking this approach.

                                                                                                            1. 2

                                                                                                              That be great. Thanks.