1. 6

    I just read the last three months of the GitHub Changelog and saw that GitHub added these features I didn’t know I needed:

    They also made these other changes that seem important to know about but that I don’t personally have a use for:

    1. 5

      I just wanted to say, I am amazed by your work on the project, and the continued awesome reporting you’re doing. It kinda feels to me like if you saw the Augean stables, smiled brightly, said: “Gee, this could be so useful to people if done right!”, then proceeded to gleefully convert them to a marvel of artistry and architecture, happily singing along. With such overwhelming positivity, to me at least kinda reminiscent of Pratchett’s Twoflower (meaning this absolutely in a good way, in case this was not clear). It’s just so great to read your continued reports; every time I see you post them here, I open them with joyful anticipation of a good time, and even if I not always understand every last drop of the contents, the read is always great, clear, interesting and well paced, such that opening the page always feels to me like entering a calm, sunny garden or sanctuary.

      I salute you, sir.

      1. 3

        Wow thank you! Augean stables is a great reference that I had not heard!

        These stables had not been cleaned in over thirty years, and 3,000 cattle lived there.

        Since there’s an unbroken line of compatibility back to Thompson shell (via bash, Korn shell, and Bourne shell), I would say that shell has not been cleaned for nearly 50 years, and 3,000,000 programmers live there :)

        I wish I could clean it all in one day but chipping away slowly seems to be working.


        On the subject of metaphors, I want to make a logo for Oil once the interpreter is fast (i.e. later this year hopefully).

        I’m still getting feedback from new users that they mistake it with “Shell Oil”, which is weird but true. So I’m thinking of a logo that is “Oil as in food” (olive oil, coconut oil, whatever) rather than “Oil as a big company” :)

        The origin for the name was that shell is lubricant between your “metal” code in C / C++ / etc., but I think oil also makes your food more harmonious :)

        If anyone has made a logo before and has ideas about this, let me know.

        I think the connotations will change as the project gets more popular. Just like Guido was fighting “snakes” for 10+ years :) Most people probably don’t remember this, but programmers said they didn’t want to tell their boss they were using a language called “Python” (e.g. circa 2004). Now it seems completely unremarkable.


        Also, I like lobste.rs because everyone seems to understand this philosophy: tell me what you did, and tell me what’s good and bad about it. No BS! Thanks for the amazing feedback.

        1. 1

          Yeah, I remember that I expected the website to be about Shell Oil at first, too.

          After learning that the Oil shell was software, I never really had a picture in my head of why it was named “Oil”. But your description of a lubricant between low-level programs, combined with the thought of food oil, inspired me to draw three sketches of logo concepts. I am not a designer and these may not make good logos, but maybe they’ll inspire something.

          The first two sketches are of sharp, dangerous gears wrapped in a protective sphere (a shell) of yellow vegetable oil, insulating the user from the sharp programs. I realize now that this does not exactly fit the metaphor—programs should be insulated from each other, not from the user—but you could say that the sphere of oil lubricates the gears, too. The last idea is “sh” (lower-case, as it is commonly written) with “o” in front, where the “o” mimics the shell of oil around the whole word.

          Here’s a good reference image for spheres of oil: olive oil caviar

          1. 2

            Wow thanks! I saved these on my “oil logo” wiki page.

            I like the last one. I think something like that would do well for large and small designs, like a favicon, which is one criteria I have. I think gears may be too detailed for that.

            I like the idea of shell being a thin layer of lubricant, not necessarily protection against danger. But that concept may be too difficult to illustrate in a logo, which is one reason I’ve been procrastinating :) I also think the teardrop shape for Oil might be a useful and recognizable sign.

            The color is also something I’ve thought of. I like the yellow color but it might need a contrasting color, so that it works well on typically white backgrounds.

            Thanks for the ideas! I’m treating the logo as a reward task for making Oil fast and production quality :)

      1. 1

        When TypeScript has a union type A | B, it allows you to access all the properties common to both A and B (i.e. the intersection of members).

        I don’t think this is a Typescript thing, but where does the idea that a union of types gives you the intersection of their members come from? This seems like really counterintuitive naming - I would have expected the union of two types to be like a set union, but it seems like it’s not.

        1. 1

          A union type is a type that provides the interface that all member types can satisfy.

          If you have

          type A
            foo
            bar
          end type A
          
          type B
            bar
            baz
          end type B
          

          the type A | B can be either

          (what they do)
          type A | B
            bar
          end type A | B
          

          or

          (what you seem to propose)
          type A | B
            foo
            bar
            baz
          end type A | B
          

          In TS3.3’s scenario, any object that can be put in some container for A | B objects will be able to access their bar property (no matter if that’s a method, function, property, variable, …). In your scenario, if you put an A into an A | B container, accessing their baz property will fail.

          1. 2

            Thanks for the explanation, but I didn’t mean to propose a change in the behaviour. I probably should have been clearer about what I was saying: why is the term “union” used when the behaviour (as described in the very same sentence) is “intersection”?

            1. 2

              The set of values allowed to be assigned to the variable is the union of A values and B values; this where the term “union type” comes from. It’s only the set of values allowed to be read from the variable that is the intersection of A values and B values.

              1. 2

                The “problem” with that construct is that it expands in one direction and restricts in another, similar to contravariance in related language features (subclassing, generics):

                An “A | B” can safely host elements that are A or are B (that’s where the “union” name comes from), but at the price that the interface you can expect must be the intersection of A’s and B’s interfaces (since you don’t know which subtype you’ll grab at any given moment). So it’s a union type with an intersection interface.

                What would an intersection type look like?

                “A & B” only works in a language where any object can be part of multiple classes (using the terms loosely here, objects needn’t be “object oriented” objects and classes could also be interfaces etc), and with that statement you’d mandate that a variable of type A & B can only host an object that implements both the A interface and the B interface, so that variable can’t hold just any A or any B.

                And that means when you have an intersection type (it’s stricter than A or B alone), it’ll have an interface that’s the union of A’s and B’s and therefore is the same or larger than either of them.

                Finally, there’s the C style union type:

                union { struct a a; struct b b; };

                This is covariant-alike in that it both widens the selection of types you can assign to it and allows you to use either interface on the stored data. However in the general case that extended interface won’t make sense, since you’re simply reading the same data in two different ways, one of them usually looking like garbage - which is why C unions are typically used only in very particular situations (either with some manually maintained type tag to state which interface to use, which reduces it to the contravariant-alike case or with very particular memory layouts)

          1. 2

            The description of a for loop over every item in the table, perhaps assisted by indexes, got me wondering how the database stores each row on disk such that it can be quickly accessed at random or sequentially. Since many tables have text of variable length, it would be impractical to define a constant length for each row’s data – so then how is it stored?

            After searching a bit, it looks like there is no single answer – the exact storage format depends on the database engine and its configuration. However, at least MySQL (source) and PostgreSQL use a folder for the database engine, sub-folders for each database, and some number of table-specific files for each table. More details about PostgreSQL’s storage file layout from PostgreSQL’s documentation:

            Each table and index is stored in a separate file, named after the table or index’s filenode number, which can be found in pg_class.relfilenode. In addition to the main file (a/k/a main fork), each table and index has a free space map (see Section 54.3 [Free Space Map]), which stores information about free space available in the relation.

            A table that has columns with potentially large entries will have an associated TOAST table, which is used for out-of-line storage of field values that are too large to keep in the table rows proper. pg_class.reltoastrelid links from a table to its TOAST table, if any. See Section 54.2 [TOAST] for more information.

            The contents of tables and indexes are discussed further in Section 54.5 [Database Page Layout].

            As mentioned above, TOAST is used when a single page cannot hold all the relevant data:

            PostgreSQL uses a fixed page size (commonly 8 kB), and does not allow tuples to span multiple pages.

            Each of these (commonly 8 kB) pages includes certain sections, most notably ItemIdData: “Array of (offset,length) pairs pointing to the actual items. 4 bytes per item.”

            That documentation answered most of my questions about how potentially-large data can be stored so it can be accessed efficiently.

            1. 4

              This free online textbook by a postgres contributor is a good resource for this, especially section 1.3, which describes the internal layout of a postgres page.

            1. 2

              So if this worked so well and was truly effective, how come it isn’t a standard feature of modern operating systems? Or is it perhaps? Linux has zswap but I’ve never seen it used. From a brief read it seems the use is as much about avoiding wear of flash used for swap on embedded systems than about making RAM go further.

              1. 6

                macOS has performed memory compression since OS X 10.9 Mavericks, which was released in 2013. For example, the Activity Monitor currently tells me that my Calendar app is using 193.4 MB of “memory”, of which 133.4 MB is “compressed memory”. (I’m not sure how those figures relate to the real, private, shared, and purgeable memory figures also shown.)

                1. 5
                  1. 1

                    I’ve been using zram on linux to great effect.

                    First started when I was using a computer with a broken harddisk for a week. Booted to ram from a usb drive, and used zram to make my 8gb of ram stretch much further (worked surprisingly well all things considered).

                    Now I basically just always have it on, very convenient for things that use to bring my computer to a halt because they ran out of memory and swap is insanely slow.

                  1. 2

                    git config --global alias.fixup 'commit --amend -C HEAD' once and then a git fixup after adding new changes has never failed me.

                    1. 5

                      That indeed works if you only want to change the last commit; this automatically merges changes into multiple (“draft”) commits.

                      1. 2

                        I hadn’t heard of the -C argument for git commit before. It seems its long form is --reuse-message, and it is one of three related flags that are useful with --amend:

                        • --no-edit – use the same commit message as the amended commit; update the author and timestamp
                        • -c <commit>, --reedit-message=<commit> – use the same commit message as the specified commit; update the author and timestamp
                        • -C <commit>, --reuse-message=<commit> – use the same commit message, author, and timestamp as the specified commit
                      1. 13

                        The clarity of writing in that “Elevator Pitch” section at the start of the readme is wonderful.

                        1. 13

                          It made no sense to me because I had never heard of the git commit --fixup feature that this simplifies, nor its accompanying feature git rebase -i --autosquash. I have used interactive rebases many times, but knowing only that absorb is an alternative to “running a manual interactive rebase” doesn’t narrow it down much.

                          After reading the man pages for those features and reading the three example commands in the README, it makes a little more sense. It wasn’t clear what the README meant by “You have fixes for the bugs” – are those fixes in multiple local commits? – but from the example command git add $FILES_YOU_FIXED I infer that the fixes are in multiple files in my working directory. Then I guess the way absorb breaks apart “each of those changes” is by assuming that each hunk is a separate fix. Anyway, I can figure it out, but it is the opposite of “wonderfully clear” to me.

                          Edit: Now that I know that absorb is an alternative to making commits and writing fixup instructions in an interactive rebase (which I have done many times), the linked description of hg absorb on mozilla.dev.version-control seems like a better overview to me:

                          Facebook demoed hg absorb which is probably the coolest workflow enhancement I’ve seen to version control in years. Essentially, when your working directory has uncommitted changes on top of draft changesets, you can run hg absorb and the uncommitted modifications are automagically folded (“absorbed”) into the appropriate draft ancestor changesets. […] The command essentially looks at the lines that were modified, finds a changeset modifying those lines, and amends that changeset to include your uncommitted changes. If the changes can’t be made without conflicts, they remain uncommitted. This workflow is insanely useful for things like applying review feedback. You just make file changes, run hg absorb and the mapping of changes to commits sorts itself out. It is magical.

                          1. 3

                            This indeed looks amazing, stated in this way.

                            1. 1

                              Same here. The git description seems too much in terms of various git features which I don’t know while the Mercurial description from Mozilla explains what it actually does.

                            2. 5

                              Haha, it doesn’t make a lot of sense to me because I don’t know git commands very well, but I’m glad it worked for you. The only reason I know what it’s talking about is because I’ve had it explained to me in Mercurial terms.

                            1. 1

                              I’m the author of the Honorable Mention submission. I had hoped to win the contest, but I must acknowledge that the winning submission had more bad code than mine. Congratulations, group __1EC7__ (ikbenlike and Zeroji).

                              The summary of my entry didn’t mention some of its bad properties, probably due to the goal of keeping the article short. Here are two more bad parts that I am especially proud of:

                              • The “intuitive” format that the program changes the input to is not only unnecessary, it also adds ambiguity. Instead of using the letters L,R for turns and the letters N,S,E,W for cardinal directions, the program uses the letters U,D,R,L (up, down, right, left) for directions. So the casewhen expressions in right and left handle the values L,D,R,U, and the casewhen expression in handle_turns_chars and the final direction calculation code also handle the values L,D,R,U, but the D and U cases are just commented out as “not needed”.

                                This ambiguous notation actually stemmed from an initial misreading of the problem. I skimmed over the problem description so fast that I didn’t see what characters to use for the cardinal directions, so I used U,D,R,L from the start because they really were more “intuitive” to me. Then I kept using those letters even after seeing the ambiguity they added.

                              • The four command-line arguments are read from ARGV in an overly abstract, functional way that is not natural in Ruby:

                                # arguments
                                processors = [
                                  method(:eval),
                                  method(:eval),
                                  method(:map_dir_to_intuitive_dir),
                                  lambda { |arg| arg }, # leave it alone
                                ]
                                init_x, init_y, init_dir, cmd_str = ARGV.zip(processors).map do |arg, processor|
                                  processed = processor.call(arg)
                                end
                                
                              1. 2

                                Yeah, those were some nice touches that didn’t make it into the summary :)

                                I’ll tell you that when I met with the other two judges it was a really hard decision between yours and the winning entry. Yours has more the “feel” we’re going for – but once it was clear that the other wasn’t just stacking languages for obfuscation, but had this “legacy codebase evolved through stacks over time” feel, it was decided to focus the teardown there.

                                That much to say: thanks so much for your participation, we really enjoyed it!

                              1. 16

                                (I don’t use this lightly, but) lol: https://craftyguy.net/pub/2019-01-23_1716x1223_scrot.png

                                PS: web developers, you don’t actually need javascript to display text.

                                1. 3

                                  For once, this type of comment is on-topic.

                                1. 21

                                  While not exactly the same, git natively supports checking out arbitrary branches in your ‘last checked out’ stack. For example, pass a single dash (i.e. ‘git checkout -’) to checkout the last checked out branch, or pass a number to it to checkout any checked out branch in your ‘last checked out’ stack (e.g. ‘git checkout @{-4}’ for the branch you checked out 4 checkouts ago).

                                  There may be a way to achieve similar functionality to pushb and popb using builtin git functionality + git/shell aliases, but I haven’t explored that..

                                  1. 4

                                    Git’s official documentation for those features:

                                    • When specifying a revision, @{-<n>}, e.g. @{-1} means “the nth branch/commit checked out before the current one.”
                                    • For the <branch> argument of git checkout, “you may also specify ‘-’ which is synonymous to ‘@{-1}’”. (I just submitted an email to the Git mailing list suggesting improvements to the formatting of this documentation.)
                                  1. 1

                                    Some people argue that closed platforms are intrinsically better than open ones? I’ve never heard of such people before. I suppose I should be glad of that.

                                    1. 9

                                      Depending on what exactly you mean by open and closed platforms, I can totally see cases where that is the case.

                                      One of the easy points is incentives: closed platforms tend to be for-profit, and that can incentivize better artifacts. By comparison, in some cases, open platforms focus on cleverness, novelty, or community over quality of product.

                                      1. 3

                                        I don’t know about people, but Apple, Microsoft, and Google all seem to.

                                        1. 3

                                          I’m not going to say intrinsically. I will say they can be with some specific platforms exceeding open ones in some attributes. Examples:

                                          The LISP machines were among best at productivity, live debugging and modification with nothing mainstream matching that I know of (Smalltalk partly). The REBOL apps were similarly concise or extensible with tiny downloads on top of it. The VMS and NonStop clusters had reliability that beats most clouds. QNX was best at individual node reliability vs speed vs features at least before Minix 3 came (who knows now). The GEMSOS, STOP, LOCK, and KeyKOS OS’s beat out all the others in security in their time. In assurance activities, still better than current ones that are popular. In hardware design, the Big Three of EDA are the default since nobody trusts an open design to do commercial ASIC’s. Similar for high-performance FPGA’s w/ Big Two. For cross-platform UI that’s web-like, sciter is way more efficient than Electron. In well-regulated software, a whole ecosystem of products sprang up with more quality, even graphics drivers/stacks. Those always sucked before, right? ;)

                                          Just a few off the top of my head.

                                        1. 2

                                          I’m used to being able to dynamically change the font size on MacOS by hitting cmd+/- but this does nothing on Kitty :-(

                                          1. 4

                                            It seems Kitty’s default shortcuts are unlike other macOS terminals’. If you open the preferences text file ~/.config/kitty/kitty.conf from the “Preferences…” menu item, you can see that the file contains these commented-out lines that describe the default mappings:

                                            # kitty_mod ctrl+shift
                                            
                                            #: The value of kitty_mod is used as the modifier for all default
                                            #: shortcuts, you can change it in your kitty.conf to change the
                                            #: modifiers for all the default shortcuts.
                                            
                                            …
                                            
                                            # map kitty_mod+equal     change_font_size all +2.0
                                            # map kitty_mod+minus     change_font_size all -2.0
                                            # map kitty_mod+backspace change_font_size all 0
                                            

                                            So the default shortcuts to increase and decrease the font size are Shift+Ctrl+‘=’ and Shift+Ctrl+‘-’.

                                            For anyone who wants a terminal that provides by default macOS-standard features such as common shortcuts, session reloading, and menus, I recommend iTerm2.

                                          1. 3

                                            The eigen- prefix is used to describe something which is “the same” before and after a transformation. e.g. the eigenvector of a matrix is a vector which still points in the same direction after multiplying by the matrix (scaled by its eigenvalue). What exactly is the transformation going on here?

                                            1. 6

                                              eigen comes from Germanic languages such as German and Dutch where it means own, particular to, etc.

                                              Mijn eigen auto -> My own car.

                                              Mijn eigenwaarde/eigendunk -> My self-esteem

                                              So, the prefix eigen- does not imply a transformation. Though, I agree that it is confusing in CS to use this prefix, since non-native speakers immediately associate it with eigenvalues/vectors.

                                              1. 2

                                                The term “singleton class” that the article briefly mentions is actually Ruby’s official term for this concept. Ruby’s standard library defines the Object#singleton_class method; you can use .singleton_class in place of .eigenclass in all the article’s examples. Perhaps this potential confusion is the reason the Ruby team chose “singleton class” over “eigenclass”.

                                                1. 2

                                                  Thank you for your comment.

                                                  Eigen means “own” in German. So “eigenclass” means “owned class” (as this anonymous class is owned by its defined class).

                                                  1. 2

                                                    Etymologically speaking, the “eigen-”-prefix was used by David Hilbert to describe that the value/vector is inherent to the thing. To confuse things a little, “eigen” is a pretty versatile word in german: https://www.dict.cc/?s=eigen

                                                    Hilbert probably used in the sense of “possessive”, “inherent”, “in-built”. In that sense, which is not focused on the transformation, “eigenclass” is rather similar.

                                                    (loosely taken and translated from: http://faql.de/etymologie.html#eigen)

                                                  1. 4

                                                    The six general principles listed at the end seem too wordy and redundant to be useful for remembering the lessons of the four URLs. So I would summarize them with these two principles:

                                                    • make URLs self-contained (let them be useful even if the server is down)
                                                    • make URLs editable (make the format obvious enough for manual editing to work)
                                                    1. 6

                                                      I created a URL scheme for the King James Bible that I felt was simple and elegant (and that was twenty years ago, sigh). I then did a similar approach to my blog URLs but based around dates, not books, chapters and verses.

                                                      1. 1

                                                        Those URL schemes are neat, but I think your comment is misplaced. You should delete and repost your comment as a reply to the top level, not to my comment.

                                                        1. 1

                                                          My intent was to reply to the two principles of the article. My comment would also be relevant to /u/whjms currently just below mine, about making URLs editable.

                                                          I think I’ll just leave it here for now.

                                                      2. 2

                                                        make URLs editable

                                                        I’ve thought about how the web would be different if manually editing URLs was the norm. For example, if web browsers generated a UI based on the query parameters that would let people easily change individual variables. Maybe sites could also add metadata to URL parameters.

                                                      1. 4

                                                        I started a thread on journaling a while ago. I got some great recommendations from it!

                                                        I’m curious as to how many folks put their notes directly in to git commits and then actually later reference those notes.

                                                        1. 2

                                                          I sometimes do this, and I find — at least for me — commit messages are the best place for me to take notes. They’re easily greppable, and accessible from any computer in the world. Also I write with a pen like a four year old, and I get impatient with how long it takes to get my thoughts out with a pen, and my hand starts to hurt.

                                                          It’s also really nice having the notes together with the diff. This gives you some scope metadata like exactly what code the notes apply to, and when this commentary was valid/relevant. This is something that comments in code do not achieve.

                                                          1. 1

                                                            Commit messages are a good place, but not ideal for planning - I use a “developer’s readme” for that. What I would like in git (I use git) is a way to write in notes for a branch - when I create a branch I would like to have a notes field that I can use to outline what the purpose of the branch is.

                                                            1. 2

                                                              Git does let you save locally-stored branch descriptions: Branch descriptions in Git

                                                              1. 1

                                                                Thanks! That’s cool. Sad that it is local only. It’s only one extra text field in the branch metadata.

                                                          2. 1

                                                            I currently keep my notes in a SQLite database with a web front end. Mostly so that I have an easy way to search them without having to deal with Git’s structure. That also makes easier to access from a cell phone, which is a big plus when I’m using the note system for things like tracking spending.

                                                          1. 2

                                                            Can technical terms not be emphasized this way? “Today’s post is all about <em>malloc</em> and dynamic memory.” If I were reading that aloud, I might put a little pause around malloc so everybody hears it.

                                                            1. 3

                                                              <ehem> wold be even better! “Today’s post is all about <ehem>malloc</ehem>”.

                                                              1. 1

                                                                I think <i> would be better for technical terms: <i>malloc</i>. You are pronouncing “malloc” differently, but not because you are stressing it. Your change of voice is similar to the change in voice you might use when quoting a book title, which should also be marked up with <i>: “But what about <i>The Wind in the Willows</i>?”.

                                                                1. 4

                                                                  If you want to be even more semantic you could use the dfn and cite tags: <dfn>malloc</dfn> and <cite>The Wind in the Willows</cite>.

                                                                  1. 3

                                                                    Good find with the <dfn> tag, but I’m not sure that <cite> could replace <i> for the book title. From the description of <cite> it sounds like it could, but the HTML demo on that MDN page includes a book title written with <i>, with <cite> wrapped around it, as in “check out <cite><i>The Wind in the Willows</i> by Kenneth Grahame</cite>”. Making the situation more confusing, the page says that the W3C and the WHATWG specs conflict on whether <cite> can include more than the book title.

                                                                    1. 1

                                                                      Good catch. To make things even more confusing, the MDN page also says,

                                                                      Typically, browsers style the contents of a <cite> element in italics by default.

                                                                      So maybe it’s best just to stay away from that one, or at least to treat it as a semantic-only tag and handle the formatting yourself. (Some of those example uses would traditionally be formatted in quotes, not italics, so maybe that’s just as well.)

                                                              1. 81

                                                                I beg all my fellow crustaceans to please, please use Firefox. Not because you think it’s better, but because it needs our support. Technology only gets better with investment, and if we don’t invest in Firefox, we will lose the web to chrome.

                                                                1. 59

                                                                  Not because you think it’s better

                                                                  But that certainly helps too. It is a great browser.

                                                                  • privacy stuff — the cookie container API for things like Facebook Container, built-in tracker blocker, various anti-fingerprinting things they’re backporting from the Tor Browser
                                                                  • honestly just the UI and the visual design! I strongly dislike the latest Chrome redesign >_<
                                                                  • nice devtools things — e.g. the CSS Grid inspector
                                                                  • more WebExtension APIs (nice example: only on Firefox can Signed Pages actually prevent the page from even loading when the signature check fails)
                                                                  • the fastest (IIRC) WASM engine (+ now in Nightly behind a pref: even better codegen backend based on Cranelift)
                                                                  • ongoing but already usable Wayland implementation (directly in the official tree now, not as a fork)
                                                                  • WebRender!!!
                                                                  1. 7

                                                                    On the other hand, WebSocket debugging (mostly frame inspection) is impossible in Firefox without an extension. I try not to install any extensions that I don’t absolutely need and Chrome has been treating me just fine in this regard[1].

                                                                    Whether or not I agree with Google’s direction is now a moot point. I need Chrome to do what I do with extensions.

                                                                    As soon as Firefox supports WebSocket debugging natively, I will be perfectly happy to switch.

                                                                    [1] I mostly oppose extensions because of questionable maintenance cycles. I allow uBlock and aXe because they have large communities backing them.

                                                                    1. 3

                                                                      Axe (https://www.deque.com/axe/) seems amazing. I know it wasn’t the focus of your post – but I somehow missed this when debugging an accessibility issue just recently, I wish I had stumbled onto it. Thanks!

                                                                      1. 1

                                                                        You’re welcome!

                                                                        At $work, we used aXe and NVDA to make our webcomponents AA compliant with WCAG. aXe was invaluable for things like contrast and missing role attributes.

                                                                      2. 3

                                                                        WebSocket debugging (mostly frame inspection) is impossible in Firefox without an extension

                                                                        Is it possible with an extension? I can’t seem to find one.

                                                                        1. 1

                                                                          I have never needed to debug WebSockets and see no reason for that functionality to bloat the basic browser for everybody. Too many extensions might not be a good thing but if you need specific functionality, there’s no reason to hold back. If it really bothers you, run separate profiles for web development and browsing. I have somewhat more than two extensions and haven’t had any problems.

                                                                          1. 1

                                                                            I do understand your sentiment, but the only extension that I see these days is marked “Experimental”.

                                                                            On the other hand, I don’t see how it would “bloat” a browser very much. (Disclaimer: I have never written a browser or contributed to any. I am open to being proved wrong.) I have written a WebSockets library myself, and it’s not a complex protocol. It can’t be too expensive to update a UI element on every (websocket) frame.

                                                                        2. 5

                                                                          Yes! I don’t know about you, but I love the fact that Firefox uses so much less ram than chrome.

                                                                          1. 2

                                                                            This was one of the major reasons I stuck with FF for a long time. It is still a pronounced difference.

                                                                          2. 3

                                                                            honestly just the UI and the visual design! I strongly dislike the latest Chrome redesign >_<

                                                                            Yeah, what’s the deal with the latest version of Chrome? All those bubbly menus feel very mid-2000’s. Everything old is new again.

                                                                            1. 3

                                                                              I found a way to go back to the old ui from https://www.c0ffee.net/blog/openbsd-on-a-laptop/ (it was posted here a few weeks ago):

                                                                              Also, set the following in chrome://flags:

                                                                              • Smooth Scrolling: (personal preference)
                                                                              • UI Layout for the browser’s top chrome: set to “Normal” to get the classic Chromium look back
                                                                              • Identity consistency between browser and cookie jar: set to “Disabled” to keep Google from hijacking any Google > - login to sign you into Chrome
                                                                              • SafeSearch URLs reporting: disabled

                                                                              (emphasis mine)

                                                                              1. 1

                                                                                Aaaaaaaand they took out that option.

                                                                            2. 1

                                                                              The Wayland implementation is not usable quite yet, though, but it is close. I tried it under Sway, but it was crashy.

                                                                            3. 16

                                                                              I switched to Firefox last year, and I have to say I don’t miss Chrome in the slightest.

                                                                              1. 13

                                                                                And those with a little financial liberty, consider donating to Mozilla. They do a lot of important work free a free and open web.

                                                                                1. 10

                                                                                  I recently came back to Firefox from Vivaldi. That’s another Chromium/Webkit based browser and it’s closed source to boot.

                                                                                  Firefox has improved greatly in speed as of late and I feel like we’re back in the era of the mid-2000s, asking people to chose Firefox over Chrome this time instead of IE.

                                                                                  1. 2

                                                                                    I’d love to switch from Vivaldi, but it’s simply not an option given the current (terrible) state of vertical tab support in Firefox.

                                                                                    1. 2

                                                                                      How is it terrible? The hiding of the regular tab bar is not an API yet and you have to use CSS for that, sure, but there are some very good tree style tab webextensions.

                                                                                      1. 2

                                                                                        The extensions are all terrible – but what’s more important is that I lost the belief that any kind of vertical tab functionality has any chance of long-term survival. Even if support was added now, it would be a constant battle to keep it and I’m frankly not interested in such fights anymore.

                                                                                        Mozilla is chasing their idealized “average user” and is determined to push everyone into their one-size-fits-all idea of user interface design – anyone not happy with that can screw off, if it was for Mozilla.

                                                                                        It’s 2018 – I don’t see why I even have to argue for vertical tabs and mouse gestures anymore. I just pick a browser vendor which hasn’t been asleep on the wheel for the last 5 years and ships with these features out of the box.

                                                                                        And if the web in the future ends up as some proprietary API defined by whatever Google Chrome implements, because Firefox went down, Mozilla has only itself to blame.

                                                                                        1. 2

                                                                                          The extensions are all terrible – but what’s more important is that I lost the belief that any kind of vertical tab functionality has any chance of long-term survival. Even if support was added now, it would be a constant battle to keep it and I’m frankly not interested in such fights anymore. The whole point of moving to WebExtensions was long term support. They couldn’t make significant changes without breaking a lot of the old extensions. The whole point was to unhook extensions from the internals so they can refactor around them and keep supporting them.

                                                                                          1. 0

                                                                                            That’s like a car manufacturer removing all electronics from a car – sure it makes the car easier to support … but now the car doesn’t even turn on anymore!

                                                                                            Considering that cars are usually used for transportation, not for having them sit in the garage, you shouldn’t be surprised that customers buy other cars in the future.

                                                                                            (And no, blaming “car enthusiasts” for having unrealistic expectations, like it happens in the case of browser users, doesn’t cut it.)

                                                                                            1. 3

                                                                                              So you’d rather they didn’t improve it at all? Or would you rather they broke most extensions every release?

                                                                                              1. 3

                                                                                                I’m not @soc, but I wish Firefox had delayed their disabling of old-style extensions in Firefox 57 until they had replicated more of the old functionality with the WebExtensions API – mainly functionality related to interface customization, tabs, and sessions.

                                                                                                Yes, during the time of that delay, old-style extensions would continue to break with each release, but the maintainers of Tree Style Tabs and other powerful extensions had already been keeping up with each release by releasing fixed versions. They probably could have continued updating their extensions until WebExtensions supported their required functionality. And some users might prefer to run slightly-buggy older extensions for a bit instead of switching to the feature-lacking new extensions straight away – they should have that choice.

                                                                                                1. 1

                                                                                                  What’s the improvement? The new API was so bad that they literally had to pull the plug on the existing API to force extension authors to migrate. That just doesn’t happen in cases where the API is “good”, developers are usually eager to adopt them and migrate their code.

                                                                                                  Let’s not accuse people you disagree with that they are “against improvements” – it’s just that the improvements have to actually exist, and in this case the API clearly wasn’t ready. This whole fiasco feels like another instance of CADT-driven development and the failure of management to reign in on it.

                                                                                                  1. 3

                                                                                                    The old extension API provided direct access to the JavaScript context of both the chrome and the tab within a single thread, so installing an XUL extension was disabling multiprocess mode. Multiprocess mode seems like an improvement; in old Firefox, a misbehaving piece of JavaScript would lock up the browser for about a second before eventually popping up a dialog offering to kill it, whereas in a multiprocess browser, it should be possible to switch and close tabs no matter what the web page inside does. The fact that nobody notices when it works correctly seems to make it the opposite of Attention-Deficient-Driven-Design; it’s the “focus on quality of implementation, even at the expense of features” design that we should be encouraging.

                                                                                                    The logical alternative to “WebExtension For The Future(tm)” would’ve been to just expose all of the relevant threads of execution directly to the XUL extensions. run-this-in-the-chome.xul and run-this-in-every-tab.xul and message pass between them. But at that point, we’re talking about having three different extension APIs in Firefox.

                                                                                                    Which isn’t to say that I think you’re against improvement. I am saying that you’re thinking too much like a developer, and not enough like the poor sod who has to do QA and Support triage.

                                                                                                    1. 2

                                                                                                      Improving the actual core of Firefox. They’re basically ripping out and replacing large components every other release. This would break large amount of plugins constantly. Hell, plugins wouldn’t even work in Nightly. I do agree with @roryokane that they should have tried to improve it before cutting support. The new API is definitely missing many things but it was the right decision to make for the long term stability of Firefox.

                                                                                                      1. 1

                                                                                                        They could have made the decision to ax the old API after extension authors adopted it. That adoption failed so hard that they had to force developers to use the new API speaks for itself.

                                                                                                        I’d rather have extension that I have to fix from time to time, than no working extensions at all.

                                                                                              2. 1

                                                                                                Why should Mozilla care that much about your niche use case? They already have a ton of stuff to deal with and barely enough funding.

                                                                                                It’s open source, make your own VerticalTabFox fork :)

                                                                                                1. 3

                                                                                                  Eh … WAT? Mozilla went the extra mile with their recent extension API changes to make things – that worked before – impossible to implement with a recent Firefox version. The current state of tab extensions is this terrible, because Mozilla explicitly made it this way.

                                                                                                  I used Firefox for more than 15 years – the only thing I wanted was to be left alone.

                                                                                                  It’s open source, make your own VerticalTabFox fork :)

                                                                                                  Feel free to read my comment above to understand why that doesn’t cut it.

                                                                                                  Also, Stuff that works >> open source. Sincerely, a happy Vivaldi user.

                                                                                                  1. 2

                                                                                                    It’s one of the laws of the internet at this point: Every thread about Firefox is always bound to attract someone complaining about WebExtensions not supporting their pet feature that was possible with the awful and insecure old extension system.

                                                                                                    If you’re care about “non terrible” (whatever that means — Tree Style Tab looks perfect to me) vertical tabs more than anything — sure, use a browser that has them.

                                                                                                    But you seem really convinced that Firefox could “go down” because of not supporting these relatively obscure power user features well?? The “average user” they’re “chasing” is not “idealized”. The actual vast majority of people do not choose browsers based on vertical tabs and mouse gestures. 50% of Firefox users do not have a single extension installed, according to telemetry. The majority of the other 50% probably only have an ad blocker.

                                                                                                    1. 3

                                                                                                      If you’re care about “non terrible” (whatever that means — Tree Style Tab looks perfect to me) vertical tabs more than anything — sure, use a browser that has them.

                                                                                                      If you compare the current state of the art of vertical tabs extensions, even Mozilla thinks they suck – just compare them to their own Tab Center experiment: https://testpilot.firefox.com/static/images/experiments/tab-center/details/tab-center-1.1957e169.jpg

                                                                                                      Picking just one example: Having the navigation bar at a higher level of the visual hierarchy is just wrong – the tab panel isn’t owned by the navigation bar, the navigation bar belongs to a specific tab! Needless to say, all of the vertical tab extensions are forced to be wrong, because they lack the API do implement the UI correctly.

                                                                                                      This is how my browser currently looks like, for comparison: https://i.imgur.com/5dTX8Do.png

                                                                                                      But you seem really convinced that Firefox could “go down” because of not supporting these relatively obscure power user features well?? The “average user” they’re “chasing” is not “idealized”. The actual vast majority of people do not choose browsers based on vertical tabs and mouse gestures. 50% of Firefox users do not have a single extension installed, according to telemetry. The majority of the other 50% probably only have an ad blocker.

                                                                                                      You can only go so far alienating the most loyal users that use Firefox for specific purposes until the stop installing/recommending it to their less technically-inclined friends and relatives.

                                                                                                      Mozilla is so busy chasing after Chrome that it doesn’t even realize that most Chrome users will never switch. They use Chrome because “the internet” (www.google.com) told them so. As long as Mozilla can’t make Google recommend Firefox on their frontpage, this will not change.

                                                                                                      Discarding their most loyal users while trying to get people to adopt Firefox who simply aren’t interested – this is a recipe for disaster.

                                                                                                  2. 1

                                                                                                    and barely enough funding

                                                                                                    Last I checked they pulled in half a billion in revenue (2016). Do you believe this is barely enough?

                                                                                                    1. 2

                                                                                                      For hundreds of millions users?

                                                                                                      Yeah.

                                                                                                2. 1

                                                                                                  At least with multi-row tabs in CSS you can’t dragndrop tabs. That’s about as bad as it gets.

                                                                                                3. 2

                                                                                                  Are vertical tabs so essential?

                                                                                                  1. 3

                                                                                                    Considering the change in screen ratios over the past ten years (displays get shorter and wider), yes, it absolutely is.

                                                                                                    With vertical tabs I can get almost 30 full-width tabs on screen, with horizontal tabs I can start fishing for the right tab after about 15, as the tab width gets increasingly smaller.

                                                                                                    Additionally, vertical tabs reduce the way of travel substantially when selecting a different tab.

                                                                                                    1. 1

                                                                                                      I still miss them, didn’t cripple me, but really hurt. The other thing about Tree (not just vertical) tabs that FF used to have was that the subtree was contextual to the parent tree. So, when you opened a link in a background tab, it was opened in a new tab that was a child of your current tab. For doing like documentation hunting / research it was amazing and I still haven’t found its peer.

                                                                                                  2. 1

                                                                                                    It’s at least partially open source. They provide tarballs.

                                                                                                    1. 4

                                                                                                      https://help.vivaldi.com/article/is-vivaldi-open-source/

                                                                                                      The chromium part is legally required to be open, the rest of their code is like readable source, don’t get me wrong that’s way better than unreadable source but it’s also very wut.

                                                                                                      1. 2

                                                                                                        Very wut. It’s a weird uneasy mix.

                                                                                                        1. 2

                                                                                                          that’s way better than unreadable source but it’s also very wut.

                                                                                                          I wouldn’t be sure of that. It makes it auditable, but has legal ramifications should you want to build something like vivaldi, but free.

                                                                                                    2. 8

                                                                                                      firefox does not get better with investment, it gets worse.

                                                                                                      the real solution is to use netsurf or dillo or mothra, so that webmasters have to come to us and write websites that work with browsers that are simple enough to be independently maintained.

                                                                                                      1. 9

                                                                                                        Good luck getting more than 1‰ adoption 😉

                                                                                                        1. 5

                                                                                                          good luck achieving independence from Google by using a browser funded by Google

                                                                                                          1. 1

                                                                                                            I can achieve independence from Google without using netsurf, dillo, or mothra; to be quite honest, those will never catch on.

                                                                                                            1. 2

                                                                                                              can you achieve independence from google in a way that will catch on?

                                                                                                              1. 1

                                                                                                                I don’t think we’ll ever get the majority of browser share back into the hands of a (relatively) sane organization like Mozilla—but we can at least get enough people to make supporting alternative browsers a priority. On the other hand, the chances that web devs will ever feel pressured to support the browsers you mentioned, is close to nil. (No pun intended.)

                                                                                                                1. 1

                                                                                                                  what is the value of having an alternative, if that alternative is funded by google and sends data to google by default?

                                                                                                                  1. 1

                                                                                                                    what is the value of having an alternative

                                                                                                                    What would you like me to say, that Firefox’s existence is worthless? This is an absurd thing to insinuate.

                                                                                                                    funded by google

                                                                                                                    No. I’m not sure whether you’re speaking in hyperbole, misunderstood what I was saying, and/or altogether skipped reading what I wrote. But this is just not correct. If Google really had Mozilla by the balls as you suggest, they would coerce them to stop adding privacy features to their browser that, e.g., block Google Analytics on all sites.

                                                                                                                    sends data to google by default

                                                                                                                    Yes, though it seems they’ve been as careful as one could be about this. Also to be fair, if you’re browsing with DNT off, you’re likely to get tracked by Google at some point anyway. But the fact that extensions can’t block this does have me worried.

                                                                                                                    1. 1

                                                                                                                      i’m sorry if i misread something you wrote. i’m just curious what benefit you expect to gain if more people start using firefox. if everyone switched to firefox, google could simply tighten their control over mozilla (continuing the trend of the past 10 years), and they would still have control over how people access the web.

                                                                                                                      1. 1

                                                                                                                        It seems you’re using “control” in a very abstract sense, and I’m having trouble following. Maybe I’m just missing some context, but what concrete actions have Google taken over the past decade to control the whole of Mozilla?

                                                                                                                        1. 1

                                                                                                                          Google has pushed through complex standards such as HTTP/2 and new rendering behaviors, which Mozilla implements in order to not “fall behind.” They are able implement and maintain such complexity due to funding they receive from Google, including their deal to make Google the default search engine in Firefox (as I said earlier, I couldn’t find any breakdown of what % of Mozilla’s funding comes from Google).

                                                                                                                          For evidence of the influence this funding has, compare the existence of Mozilla’s Facebook Container to the non-existence of a Google Container.

                                                                                                                          1. 1

                                                                                                                            what % of Mozilla’s funding comes from Google

                                                                                                                            No word on the exact breakdown. Visit their 2017 report and scroll all the way to the bottom, and you’ll get a couple of helpful links. One of them is to a wiki page that describes exactly what each search engine gets in return for their investment.

                                                                                                                            I would also like to know the exact breakdown, but I’d expect all those companies would get a little testy if the exact amount were disclosed. And anyway, we know what the lump sum is (around half a billion), and we can assume that most of it comes from Google.

                                                                                                                            the non-existence of a Google Container

                                                                                                                            They certainly haven’t made one themselves, but there’s nothing stopping others from forking one off! And anyway, I think it’s more so fear on Mozilla’s part than any concrete warning from Google against doing so.

                                                                                                                            Perhaps this is naïveté on my part, but I really do think Google just want their search engine to be the default for Firefox. In any case, if they really wanted to exert their dominance over the browser field, they could always just… you know… stop funding Mozilla. Remember: Google is in the “web market” first & the “software market” second. Having browser dominance is just one of many means to the same end. I believe their continued funding of Mozilla attests to that.

                                                                                                                            1. 2

                                                                                                                              It doesn’t have to be a direct threat from Google to make a difference. Direct threats are a very narrow way in which power operates and there’s no reason that should be the only type of control we care about.

                                                                                                                              Yes Google’s goal of dominating the browser market is secondary to their goal of dominating the web. Then we agree that Google’s funding of Firefox is in keeping with their long-term goal of web dominance.

                                                                                                                              if they really wanted to exert their dominance over the browser field, they could always just… you know… stop funding Mozilla.

                                                                                                                              Likewise, if Firefox was a threat to their primary goal of web dominance, they could stop funding Mozilla. So doesn’t it stand to reason that using Firefox is not an effective way to resist Google’s web dominance? At least Google doesn’t think so.

                                                                                                                              1. 1

                                                                                                                                Likewise, if Firefox was a threat to their primary goal of web dominance, they could stop funding Mozilla. So doesn’t it stand to reason that using Firefox is not an effective way to resist Google’s web dominance?

                                                                                                                                You make some good points, but you’re ultimately using the language of a “black or white” argument here. In my view, if Google were to stop funding Mozilla they would still have other sponsors. And that’s not to mention the huge wave this would make in the press—even if most people don’t use Firefox, they’re at least aware of it. In a strange sense, Google cannot afford to stop funding Mozilla. If they do, they lose their influence over the Firefox project and get huge backlash.

                                                                                                                                I think this is something the Mozilla organization were well aware of when they made the decision to accept search engines as a funding source. They made themselves the center of attention, something to be competed over. And in so doing, they ensured their longevity, even as Google’s influence continued to grow.

                                                                                                                                Of course this has negative side effects, such as companies like Google having influence over them. But in this day & age, the game is no longer to be free of influence from Google; that’s Round 2. Round 1 is to achieve enough usage to exert influence on what technologies are actually adopted. In that sense, Mozilla is at the discussion table, while netsurf, dillo, and mothra (as much as I’d love to love them) are not and likely never will be.

                                                                                                          2. 3

                                                                                                            Just switch to Gopher.

                                                                                                            1. 5

                                                                                                              Just switch to Gopher

                                                                                                              I know you were joking, but I do feel like there is something to be said for the simplicity of systems like gopher. The web is so complicated nowadays that building a fully functional web browser requires software engineering on a grand scale.

                                                                                                              1. 3

                                                                                                                yeah. i miss when the web was simpler.

                                                                                                                1. 1

                                                                                                                  I was partially joking. I know there are new ActivityPub tools like Pleroma that support Gopher and I’ve though about adding support to generate/server gopher content for my own blog. I realize it’s still kinda a joke within the community, but you’re right about there being something simple about just having content without all the noise.

                                                                                                            2. 1

                                                                                                              Unless more than (rounded) 0% of people use it for Facebook, it won’t make a large enough blip for people to care. Also this is how IE was dominant, because so much only worked for them.

                                                                                                              1. 1

                                                                                                                yes, it would require masses of people. and yes it won’t happen, which is why the web is lost.

                                                                                                            3. 2

                                                                                                              I’ve relatively recently switched to FF, but still use Chrome for web dev. The dev tools still seem quite more advanced and the browser is much less likely to lock up completely if I have a JS issue that’s chewing CPU.

                                                                                                              1. 2

                                                                                                                I tried to use Firefox on my desktop. It was okay, not any better or worse than Chrome for casual browsing apart from private browsing Not Working The Way It Should relative to Chrome (certain cookies didn’t work across tabs in the same Firefox private window). I’d actually want to use Firefox if this was my entire Firefox experience.

                                                                                                                I tried to use Firefox on my laptop. Site icons from bookmarks don’t sync for whatever reason (I looked up the ticket and it seems to be a policy problem where the perfect is the enemy of the kinda good enough), but it’s just a minor annoyance. The laptop is also pretty old and for that or whatever reason has hardware accelerated video decoding blacklisted in Firefox with no way to turn it back on (it used to work a few years ago with Firefox until it didn’t), so I can’t even play 720p YouTube videos at an acceptable framerate and noise level.

                                                                                                                I tried to use Firefox on my Android phone. Bookmarks were completely useless with no way to organize them. I couldn’t even organize on a desktop Firefox and sync them over to the phone since they just came out in some random order with no way to sort them alphabetically. There was also something buggy with the history where clearing history didn’t quite clear history (pages didn’t show up in history, but links remained colored as visited if I opened the page again) unless I also exited the app, but I don’t remember the details exactly. At least I could use UBO.

                                                                                                                This was all within the last month. I used to use Firefox before I used Chrome, but Chrome just works right now.

                                                                                                                1. 6

                                                                                                                  I definitely understand that Chrome works better for many users and you gave some good examples of where firefox fails. My point was that people need to use and support firefox despite it being worse than chrome in many ways. I’m asking people to make sacrifices by taking a principled position. I also recognize most users might not do that, but certainly, tech people might!? But maybe I’m wrong here, maybe the new kids don’t care about an open internet.

                                                                                                              1. 1

                                                                                                                I once tried to implement this for an in-browser editor using the tab-size CSS property, only to find that no browsers implement that property fully. The CSS standard says that you should be able to pass any distance such as 17px to set the width of each tab character, but in practice browsers only support passing an integer such as 2, which makes the width an exact multiple of the width of the font’s space character.

                                                                                                                It’s a shame that no text formatting API I have ever seen makes implementing elastic tabstops easy.

                                                                                                                Though, thinking about the above limitation of CSS implementations, maybe it would be possible to combine tab-size with a web font that changes tab characters to be one pixel wide? The unicode-range property of a @font-face declaration can be used to specify that the font is only used to render certain characters.

                                                                                                                1. 2

                                                                                                                  This article is unnecessarily hard to read because of its plain-text nature and Pastebin.com’s styling. Here is a formatted version I made so I could read it more easily: https://gist.github.com/roryokane/d02addfa9329c579f15daef5b4ebae2f

                                                                                                                  1. 1

                                                                                                                    Looks nice! Thanks!

                                                                                                                  1. 2

                                                                                                                    The OptiCSS part of CSS Blocks, a sub-library that compiles stylesheets for peformance, seems to do the same thing as the existing library Styletron. Styletron does the same splitting of rules into a rule for each set of styles that is shared across elements, followed by giving multiple classes to elements that assemble all subsets of rules they need. Styletron’s introductory blog post explains more about the concept.