1. 1

    I have a hard time understanding why things like Django’s ORM are a win. They make simple queries possible and complex queries tedious at worst, as compared to just writing the SQL. My workflow for writing non-trivial queries is something like:

    1. Think about the query I want to write
    2. Figure out how to express said query in the ORM
    3. Look at the generated query to figure out why it’s slow and what I need to nudge to get the ORM to generate something reasonable

    I’d be curious to hear about success stories from people using these tools in large, non-trivial codebases.

    1. 1

      Two benefits that come to mind are

      1. Portability: using ORM reduces dependency in database engine. For products / projects that need to operate on multiple db engines using an ORM makes things much easier.

      2. Composability: using an ORM, and Django QuerySet as an example, you can easily compose queries. Think about a website with a list of filters. Some filters are on fields on the same tables, other on related tables that require a join, some filters are on expression fields etc. How would you implement that w/o an ORM? String interpolation? I think you’ll end up creating your own tiny ORM to add fields and joins lazily..

      As someone who is not bound by the first constraint, I often resort to RAW SQL in places the ORM falls short (example).

    1. 6

      I really don’t like the approach of using python itself as the configuration language. Stuff configuration into effectively global variables muddies dependencies and interfaces, and additionally it’s awkward as soon as a non-python component needs to read this configuration. I’ve also seen cases where the “config” module slowly starts acquiring things that perform side-effects, which is its own whole can of worms.

      1. 1

        Vim is configured with a similar script. If you want to do it this way probably depends on what you’re doing.

      1. 1

        I agree with a lot of the points he makes, but testing is the fly in the ointment. It’s much harder to test a 200 line function as compared to a couple smaller functions.

        1. 2

          I use this style all the time for batch processing glue code that’s not easy to unit test anyway. It makes sense to limit the scope of variables as much as possible. I regularly promote variables to higher levels of scope than what I initially predicted when they’re heavily used. It’s cleaner, and easier to refactor than threading unrelated state values in and out of multiple functions with awkwardly constructed structs or tuples.

          1. 1

            He’s not talking about pure functions, where a granular separation of functionality improves testability, but rather cases where the program coordinates many stateful calls. Unit tests of functions split out from that kind of procedure don’t actually tell you much about the correctness of the program and generally become dead-weight change-detectors.

            1. 1

              I agree that change-detector tests are worthless. I guess if there are no pieces that can be separated out as pure functions then yes, inlining makes a lot more sense.

          1. 8

            Company: Systems and Technology Research

            Company site: http://stresearch.com (It’s not particularly helpful here)

            Position: Lots of fun software stuff – from programming languages to data engineering to computer vision to basically anything that’s not a webapp

            Location: Woburn, MA (a little north of Boston)

            Description: We solve hard problems, usually (but not always) for the government. We’re not some stodgy defense contractor but rather teams of engineers, mathematicians and software engineers that get things done and actually deliver product. Some examples of the types of projects we work on are counter-botnet botnets and programming language research to improve security.

            Feel free to apply through the website or through a PM to me – if the former, please mention lobste.rs!

            1. 1

              I think there are real opportunities to shave the coursework down to the very essence. It’s probably not worth teaching git upfront, for instance. Making students work through not having source control for a while will put them in a much more receptive frame of mind when they do end up learning it. It’s much easier to learn something when you’re excited about how it’s going make your life easier rather than learning for the sake of learning.

              1. 3

                I think the readability issue is a thrown aside a little too lightly. Yes, in this particular example readability doesn’t suffer from wildcard imports, but in plenty of real world code it does: when there are a dozen or so imports of unfamiliar packages it’s really nice to see at a glance exactly where code and data are flowing.

                1. 6

                  Hmmm, I’m coming into this fresh and ignorant so it’s interesting to see people here discuss the weird history and person behind the projects. My hot take:

                  • Looks a lot like go and was obviously heavily inspired by it.
                  • Lots of things that I would think are hard problems have been punted or WIP yet seem to be core features. E.g., arbitrary key types for maps, generics, memory management, concurrency specifics
                  • Error handling seems to be oddly bolted on? Rather than maybe syntactic sugar on top of a generic type it’s special cases all around

                  That probably sounded more negative than I meant it to – it just seems like it’s very early. If everything comes together I think it could be pretty compelling.

                  1. 17

                    Using a static site generator means that you have to keep track of two sources: the actual Markdown source and the resulting HTML source.

                    This is not representative of my experience. I can delete my generated /public folder and re-run Hugo again to generate a new site. I only have to keep track of my source.

                    Finally, you constantly have to work around the limitations of your static site generator.

                    This is very true. I use Hugo, and it changes very fast, often breaking some things. Also, it started out as a blog site generator, and adding features to make it a generic site generator has required paying attention to releases and updating my custom theme to prevent my site from breaking.

                    But how can I then keep the style and layout of all my posts and pages in sync?

                    I actually think this is kind of neat. I like the idea of a web of interconnected pages each similar but a little different, evolving over time. It reminds me of the old web.

                    🤔 I should redesign my website.

                    1. 6

                      Hugo is dang frustrating. Recently I accidentally updated it from the distro, jumping ahead 15 versions. At some point they made pygments go from rendering my site in <100ms to rendering in 15s. Then I tried switching to Chroma, but it turns out there’s no extension system, so to tweak my code highlighters I needed to manually compile Chroma and then manually compile Hugo.

                      Then I found out that you use a tweet shortcode, you can’t preview your site offline. That broke me and I went back to a 2016 build.

                      1. 1

                        I feel you. That is why I use specific versions of hugo for my site, not one supplied by a distro.

                        Also I recommend using hljs. I like it (progressive enhancement) better than the pygments. I’ve had some problems with pygments in the past, but I cannot recall it. (Also had some minor annoyances with hljs, but I’m generally OK with it).

                        Regarding the tweet shortcode… I never used that (I prefer screenshots of tweets and links, as I do not trust linking third party sources. They can change/disappear, and it would ruin my point). Could you link an issue or something so I could understand it? It made me curious.

                        1. 1

                          Yeah, I think I’ve been lucky in that not much has broken for me.

                          The biggest issue I ran into a couple of months ago was a change that prevent me from using a / in a tag name to fake sub-paths. I used this to match my old URL schema from before I was using Hugo.

                          Hugo removed (”“fixed””) the tag issue, so I updated my blog to use another solution, BUT then Hugo reverted the change. Ha!

                        2. 4

                          I used to write my blog (for the past 19 years) in raw HTML. Then a few months ago I implemented my own markup language (based upon Orgmode with a lot of extensions for how I write posts), but I still only keep the rendered HTML, not the original source. That way, I’m not stuck with supporting outdated versions of my markup formatter.

                          1. 2

                            This is not representative of my experience. I can delete my generated /public folder and re-run Hugo again to generate a new site. I only have to keep track of my source.

                            But even then, you must keep both the source and the result in your head, because you have to worry about how your Markdown will be translated to HTML (dependent on the version and implementation of Markdown) and how your posts will be arranged in public/.

                            This is very true. I use Hugo, and it changes very fast, often breaking some things. Also, it started out as a blog site generator, and adding features to make it a generic site generator has required paying attention to releases and updating my custom theme to prevent my site from breaking.

                            This is a great summary of the problem! Websites created with static site generators are quite fragile.

                            1. 4

                              But even then, you must keep both the source and the result in your head, because you have to worry about how your Markdown will be translated to HTML (dependent on the version and implementation of Markdown) and how your posts will be arranged in public/.

                              I’m still not aligned with you on this. I do have to think about my HTML when I am building my custom theme, not when I’m building the site or uploading it.

                              The only thing I have to consider when creating new content is where my feature image is located and use the correct path in my content’s meta data. The thumbnails and their use in the page are auto-generate, and the content is put where it needs to be, and related links menu items and homepages are all updated per my theme.

                              1. 1

                                I suppose it depends on what type of content you write, but I find it hard to maintain things like footnotes and tables across different implementations of Markdown and static site generators (or even the same generator but a different version). Not to mention things like elements with custom classes and inline HTML.

                                What I mean is, if you’re writing HTML directly you always know what the resulting HTML will be. If you write in Markdown, you always have to spend time thinking about what the HTML will look like. You usually have a good enough idea, but you could be wrong.

                                1. 1

                                  What I mean is, if you’re writing HTML directly you always know what the resulting HTML will be. If you write in Markdown, you always have to spend time thinking about what the HTML will look like.

                                  I think this is why I hate ORMs. Instead of just writing the SQL I want, I have to learn how to express it in whatever weird interface the library exposes – assuming it’s even expressive enough.

                                  1. 1

                                    Is Markdown really in that much of a state of flux?

                                    I’m using the OG Daring Fireball edition, I do know that there’s been some work to integrate stuff like footnotes and ToC (which Gruber opposed on philosophical grounds). It’s been frozen since… 2011? 2004

                                    I’d rather use a tool that made it easier for me to write a blog post every day (let’s face it, every month more like it) than worry about future incompatibility in the HTML rendering tool I’m using.

                                    1. 1

                                      Is Markdown really in that much of a state of flux?

                                      Not Gruber’s Markdown, but yes, certainly if you’re switching between implementations (or versions thereof) or static site generators (or versions thereof) that use different implementations.

                                      I’d rather use a tool that made it easier for me to write a blog post every day (let’s face it, every month more like it) than worry about future incompatibility in the HTML rendering tool I’m using.

                                      Indeed – that’s exactly how I feel writing posts in HTML. Nothing can go wrong, no matter what system I’m using or what programs I have installed.

                                2. 2

                                  Websites created with static site generators are quite fragile.

                                  Only if the site generator ever changes. I use one written in Clojure that has not been changed in years.

                                  1. 1

                                    That is why I made my own. A few lines of Python and your ready.

                                  2. 1

                                    I actually think this is kind of neat. I like the idea of a web of interconnected pages each similar but a little different, evolving over time. It reminds me of the old web.

                                    🤔 I should redesign my website.

                                    This cracked me the hell up :D

                                  1. 2

                                    This is pretty cool; I hacked together a rough scheme interpreter in go for something similar a couple jobs back.

                                    The thing I struggle with here is that a tool like this for business logic is a bit of a slippery slope. It’s convenient, but then you wake up one day and you’re storing program snippets in your database and doing other heinous things. Interfaces get a bit muddy too, because anything that executes arbitrary code basically needs the whole world as its evironment. So I guess my question is, how do you use it?

                                    1. 2

                                      We use it at our search engine for ruler. We have a lot of constantly changing rules, and now our managers can modify it of fly. This is why expr have only limited abilities. And type checking. (Before our rules was written in python, and it was a mess, now much better).

                                    1. 1

                                      Have we entered a steady-state for this kind of game? I feel like I haven’t heard much from this side of the industry in a while. Don’t get me wrong, the various app stores are still cesspools when it comes to games, but things seem to have died down.

                                      1. 2

                                        My favourite feature of B is that identifiers may contain A to Z, a to z, _ and backspace characters. I presume that they were using printing terminals: teletypes, not video terminals. So an identifier can contain underscored text: you underscore a letter using the sequence letter, backspace, underscore.

                                        1. 1

                                          An interesting consequence of that is abc^H^H^H___ is a distinct variable from a^H_b^Hc^H_, even though they would look the same on a teletype. Obfuscated coder’s dream!

                                        1. 20

                                          My advice, which is worth every penny you pay for it:

                                          Don’t maintain a test environment. Rather, write, maintain and use code to build an all-new copy of production, making specific changes. If you use puppet, chef, ansible or such to set up production, use the same, and if you have a database, restore the latest backup and perhaps delete records.

                                          The specific changes may include deleting 99% of the users or other records, using the smallest possible VM instances if you’re on a public cloud, and should include removing the ability to send mail, but it ought to be a faithful copy by default. Including all the data has drawbacks, including only 1% has drawbacks, I’ve suffered both, pick your poison.

                                          Don’t let them diverge. Recreate the copy every week, or maybe even every night, automatically.

                                          1. 9

                                            Seconding this.

                                            One of the nice things about having “staging” being basically a hot-standby of production is that, in a pinch, you can cut over to serve from it if you need to. Additionally, the act of getting things organized to provision that system will usually help you spot issues with your existing production deployment–and if you can’t rebuild prod from a script automatically, you have a ticking timebomb on your hands.

                                            As far as database stuff goes, use the database backups from prod (hopefully taken every night) and perhaps run them through an anonymizing ETL to do things like scramble sensitive customer data and names. You can’t beat the shape (and issues) of real data for testing purposes.

                                            1. 2

                                              Pardon a soapbox digression: Friendlysock is big improvement over your previous persona. Merci.

                                              1. 1

                                                It’s not a bad idea to make use of a secondary by having it be available to tests. Though I would argue instead for multiple availability zones and auto scaling groups if you want production to be high availability. Having staging as a secondary makes it difficult for certain databases like Couch base to have automatic fail over since the data is not in sync and in both cases your gonna have to spin up new servers anyways.

                                              2. 8

                                                We basically do this. our production DB (and other production datastores) are restored every hour, so when a developer/tester runs our code they can specify –db=hourly and it will talk to the hourly copy(actually we do this through ENV variables, but can override that with a cli option) . We do the same for daily. We don’t have a weekly.

                                                Most of our development happens in daily. Our development rarely needs to live past a day, as our changes tend to be pretty small anymore. If we have some long-lived branch that needs it’s own DB to play in(like a huge long-lasting DB change or something) we spin out a copy of daily just for that purpose, we limit it to one, and it’s called dev.

                                                All of our debugging and user issue fixing happens in hourly. It’s very rare that a user bug gets to us in < 1hr that can’t be reproduced easily. When that happens we usually just wait for the next hour tick to happen, to make sure it’s still not reproducible before closing.

                                                It makes life very nice to do this. We get to debug and troubleshoot in what is essentially a live environment, with real data, without caring if we break it badly (since it’s just an at most 1 hour old copy of production, and will automatically get rebuilt every hour of every day).

                                                Plus this means all of our dev and test systems have the same security and access controls as production, if we are re-building them EVERY HOUR, it needs to be identical to production.

                                                Also this is all automated, and is restored from our near-term backup(s). So we know our backups work every single hour of every day. This does mean keeping your near-term backups very close to production, since it’s tied so tightly to our development workflow. We do of course also do longer-term backups that are just bit-for-bit copies of the near-term stuck at a particular time(i.e. daily, weekly, monthly).

                                                Overall, definitely do this and make your development life lazy.

                                                1. 1

                                                  I’m sorry, what is the distinction you’re making that makes this not a test environment? The syncing databases?

                                                  1. 2

                                                    If I understand correctly, the point is that this entire environment, infrastructure included, is effectively ephemeral. It is not a persistent set of servers with a managed set of data, instead, it’s a stand by copy of production recreated every week, or day. Thus, it’s less of a classic environment and more like a temporary copy. (That is always available.)

                                                    1. 4

                                                      Yes, precisely.

                                                      OP wants the test environment to be usable for testing, etc., all of which implies that for the unknown case that comes up next week, the test and production environments should be equivalent.

                                                      One could say “well, we could just maintain both environments, and when we change one we’ll do the same change on the other”. I say that’s rubbish, doesn’t happen, sooner or later the test environment has unrealistic data and significant but unknown divergences. The way to get equivalence is to force the two to be the same, so that

                                                      • quick hacks done during testing get wiped and replaced by a faithful copy of production every night or sunday
                                                      • mistakes don’t live forever and slowly increase divergence
                                                      • data is realistic by default and every difference is a conscious decision
                                                      • people trust that the test environment is usable for testing

                                                      Put differently, the distinction is not the noun (“environment”) but the verb (“maintain” vs “regenerate”).

                                                      1. 2

                                                        Ah, okay. That’s an interesting distinction you make – I take it for granted that the entire infrastructure is generated with automation and hence can be created / destroyed at will.

                                                        1. 2

                                                          LOLWTFsomething. Even clueful teams fail a little now and then.

                                                          Getting the big important database right seems particularly difficult. Nowhere I’ve worked and nowhere I’ve heard details about was really able to tear down and set up the database without significant downtime.

                                                1. 1

                                                  Company: Systems and Technology Research

                                                  Company site: http://stresearch.com

                                                  Position: Lots of fun software stuff – from algorithms to data engineering to computer vision to basically anything that’s not a webapp

                                                  Location: Woburn, MA (a little north of Boston)

                                                  Description: We solve hard problems, usually (but not always) for the government. We’re not some stodgy defense contractor but rather teams of engineers, mathematicians and software engineers that get things done and actually deliver product. Some examples of the types of projects we work on are counter-botnet botnets and programming language research to improve security.

                                                  We’re particularly looking to hire software engineers that are well-versed in modern development and deployment practices (e.g., AWS, GCP, big-ish data). Feel free to apply through the website or through a PM to me – if the former, please mention lobste.rs!

                                                  1. 5

                                                    I wrote some computer vision software for a medical device back in 2007 that’s still running. I’m mostly impressed that the entire software stack held together the last twelve years over the changes in technology and bankruptcies / acquisitions. It’s one of the earlier projects from my career and still the piece I’m most proud of! Every couple of years I put in a couple of hours contracting for the current owner to do minor tweaks and such.

                                                    1. 26

                                                      I’m pretty surprised by the amount of hate for Go in the comments here. I definitely agree with the author. For me the simplicity of Go has been an absolute breath of fresh air. It really feels like a better C.

                                                      C doesn’t have generics and yet you don’t hear people complain about that. Right now if you want a statically typed, garbage collected language, your only real options are Java (JVM languages) or Go. The cross platform support for C# is still pretty poor, and many of the smaller languages just don’t have the library support.

                                                      I just don’t see the lack of generics as an issue right now, but I hope that the new generics proposals for Go2 get it right.

                                                      1. 28

                                                        Generics weren’t really a thing until 1973 with ML. C was released in 1972, so it gets some slack. Generics were pretty well understood for decades before Go came out which is why people go off about it.

                                                        1. 13

                                                          The problem is that many people aren’t advocating Go as a better C, but as better, period. And many other people are denouncing Go as a bad language, period. The result is polarization which shows up as ‘hate’ (I would prefer to call it ‘unmoderated negativity’, because I don’t know (and cannot really imagine) if people actually feel hate).

                                                          It would be much nicer if everyone applied the principles of humanity and charity

                                                          1. 6

                                                            C has the preprocessor, which lets you build things like generic redblack trees. Of course, in go, you have go generate. So I think it comes out about even, but because the two features aren’t identical people don’t really consider them.

                                                            For that matter, c++ templates frequently boil down to tons of duplicated code generation, which then the linker has to sift through. Go’s solution requires a touch more work, but eliminates a lot of eventual waste.

                                                            1. 5

                                                              C Preprocessir and go generate might be about equal in what they can do, but there’s no question that C Preprocessir has a lower barrier to entry for the basic things.

                                                              1. 2

                                                                Preprocessor a separate language and tool from C, though. It’s not like having the feature built into the language with the compiler being able to understand the context as it applies the feature.

                                                              2. 5

                                                                I’m not sure that I agree about the C# bit. Why do you say that the cross platform support is poor?

                                                                1. 10

                                                                  Seriously, it feels bizarre using Mono for about a decade, yet people act like .NET only appeared outside of Windows when .NET Core was busy being born a few years ago.

                                                                2. 7

                                                                  It really feels like a better C.

                                                                  So… if you ignore the past 30 years of academic research, it’s a good language? How exactly is that impressive?

                                                                  C doesn’t have generics and yet you don’t hear people complain about that.

                                                                  I’ve never used generics, and I’ve never missed ’em.

                                                                  1. 4

                                                                    I more or less begrudgingly agree. Every now and then I find myself wishing for generics or operator overloading in Go (not as often as I would have guessed)… then I remember how refreshing it is to be able to read some unfamiliar Go code and know that I don’t have to wonder what an innocuous looking “+” might be doing.

                                                                    1. 9

                                                                      You can have generics without operator overloading, though. See also: Java 5.

                                                                    2. 0
                                                                      1. 12

                                                                        Not in the sense that anyone cares about. It doesn’t allow for user-defined generic code – the library author has to write the specialized implementations ahead of time, and exhaustively enumerate what types their macro is generic over. This feature exists almost exclusively for the benefit of tgmath.h.

                                                                        C would have been better off without this poorly thought out solution.

                                                                    1. 15

                                                                      Is this a misconception: It’s harder to write a window manager for Wayland. Looking at the sway of WM’s for “regular” xorg setups, it seems “fairly” manageable to get to a working state quickly. Looking at sway or way-cooler, it seem like a lot more work. Or am I mistaken?

                                                                      1. 15

                                                                        No, this is true.

                                                                        1. 4

                                                                          Do you have any ideas on how this could be overcome? Or should this be seen as a good thing?

                                                                          1. 5

                                                                            Mir is working on something in this direction. But I don’t think it’s too terrible of a thing, no. You get a lot of power and flexibility with something like wlroots that makes more novel desktops possible.

                                                                            1. 1

                                                                              Don’t forget Wayfire :) Anyone can just implement whatever window management stuff they want as loadable plugins for Wayfire.

                                                                              1. 1

                                                                                Is Mir still an active project? I thought it effectively lost sponsorship once Canonical abandoned it.

                                                                                1. 3

                                                                                  It’s still active, but they ditched their own protocol in favor of Wayland and I’m not sure how many resources are devoted to it.

                                                                          2. 2

                                                                            AFAICT the difference is mainly that the hard part, writing the actual rendering, is done by X11, so most X11 window managers don’t have to bother with that at all. Wayland windows managers do have to bother if they want to work.

                                                                            1. 5

                                                                              A window manager can be written a plugin for an existing compositor like Wayfire or Weston.

                                                                          1. 14

                                                                            I’m writing a guide in Italian for majoring CS students and how to avoid exploitation in their first jobs.

                                                                              1. 1

                                                                                Exploitation in what sense?

                                                                                1. 1

                                                                                  exploitation by the employers: low wages, crunching, attacks on workers’ autonomy and so on.

                                                                              1. 4

                                                                                I’ve always found myself overly interested in the busy beaver function: simple formulation, but it outpaces any computable function, no matter how many factorials and exponents you throw in!

                                                                                Scott Aaronson has a great write-up: https://www.scottaaronson.com/writings/bignumbers.html

                                                                                1. 2

                                                                                  I totally agree. Having a M.S. in math, the things that would interest me the most about CS would be things like the halting problem, busy beaver function, etc. For example, another Scott Aaronson link (https://www.scottaaronson.com/busybeaver.pdf) gives explicit descriptions of small Turing machines that cannot be proven to halt using ZFC (the axioms underlying most of modern mathematics), or proving they halt is equivalent in difficulty to proving Goldbach’s conjecture or the Riemann hypothesis.

                                                                                1. 9

                                                                                  This website it terribly to use on a mobile device. I wish more sites were plain text…

                                                                                  1. 18

                                                                                    To be fair, this website is also terrible on desktop.

                                                                                    Redacted since it’s unneedly harsh

                                                                                    1. 9

                                                                                      I’m a co-founder of SmoothTerminal. Sorry about the performance issues - we just launched a UX/UI refresh and none of us noticed the performance issues until yesterday. Are you on Safari? That’s the only place we’ve been able to reproduce the slow scrolling, and there’s some particularly weird behaviour sometimes (safari web inspector claims an element is where it should be, but it’s painted somewhere else entirely). We’re working on it, and I’m embarrassed that it’s bad. Mea culpa.

                                                                                      1. 24

                                                                                        I shouldn’t have been this harsh. Sometime I forget about the human on the other side of the screen. I’m the one embarrassed, sorry about that.

                                                                                        I have this issue at its worst on Chrome on OSX. Using it on Firefox/Linux on my desktop is less worse, but scrolling still feel a bit tampered with.

                                                                                        1. 20

                                                                                          This is one of the reasons that I like lobste.rs, we all occasionally make poorly thought out or harsh comments, but this is one of the places on the internet where people apologize because they think about the person on the other side. Thanks for making the world decent!

                                                                                        2. 5

                                                                                          Honestly it’s pretty rough to use on desktop as well. The floating ToC blocks the text in its default, expanded position, and on wide monitors the layout is much wider than seems reasonable. The “reader” view in firefox cleans it up nicely – it just gives raw text with a reasonable column width, which is all anyone wants anyway.

                                                                                          1. 6

                                                                                            Killing TOC, thanks

                                                                                            1. 5

                                                                                              Thanks for being responsive!

                                                                                              1. 1

                                                                                                No problem. We saw some performance gains from that and it was definitely broken in safari, but the real performance gains came from the deploy we just performed - we stopped using background-attachment: fix. That was causing extreme redraw churn. Both needed to be done though really.

                                                                                          2. 4

                                                                                            FWIW, it is pretty difficult to read with JavaScript disabled (using uMatrix). Perhaps you’re applying styles in JavaScript?

                                                                                            1. 2

                                                                                              This is what I was thinking too. I just gave up and opted for Reader View in Firefox.

                                                                                              1. 1

                                                                                                We are, and it’s in support of our themes. We should make sure to ship the default theme by default, but my guess is it’s flipped in js and has no good default fallback. Thanks.

                                                                                                1. 1

                                                                                                  We were accidentally shipping all styles over js. We’re prepping a PR that properly sends the stylesheet now. That’s embarrassing.

                                                                                                  1. 1

                                                                                                    Stuff happens! Still displays poorly in Firefox with uMatrix, but maybe you’re still working on the PR.

                                                                                                    It probably looks fine in e.g. elinks or eww.

                                                                                                2. 1

                                                                                                  Mobile Firefox here, I could see the first paragraph but only the background Blue after that, until I switched to Reader View

                                                                                                  1. 1

                                                                                                    What mobile OS? is that happening still? I just tried it on mobile firefox on android and it worked fine, but we also just deployed a bunch of tweaks based on the righteous, justified shellacking we got for performance yesterday.

                                                                                                    1. 1

                                                                                                      It works much better now, thanks!

                                                                                            1. 4

                                                                                              Upvoted with the hope of someone coming in and commenting on their experience in this space – I’m always slightly annoyed at docker.

                                                                                              1. 2

                                                                                                This is relevant to me at work as we’re building out a platform around Kubernetes. We’ve had issues with Docker on our CentOS servers because Red Hat’s packaged version of Docker is two years old and missing several bugfixes that we care about, as well as plenty of features.

                                                                                                As far as I can tell, CRI-O is likely to be the way forward - Red Hat certainly think so and are throwing their weight behind it, and it helps a lot that the specifications are designed to be backwards-compatible with Docker’s API.

                                                                                                However, after some investigation I’m just not convinced that the adoption and tooling are there yet, and we ended up moving to Docker’s own packages for a more recent version (I’ll be rolling this out to production this week).

                                                                                                I’d be interested to know if anyone is using, or has spent significant time with, CRI-O or any of the other alternatives.