Threads for duncan_bayne

  1. 45

    The way this PR was written made it almost seem like a joke

    Nobody really likes C++ or CMake, and there’s no clear path for getting off old toolchains. Every year the pain will get worse.

    and

    Being written in Rust will help fish continue to be perceived as modern and relevant.

    To me this read a lot like satire poking fun at the Rust community. Took me some digging to realize this was actually serious! I personally don’t care what language fish happens to be written in. As a happy user of fish I just really hope this doesn’t disrupt the project too much. Rewrites are hard!

    1. 35

      This is what it looks like when someone is self-aware :-)

      They looked at the tradeoffs, made a technical decision, and then didn’t take themselves too seriously.

      1. 10

        Poe’s Law is strong with this one. Not knowing the author of Fish, I genuinely can’t tell whether the commentary is 100% in earnest, or an absolutely brilliant satire.

        1. 21

          Given the almost 6,000 lines of seemingly high quality Rust code, I’m going to say it’s not a joke.

          1. 16

            Gotta commit to the bit.

            1.  

              Oh, sure! I meant the explanation in the PR, not the code itself.

            2.  

              Same. After doing some research into the PR though, I’m pretty sure it’s in earnest. XD

            3.  

              For sure! After I looked deeper and found that this person is a main contributor to fish things made more sense. I totally respect their position and hope things go well. I just thought the way it was phrased made it hard to take seriously at first!

            4. 20

              The author understands some important but often underappreciated details. Since they aren’t paying anyone to work on the project, it has to be pleasant and attractive for new contributors to want to join in.

              1. 17

                Nobody really likes C++ or CMake, and there’s no clear path for getting off old toolchains. Every year the pain will get worse.

                I think that the “Nobody” and “pain” there may have been referring to the dev team, not so much everyone in the world. In that context it’s a little less outlandish a statement.

                1. 15

                  It’s also not really outlandish in general. Nobody likes CMake. How terrible CMake is, is a common topic of conversation in the C++ world, and C++ itself doesn’t exactly have a reputation for being the language everyone loves to use.

                  I say as someone who does a whole lot of C++ development and would pick it above Rust for certain projects.

                  1. 7

                    Recent observation from Walter Bright on how C++ is perceived:

                    He then said that he had noticed in discussions on HN and elsewhere a tectonic shift appears to be going on: C++ appears to be sinking. There seems to be a lot more negativity out there about it these days. He doesn’t know how big this is, but it seems to be a major shift. People are realizing that there are intractable problems with C++, it’s getting too complicated, they don’t like the way code looks when writing C++, memory safety has come to the fore and C++ doesn’t deal with it effectively, etc.

                    From https://forum.dlang.org/post/uhcopuxrlabibmgrbqpe@forum.dlang.org

                    1.  

                      That’s totally fine with me.

                      My retirement gig: maintaining and rescuing old C++ codebases that most devs are too scared/above working on. I expect it to be gross, highly profitable, and not require a ton of time.

                      1.  

                        C programmers gonna have their COBOL programmer in 1999 moment by the time 2037 rolls around.

                      2.  

                        C++ appears to be sinking

                        And yet, it was the ‘language of the year’ from TIOBE’s end-of-year roundup for 2022, because it showed the largest growth of all of the languages in their list, sitting comfortably at position 3 below Python and C. D shows up down at number 46, so might be subject to some wishful-thinking echo-chamber effects. Rust was in the top 20 again, after slipping a bit.

                        TIOBE’s rankings need to be taken with a bit of a grain of salt, because they’re tracking a lot of secondary factors, OpenHub tracks more objective things and they’re also showing a steady increase in the number of lines of code of C++ changed each month over the last few years.

                        1. 24

                          TIOBE has +/- 50% error margin and even if the data wasn’t unusable, it’s misrepresented (measuring mentions picked by search engine algorithms over a historical corpus, not just current year, not actual usage). It’s so bad that I think it’s wrong to even mention it with “a grain of salt”. It’s a developer’s horoscope.

                          TIOBE thinks C popularity has halved one year and tripled next year. It thinks a niche db query language from a commercial product discontinued in 2007 is more popular in 2023 than TypeScript. I can’t emphasize enough how garbage this data is, even the top 10. It requires overlooking so many grave errors that it exists only to reinforce preexisting beliefs.


                          Out of all flawed methods, I think RedMonk is the least flawed one: https://redmonk.com/rstephens/2022/10/20/top20-jun2022/ although both RedMonk and OpenHub are biased towards open-source, so e.g. we may never learn how much Ada DoD actually uses.

                          1.  

                            My favourite part about the RedMonk chart is that it shows Haskell going out through the bottom of the chart, and Rust emerging shortly afterwards, but in a slightly darker shade of red which, erm, explains a lot of things.

                  2. 8

                    It does seem weird. We find it easier to hire C programmers than Rust programmers and easier to hire C++ programmers than either. On the other hand, there do seem to be a lot of people that want a project to hack on to help them learn Rust, which might be a good opportunity for an open source project (assuming that you are happy with the code quality of learning-project Rust contributions).

                    1. 17

                      The difficulty is that you need to hire good C++ programmers. Every time some vulnerability or footgun in C++ is discussed, people say it’s not C++’s fault, is just a crappy programmer.

                      OTOH my experience from hiring at Cloudflare is that it’s surprisingly easy to onboard new Rust programmers and have them productively contribute to complex projects. You tell them not to use unsafe, and they literally won’t be able to cause UB in the codebase.

                    2.  

                      As a happy user of fish I just really hope this doesn’t disrupt the project too much. Rewrites are hard!

                      Same here. As a user, it doesn’t bother me in which language it is written in. They should absolutely pick the language that allows them to be more productive and deliver more. I have been an happy fish user for 13 years, it is a software that proved useful from.day one. And every realease there are clear important improvements, often times new UX additions. I wish them a smoot migration.

                      1.  

                        This is the actual world we live in. This is what people really think.

                        1.  

                          Why does everyone hate CMake so much?

                          I find it far easier to understand than Makefiles and automake.

                          Plus it runs on ancient versions of Windows (like XP) and Linux, which is not something most build systems support. And it mostly “just works” with whatever compiler you have on your system.

                          1. 5

                            Makefiles and automake are a very low bar.

                            Cargo can’t do 90% of the things that CMake can, but it’s so loved, because most projects don’t need to write any build script at all. You put your files in src/ and they build, on every Rust-supported platform. You put #[test] on unit tests, and cargo test runs them, in parallel. You can’t write your own doxygen workflow, but cargo doc gives you generated reference out of the box for every project. The biggest criticism Cargo gets about dependency management is that it’s too easy to use dependencies.

                            This convention-over-configuration makes any approach requiring maintaining a DIY snowflake build script a chore. It feels archaic like writing header files by hand.

                            1. 5

                              I find it far easier to understand than Makefiles and automake.

                              Why does everyone hate being punched in the face? I find it far more pleasant than being ritually disemboweled.

                              And it mostly “just works” with whatever compiler you have on your system.

                              CMake is three things:

                              • A set of core functionality for running some build tasks.
                              • A truly awful macro language that’s been extended to be a merely quite bad configuration language.
                              • A set of packages built on the macro language.

                              If the things that you want to do are well supported by the core functionality then CMake is fairly nice. If it’s supported by existing packages, then it’s fine. If it isn’t, then extending it is horrible. For example, when using clang-cl, I was bitten by the fact that there’s hard-coded logic in CMake that adds the /TC or /TP flags to override the language detection based on the filename and tell it to use C or C++. This made it impossible to compile Objective-C. A few releases later, CMake got support for Objective-C, but I can’t use that support to build the Objective-C runtime because it has logic in the core packages that checks that it can compile and link an Objective-C program, and it can’t do that without the runtime already existing.

                              I’ve tried to use CMake for our RTOS project, but adding a new kind of target is incredibly hard because CMake’s language is really just a macro language and so you can’t add a new kind of object with properties of it, you are just using a macro language to set strings in a global namespace.

                              I’ve been using xmake recently and, while there’s a lot I’ve struggled with, at least targets are objects and you can set and get custom properties on them trivially.

                              1.  

                                Plus it runs on ancient versions of Windows (like XP)

                                Only versions no one wants to run anymore (i.e. 3.5 and older).

                                1.  

                                  its an entire set of new things to learn and it generates a makefile so I worry that I’ll still have to deal with the problems of makefiles as well as the new problems cmake brings

                                2.  

                                  If you’re curious about the size of the rewriting project: I ran tokei on the repo and it counted 49k lines of C++ 8k lines of headers 1k lines of CMake (and 57k lines of Fish, so there’s also a lot that won’t need to be rewritten)

                                1. 2

                                  Years ago my mother in law saw a Microcomputer Trainer at an op shop and bought it for me, knowing my love for old and slightly arcane computer hardware.

                                  https://vimeo.com/63990422

                                  I believe the Microcomputer Trainer has the same CPU (TMS1100) as the D&D Labyrinth Game.

                                  1.  

                                    It looks like that is indeed the same CPU family, but not running code directly from the RAM (it can’t, it’s Harvard architecture). Instead, this looks like it’s a basic virtual machine in the ROM that maps to similar instructions, see https://www.instructables.com/Radio-Shack-Microcomputer-Trainer-Emulator-in-Scra/

                                  1. 17

                                    Kubernetes is our generation’s Multics.

                                    I (too?) believe it exists because UNIX never moved past being a multi-user operating system for a solitary minicomputer. Users and groups are vestigial organs. Berkeley sockets was a hack. And Plan9 failed.

                                    Erlang is the Galapagos. 😉

                                    1. 17

                                      (author here) Thanks for mentioning it :) I had collected some more links about fundamental design problems with Kubernetes, but I haven’t had time to put them on the blog. I’ll drop a couple good recent links here:

                                      Kubernetes Was Never Designed for Batch Jobs - https://lobste.rs/s/z8gxe6/kubernetes_was_never_designed_for_batch - 4 months ago on lobste.rs

                                      Kubernetes StatefulSets are Broken - https://www.plural.sh/blog/kubernetes-statefulsets-are-broken/

                                      https://news.ycombinator.com/item?id=32439255 - 5 months ago

                                      The tagline is VERY right:

                                      Kubernetes was originally intended to act as a container orchestration platform for stateless workloads, not stateful apps.

                                      An important thing that seems to be lost in the hype is that Google’s Borg (which Kubernetes began as a clone of) was ALSO “intended to act as a container orchestration platform for stateless workloads, not stateful apps”. (I used it for several years across many teams starting ~2007, and tried to write something of my own many years ago.)

                                      That’s because Borg was built for Google search in ~2003-2004. This app requires mind-boggling amounts of CPU/memory/storage/networking, but is very “stateless”. That is, the state was basically tiers of enormous immutable files that were inverting the whole web. There is no online state; there is no notion of consistency and thus no notion of transactions.

                                      This was a world before Gmail or Google Docs existed as public products (Maps and YouTube too).

                                      In the years after Borg was first deployed, the difficulty of running regular non-search, stateful apps on it became well known. The Broccoli man video went viral in Google because so many engineers (including myself) had experienced that pain:

                                      https://www.youtube.com/watch?v=3t6L-FlfeaI

                                      (Although my memory is that it made fun of what I think of as the M requirements x N applications problem [1], not necessarily stateful apps, but both were problems. The status quo for stateful apps was to write your own application-specific distributed database, like GMail, or try to latch on to Bigtable, which was a non-relational DB with no transactions and limited querying ability. It was designed for search.)

                                      I think not until Spanner was there a true solution for fine-grained and consistent state, in applications like Gmail or Google Docs. (FWIW Google ads was the early app other than search, and it the ran MySQL clusters for a long time – like completely into the tens / hundreds of billions of dollars range.)


                                      Anyway, my point is that overall there is a huge problem to be solved, as Kubernetes didn’t solve it. It basically took all the Broccoli Man problems we had over 10 years ago and exported them to the rest of the world. It was NOT designed to run your applications well – hence all the layers of additional stuff you need to run the most basic workloads like a web app with a database.

                                      The problem is to create abstractions that let you run distributed applications on your own hardware, not the cloud. All cloud providers and self-hosters like Hey need to solve this problem! This is similar to Unix letting you bring up say a typesetting package on any machine to create documents, without writing assembly code for that machine.

                                      (Maybe it’s worth rabble rousing a bit more, as I noticed a few months ago that a nascent Kubernetes / systemd “competitor” called Aurae cited my “narrow waist” posts as inspiration:

                                      https://medium.com/@kris-nova/why-fix-kubernetes-and-systemd-782840e50104

                                      https://lobste.rs/s/dwui6j/why_fix_kubernetes_systemd – followup: I didn’t manage to crawl out from under a big pile of work, which is good because we got the garbage collector working :) I’m still looking for people who want to be paid to write this kind of code under our second NLnet grant – contact me if interested.


                                      [1] Good references on this architectural problem:

                                      https://www.oilshell.org/blog/2022/02/diagrams.html#these-abstractions-can-be-designed

                                      https://lobste.rs/s/mjo19d/unix_microservice_platforms

                                      1. 2

                                        Mild nit, because it really has no bearing on your well-written comment:

                                        BigTable does have transactions, they’re just single row, where a row is an arbitrary collection of columns (KV pairs) grouped into column families. This property was/is leveraged pervasively to build transactional applications on BigTable. Sadly (or, perhaps blessedly) some of these systems never had papers published, and avoided opensource projects making their mistakes.

                                        It probably doesn’t reveal too much to say that most applications you’re familiar with that you might guess are using Spanner today predated the wide deployment of Spanner.

                                      2. 6

                                        and https://www.unison.cloud/ is another planet :)

                                        1. 1

                                          Indeed. I wonder if a single language distributed runtime can succeed?

                                          1. 1

                                            I wonder as well! But it’s not more closed than other runtimes in the end (a “traditional” language isn’t better at interop per se). Also if the protocol used for distribution is open, competing runtimes could participate to the cluster. Reinventing a whole ecosystem (again, applicable to non-distributed runtimes as well) is what’s risky.

                                        2. 4

                                          And Plan9 failed.

                                          I’ve been playing with Plan 9 recently and love it. I’m leaning towards the conclusion, though, that I wouldn’t give up Common Lisp programming to switch.

                                          1. 2

                                            Why not both? All you gotta do is port SBCL …

                                            1. 1

                                              I’m not planning to be unemployed for that long ;-P

                                              Seriously, beyond the time issue, there’s also the skill and experience. I’m still planning to (somehow) get mDNS working & integrated with 9front (whether they accept the patch or not is another matter …). But a SBCL port I think would be aiming a bit too high.

                                        1. 1

                                          I wish there were a popular nonprofit alternative I could recommended.

                                          Why is that? SO has made the lives of so many programmers better, myself included. Surely it’s a good thing that the founders are able to profit by it?

                                          1. 4

                                            It’s important enough that it shouldn’t be in the hands of a couple people. If it’s a company, it can be bought; if it can be bought, it can be destroyed. Look at freenode.

                                            1. 5

                                              At least the data/content is licensed and made available in such a way to disincentivise any stewards of the site, current or future, from doing too terrible a job of it.

                                              1. 3
                                                1. 2

                                                  If something is important it absolutely should be in the hands of people who can profit from it, because otherwise it will be going away.

                                                  1. 6

                                                    You’re commenting on a free site about a post someone wrote for free about maintaining software for free for nearly a decade and (my understanding of) your takeaway is that only extraction capitalism can possibly create sustained value.

                                                    Meanwhile musk is burning for-profit twitter to the ground and I can’t take my kids to Toys R Us anymore because hedge firms exist.

                                                    I think we need more nuance and understanding.

                                                    1. 1

                                                      This site exists free of charge and advertising solely through obscurity. Pretending otherwise is disingenuous to say the least.

                                                      1. 4

                                                        Every town in the Western world has churches which are non-profit entities. Whether you think they’re good or bad, they definitely exist and aren’t explicitly profit seeking. There are lots of ways to make a sustainable endeavor. The for profit corporation is one, but there are others.

                                                    2. 2

                                                      Wikipedia? A seemingly close cousin to Stackoverflow.

                                                      1. 1

                                                        I’m aware that it exists, and also that it would be the major exception anybody could mention. Stack overflow is not going to run on the “nag everybody who’s details we have for donations until the heat death of the universe” model.

                                                        1. 2

                                                          Is your argument that Stackoverflow won’t or that it’s impossible and nobody should try? Because the OP said alternative, arguing against the latter, and the existence of Wikipedia stands to me as a beacon of what’s possible, inviting us to imagine and build better.

                                                1. 13

                                                  Last week I got made redundant, along with ~ 14% of staff globally. So this week is mostly about:

                                                  • spending more time with the family and children (end of the school holidays)
                                                  • taking the children on an overnight trip to a local historical village
                                                  • polishing up my resume and re-activating my LinkedIn account
                                                  • cleaning up my Ruby “coding exercise” project in case anyone wants to know if I can still code
                                                  • having a few preliminary chats with my network to see what’s out there
                                                  1. 6

                                                    Good luck!

                                                    1. 3

                                                      Good luck! I just concluded a job search. The market is good - I hope you’ll be pleasantly surprised!

                                                      1. 1

                                                        Any tips on where to find good jobs? I find most job boards lacking in some ways or others - when I’m looking, I’m typically looking for rather specific things and don’t want to waste my time wading through irrelevant posts.

                                                        1. 1

                                                          It probably depends a lot on the kind of job you’re looking for. Lobste.rs has a regular ‘who’s hiring’ quarterly post, perhaps this is a good time for a ‘who’s looking’ version. I’m not actively looking at the moment but I had a quick skim of some of the tech comany’s open hiring and discovered that AMD appears to be trying to build a CPU perf team in the building practically next door to my house. I’m now very curious what they’re working on…

                                                      2. 1

                                                        Sorry to hear and I hope you get everything sorted and the time is well spent!

                                                      1. 2

                                                        This one:

                                                        https://weare.guru/wp-content/uploads/2019/06/1980s-Offices-27.jpg

                                                        … reminds me, in spirit, of a cleantech / control system startup I worked for back in 2013. Honestly gives me better vibes than a lot of modern, far more sterile, office environments.

                                                        1. 6

                                                          My primary “workstation” literally right now as I’m sitting here, having switched to my personal machine from my work-issued M1 MacBook Pro. As you can see it’s very much in a post-Christmas / guests / children state :)

                                                          It’s a ThinkPad X250 running FreeBSD 13.1, on a docking station, with an IBM SK-8840 keyboard, Elecom three-button mouse (not pictured), StumpWM window manager. Monitor is some random 1080p AOC thing on an arm. Probably the most noteworthy thing is the Beastie Scream artwork sticker[1].

                                                          The desk itself is a manually height-adjustable bench type desk thrown out by one of my previous employers, with a replacement top (going from MDF to proper oiled timber).

                                                          [1] Disclosure: I work for the company who sells those :)

                                                          1. 3

                                                            Love the old Thinkpad keyboard, first time I’ve seen this model.

                                                            1. 1

                                                              They’re getting difficult to find. Mine is hooked up to the docking station via a PS-2 to USB adaptor. Interestingly I discovered a failure mode in cheap types of that adaptor that have the mouse reporting as a barcode reader. The second least cheap adaptor on Amazon works fine though :)

                                                          1. 51

                                                            This is a great demo of Cloudflare’s tech stack, but the lock-in factor is strong. You shouldn’t run this unless you’re planning on being a Cloudflare customer forever, because it will never run anywhere else.

                                                            1. 14

                                                              That’s definitely true today, but I also think this could be an interesting starting point for a Deno-based ActivityPub server:

                                                              D1 -> vanilla SQLite (plus Litestream or similar)

                                                              Workers K/V -> Redis

                                                              Page Functions -> Actual, plain JS functions hosted by Deno (local workers)

                                                              Images -> pict-rs (or similar)

                                                              Other implementations tend to be huge (Mastodon, Misskey) or tailored to a single kind of activity (Pixelfed, Lemmy) that make them awkward to use as a base for further experimentation. I for one would be very excited to bang on a lightweight-but-somewhat-featureful alternative like this, once suitably modified to run on an open platform.

                                                              Generally speaking, I’m very resistant to choosing APIs that are locked to one vendor. Services that are generally available but perhaps simpler to deploy on one vendor’s cloud (see: AWS RDS/Aurora) seem like a pragmatic option for those who already have a relationship with that provider. Workers at least seem headed for some level of standardization, for much the same reason that K8s took off so quickly: everyone wants to get ahead of Amazon’s owning this space like they do object storage and general compute.

                                                              1. 6

                                                                If you want small, there’s GotoSocial (single Go binary, SQLite) or Honk (single Go binary, SQLite, no API though). Even more minimally, there’s Epicyon which doesn’t even have a DB, it uses flat files. There’s also another Python one which is strictly single-user but I can’t remember the name of it right now.

                                                                1. 4

                                                                  no API though

                                                                  There is one—honk(3), albeit a bit unusual.

                                                                  1. 3

                                                                    Fair - I should have been explicit with the “no mastodon-compatible API” since that’s what apps and frontends expect.

                                                                  2. 2

                                                                    It should be noted that GoToSocial is still very much alpha software, and while it does implement most of the mastodon api it isn’t 100% compatible yet.

                                                                    This is not to be a downer on it, I really like GTS, I’ve contributed to it (and want to contribute more), and follow along their dev chat. It’s still very usable, just don’t expect it to be able to do everything yet.

                                                                    1. 3

                                                                      The only real issues I’ve had with GtS are 1) OOB OAuth doesn’t give you the code on a page, you have to copy it from the URL (ultra minor and most people will never encounter this); 2) friend requests from Honk don’t work because of the “partial actor key” weirdness GtS has BUT this is exacerbated by a weirdness in Honk where it stores the assumed owner of a key instead of the stated owner. Need to dig into this some more before presenting it as a patch / issue tho; and 3) the weird version number breaks a bunch of libraries which use the version number for feature support (looking at you, Mastodon.py!)

                                                                      Oh and Brutaldon doesn’t work but I can’t get that to work with Akkoma either and I’d be inclined to blame Brutaldon for that rather than GtS.

                                                                      1. 3

                                                                        At least as of version 0.6.0 OOB auth displays it on a page for you, because I was playing around with it and got a nice page that looks like the rest of the UI with the token displayed for me.

                                                                        The version number thing I think is known, because there’s some client that can’t do any searching because it just assumes because it’s low it uses the old mastodon search endpoint. That said I think I agree with their stance that they don’t want to turn the version field into a user-agent string situation. My own thoughts are everybody implementing the mastodon api should probably just add a new “api_version” field or something, which reports the api compatibility, because asking clients to implement logic to determine capabilities based on different server backends feels backwards when your goal is explicitly compatibility with the api.

                                                                        1. 2

                                                                          I’m on v0.6.0 git-36aa685 (Jan 9) and I get a 404 page with the code in the URL for OOB. Just updated to the latest git (v0.6.0 git-132c738) and it’s still a 404 page with the code in the URL. But like I said, this is an ultra-minor issue most people will never experience.

                                                                          [version number <=> features is nonsense]

                                                                          Yep, totally agree but it’s going to be a good long while before we get an api_version field (have you seen how long it takes the Mastodon devs to agree on anything?) and we have to deal with these clients now (e.g. I have to hack my Home Assistant’s local copy of Mastodon.py to get notifications out to my GtS instance.)

                                                                          1. 2

                                                                            to be a good long while before we get an api_version field (have you seen how long it takes the Mastodon devs to agree on anything?)

                                                                            Maybe I’m missing something but API versioning feels like something you’d want from day 0?

                                                                            1. 2

                                                                              Well, there’s /api/v1/XYZ and /api/v2/XYZ but that doesn’t really encompass what these libraries are trying to do by checking the version number because they’re trying to avoid calling endpoints that didn’t exist in older Mastodon versions.

                                                                              e.g., Mastodon.py wraps all of its endpoint methods with stuff like this:

                                                                                  @api_version("1.0.0", "3.0.0", _DICT_VERSION_CARD)
                                                                                  def status_card(self, id):
                                                                              

                                                                              _DICT_VERSION_CARD is 3.2.0 which means that you’ll get an exception if you try to call whatever.status_card(blah) on a server that advertises a version lower than 3.2.0. GotoSocial is currently at v0.6.0 (which breaks the parsing anyway and stops anything from working because v6 isn’t an integer) which would mean that you couldn’t call any endpoints, supported or not.

                                                                              What they should have done is have a capabilities endpoint which lists what your server can do and let the libraries use that as their guide rather than guesstimating from version numbers. Much like SMTP or IMAP banners. Or use the client-server protocol which is server-agnostic but they’ve been waffling about that since 2019 with no progress…

                                                                              https://github.com/mastodon/mastodon/issues/10520

                                                                              1. 2

                                                                                I don’t think they’ll ever really focus on the C2S AP protocol, it doesn’t have the same features and hacking them on sounds like a ton of work. I do agree that some sort of capabilities endpoint would be really nice.

                                                                                Also yeah, agreed that trying to get mastodon itself to add api support for it feels like a huge battle, but I feel like if enough of the alternative servers like akkoma and gts agreed on an implementation, and then implemented something like it, it could force mastodon to conform? But that also has its own problems.

                                                                                At the end of the day I understand why everyone conforms to the mastodon api, but it would be nice if there was some group outside of mastodon and Eugen defining the api spec, with input from the community and developers outside of mastodon, but that’s pie in the sky wistful thinking, and requires a lot of organization from someone, and buy-in from all the other server devs.

                                                                            2. 2

                                                                              Huh, not sure what makes my GTS instance different, but I’m on the release commit, GoToSocial 0.6.0 git-f9e5ec9, and going through the oauth oob flow gave me this after doing my user login (https://imgur.com/sfm19cx), and the URL I used to initiate the flow was https://<my domain>/oauth/authorize?client_id=<app's client id>&redirect_uri=urn%3Aietf%3Awg%3Aoauth%3A2.0%3Aoob&response_type=code&scope=read

                                                                              1. 2

                                                                                I shall have to do a clean install and see if there’s some step I’ve missed during the various updates (which it definitely sounds like I have!)

                                                                1. 1

                                                                  For all I can tell, BASIC seems to have been designed for line-by-line interpretation.

                                                                  As someone who cut their teeth on Locomotive BASIC (on an Amstrad CPC 464), that was most certainly the plan at the time :)

                                                                  Relatedly: I think the thing I love the most about Common Lisp programming with SLIME is that it’s spiritually a return to the immediacy of an interactive BASIC prompt … just with a degree more power that would have been unimaginable at the time.

                                                                  Edited: well, unimaginable at least to anyone without access to a Lisp Machine ;-P

                                                                  1. 32

                                                                    I work at a news site. They’re going to hold the election on a certain day whether I’m ready for it or not. Obviously then the goal is to make an actionable design that can be implemented far enough in advance before the election day to do some testing and whatnot. You can call it what you like, but it’s basically a deadline.

                                                                    Of course, lots of work I do has no deadline. The CMS is upgraded when the CMS is upgraded. So I think it’s worth distinguishing things with real externally imposed deadlines from things with internal goal dates. Goal dates can be shifted. Deadlines are not so easy to move.

                                                                    1. 17

                                                                      I used to work for a edtech company. If features weren’t ready by the start of the school year we’d miss our chance to get the majority of our teachers properly onboarded. Deadlines matter in software because they matter in the meatworld.

                                                                      1. 4

                                                                        The fact that you have to deliver a specific feature for election day is a choice made by humans, not something inevitable. The decision to develop something new before a given date instead of saying “we develop the feature and at the first useful election we use it” is a choice. Deadlines become inevitable when profit is put before software quality. Deadlines are inevitable when people that care about profit hold more power than people that care about software quality.

                                                                        1. 24

                                                                          Profit is more important than software quality. Without profit, people don’t get paid.

                                                                          1. 4

                                                                            that’s revenue. Profit is what pays your manager’s yacht. I work in a non-profit and I get paid every month.

                                                                            Also it’s not true: in start-up economy is not really important to turn a profit. But it’s not the best driver of software quality either.

                                                                            1. 5

                                                                              Are you saying that deadlines happen when people care more about profit than software quality but not when people care more about revenue than software quality?

                                                                              1. 3

                                                                                it depends on the context and mission of the organization but in my experience, in non-profit orgs it’s much easier to reason long term compared to VC-funded startups or big corpos.

                                                                          2. 13

                                                                            Deadlines are also inevitable when the food is going to spoil unless we have a system for distributing it by a certain date. That doesn’t have anything to do with profits, it has to do with the food spoiling; it would spoil just as fast under any kind of system humans can come up with.

                                                                            1. 1

                                                                              It’s quite OT but the logistics of food greatly impact on the spoilage of food in different ways.

                                                                            2. 7

                                                                              “we develop the feature and at the first useful election we use it”

                                                                              I know that Politico takes that approach because they cover lots of elections nationwide. For me, I’m only covering Pennsylvania, so there’s not really enough chance to recoup investment. If we miss 2022, there’s no telling if we’ll even be using the same CMS in 2024. It would be like trying to get the kids ready for school on Sunday morning: you can do some things, for sure, but lots of it really can only be done on Monday morning.

                                                                              1. 3

                                                                                I generally agree, it’s part of the system the engineer is operating inside of…they are linked. It’s the reality we often brush off or ignore. Instead, we tell ourselves (and our customers) this software was “made with 💖” and “we’re making the world a better place.” Fine attitude for a pet project you control, but when you work for a company that’s beholden to VC money or the public stock market, good luck.

                                                                              2. 3

                                                                                So I think it’s worth distinguishing things with real externally imposed deadlines from things with internal goal dates.

                                                                                Failure to do this effectively has been the cause of so many Dilbertesque own-goals - including some of my own - over the several decades I’ve been part of the industry.

                                                                                It’s doubly important for senior leaders. I’ve seen a “gee it would be nice if we had this by $DATE” turn through a series of retellings into a hard deadline, and then eventually horrify the person who spoke off-the-cuff when she discovered how that comment had been taken.

                                                                                1. 2

                                                                                  Indeed – this seems to.me like the difference between a deadline and good old wishful thinking!

                                                                                  1. 2

                                                                                    Distinguishing deadline vs goal date is a good clarification.

                                                                                    If you look at what the article is espousing, it’s exactly what you would want to do with a real deadline: check in regularly on where you are, decide what gets done and what doesn’t get done, and bulldoze everything else out of the way.

                                                                                    Invoking the halting problem’s a bit problematic, because we write many, many programs where we do know when they will finish. We have whole languages (Datalog) that are guaranteed to terminate.

                                                                                    Though most of what I see in articles like this is what the agile community figured out long ago. I still haven’t figured out what the balance of what happened to agile was among sabotage, misunderstanding, or Gresham’s law.

                                                                                  1. 4
                                                                                    • Plan 9 & the Plan 9 dialect of C
                                                                                    • Picking a lane (Bell Labs / Plan 9 simplicity vs. Common Lisp simplicity)
                                                                                    • Decent swimming (Australian crawl)
                                                                                    • Better welding

                                                                                    This may seem like a short list; but my goal for 2023 is better mental and physical fitness, leading to better effectiveness at home and work.

                                                                                    So it’s more about trying to do less, than more. I’ve explicitly postponed several side projects by a calendar year.

                                                                                    1. 5

                                                                                      the X terminals back then had less processing power than a smart toilet seat today so the cpu-intensive clients were running on some mainfraime

                                                                                      The mainframe probably had less processing power than a modern smart toilet seat too. A modern M-profile Arm core is pretty comparable to a high-end workstation from the early ’90s.

                                                                                      I’m honestly quite surprised by this. I thought the xcb push included adding machine-generated parsers and serialisers for all of the X11 wire formats. Do they not handle the byte swapping automatically?

                                                                                      1. 3

                                                                                        A modern M-profile Arm core is pretty comparable to a high-end workstation from the early ’90s

                                                                                        There were a lot of good games and useful office programs back then. What are we wasting that power on today?

                                                                                        1. 16

                                                                                          now we’re wasting cpu cycles on running different copies of chromium

                                                                                          1. 6

                                                                                            Some of it is wasted, but a lot is actually useful:

                                                                                            • Spell checking dictionaries are now big enough to have few errors and spell checking as you type is a huge quality of life improvement.
                                                                                            • Embedding a large image doesn’t slow the editor to a crawl of cause it to crash. I remember having to dither images to black and white in an external editor so that my word processor could display them without thrashing.
                                                                                            • Modern word processors (sadly, not Word) can use the dynamic programming approach to line breaking and even page layout from TeX, which was completely infeasible to do in real-time back then.
                                                                                            • Persistent undo is on by default in a lot of places (even vim!), so quitting an application doesn’t cause it to crash.
                                                                                            • Antialiased font rendering consumes a lot of cycles, especially with font hinting. I think someone worked out that around 50% of the CPU cycles in early OS X systems were spent on text rendering, Quartz Extreme was a huge win there but required a GPU.
                                                                                            • I can now run multiple applications at a time without thrashing. Back in the early ‘90s, I often had to save and quit one app to do anything in another.
                                                                                            • Network access is built in, including live syncing. I’ve recently had a machine die and was able to keep working on another one with no loss of data. I spent weeks in the ‘90s trying to recover data after failures.

                                                                                            And that’s just off the top of my head.

                                                                                          2. 3

                                                                                            X11 came out in 1984. An I expanded 128KB Macintosh with a 7Mhz M68k processor was $6500 in today’s dollars. $6500 today would get you an absolute beast of a desktop now.

                                                                                            Heh, I just checked and a base Mac Pro today costs almost exactly $6500.

                                                                                            1. 0

                                                                                              Except, courtesy inflation, that $6,500 is now worth $18,644 today.

                                                                                              If more people saw inflation as a tax, I swear there’d be rioting in the streets.

                                                                                              1. 3

                                                                                                If more people saw inflation as a tax, I swear there’d be rioting in the streets.

                                                                                                The economy has grown a lot in the last 40 years too.

                                                                                                1. 0

                                                                                                  It certainly has, but it looks (to me as a layperson) as though inflation has negated that. If you look at the value of the S&P 500 expressed in USD you can clearly see growth:

                                                                                                  https://i.postimg.cc/W3yVJnwp/sp500-1983.png

                                                                                                  But if you look at the value of the S&P against gold, it looks a lot less rosy:

                                                                                                  https://i.postimg.cc/2SJ9NKGx/sp500-1928.png

                                                                                                2. 3

                                                                                                  It was $6500 in today’s dollars. At the time it was priced at $2495.

                                                                                                  1. 2

                                                                                                    Ah, I’d missed that. Point still stands though - that’s an alarming amount of inflation.

                                                                                                    This probably isn’t a unique thought, but I wonder if this sort of currency devaluation is only socially possible in the context of rapid technological improvement.

                                                                                                    In other words, will people notice that a high end workstation that used to cost $2500 now costs $6500, if it’s so much more capable?

                                                                                                    1. 5

                                                                                                      In other words, will people notice that a high end workstation that used to cost $2500 now costs $6500, if it’s so much more capable?

                                                                                                      There is no relative price change when you compare to the median household income (it is even slightly cheaper now):

                                                                                                      1. 1

                                                                                                        Which is what you’d expect. Wages (generally) inflate along with goods & services. What doesn’t inflate is savings.

                                                                                                        1. 3

                                                                                                          What also doesn’t inflate is debt. And debt is really common. Moreso than savings.

                                                                                                          1. 1

                                                                                                            Yup. Which is one of the main reasons Governments worldwide, of almost all political and economic flavors, favour high inflation.

                                                                                              2. 2

                                                                                                XCB mainly affected the client side, not the X server. There was, as always, grand plans for also applying it to the Xorg dispatch - alas: protocol.txt

                                                                                                The dispatch in Xorg has a whole lot of “C89 and before” that was never really battle tested or fuzzed for big endian – as soon as you enable them you get a whole lot of viable attack surface. The only xcb code you’ll find inside Xorg itself is in select parts of the DDX (integration platform) that deal with other windowing system integration (mswin, darwin, …) where it turns out to be easier to spawn worker threads which connect to the xserver via a socketpair.2 preauthenticated connection for things like clipboard and dnd than it would be to try and wriggle the same data out of the internal xorg structures.

                                                                                                1. 1

                                                                                                  Thanks. I vaguely remembered reading a blog post or news article that the XML protocol descriptions that XCB used would also be used for the server parts but it sounds as if that never happened.

                                                                                              1. 14

                                                                                                Flash has to be one of the greatest failures in software history:

                                                                                                • Billions of users
                                                                                                • Content exceeding any of the app stores at the time
                                                                                                • Covering lots of different platforms
                                                                                                • Completely and fairly suddenly dead-ended / desupported / shut down 🤦‍♂️

                                                                                                I still think the #1 reason why Apple blocked it on the iPhone is that Flash represented the only real competitor to iOS at the time (pre-Android): Cross platform, graphical, tons of content and games.

                                                                                                1. 30

                                                                                                  I think it was more that Flash was a CPU hog (esp on early mobile CPUs), buggy, and an endless source of security holes. And as a browser developer, you couldn’t do much about that because it was a proprietary binary blob guarded by Adobe.

                                                                                                  I worked on the Chrome team around that time. They hated Flash too. Google actually wrangled the right to make some fixes/optimizations to it, but the source code could only live on one machine in a locked office that only a few engineers had access to.

                                                                                                  1. 9

                                                                                                    Apple also added some special paths through the GPU driver for it. It was pretty amazing to me that, playing the same video file, Flash on a Core 2 Duo MacBook Pro consumed more CPU than the PowerPC version of VLC under Rosetta.

                                                                                                    As I recall, the big problem with Flash was the structure of the rendering pipeline. They did some compositing after drawing, which was quite efficient on a pure CPU pipeline but was impossible to offload efficiently to GPUs. It required doing some CPU-side rendering, compositing on the GPU, then shipping the texture back for more drawing. With AGP, this was even worse than on later PCIe systems, because AGP was highly asymmetric and was optimised for sending data to the GPU. This was a real problem for video players because things like subtitles or UI elements had to be drawn on the rendered frame rather than rendered to another texture and composited. This made it almost impossible to take advantage of GPU offload for video decode.

                                                                                                    In contrast, with something like CoreAnimation, the app ships the compressed frame to the GPU, where it is decoded and stored in a texture. It draws the subtitles for a few frames (subtitles don’t change every frame) and ships those to the GPU. It typically renders the UI buttons once and sends those. It then runs a small program to say ‘draw this frame, composite the subtitles from her, and the UI buttons from these textures’, which involves very little CPU, little bus traffic, and barely warms up the compositing engine (even 20 years ago, texture engines were designed to do 10+ million pixels per second compositing operations).

                                                                                                    Somewhat depressingly, there were a lot of great things about Flash. ActionScript had a load of features that are only just being added to JavaScript. The implementation was, I thing, the first ever production-quality trace-based JIT and was a lot faster then contemporary competitors.

                                                                                                    1. 2

                                                                                                      That’s interesting! I’d never heard those details about its rendering.

                                                                                                      Flash does have a legacy in that it directly inspired HTML 5. After almost a decade(?) where HTML hadn’t changed much, the browser folks realized that the best way to fix Flash was to add its compelling features to Web standards.

                                                                                                    2. 4

                                                                                                      the source code could only live on one machine in a locked office that only a few engineers had access to.

                                                                                                      Were they embarrassed? Afraid of a flurry of new vulnerabilities as many eyeballs found the bugs? Were there licensed technologies in there that prohibited them from releasing the source?

                                                                                                      Naively I’d assume that the only option to prevent Flash’s slide into irrelevance would have been to open the source and attempt to build a community around it (around the implantation that is, not Flash itself).

                                                                                                      1. 1

                                                                                                        Yeah, from a business point of view, Adobe should have done more to make the client open and free so that they could continue to charge money for the development apps. It has worked for PDF!

                                                                                                        1. 2

                                                                                                          As I recall, the SWF file format was pretty well documented and there were third-party tools that could generate them. I think the license was weird: you could use the Adobe docs to implement SWF generation, but not SWF parsing, and so the third-party tools couldn’t be used to edit Flash movies generated by Adobe Flash and you couldn’t implement a compatible player without reverse engineering. This was almost clever: it meant that there couldn’t be any interoperability between SWF authoring tools because they all had the same export format but different save formats and so it was hard to switch from the Adobe tools to a competing product, yet competing products existed and made the format seem open.

                                                                                                      2. 2

                                                                                                        Totally agreed that everyone hated Flash, including the people maintaining it and the people building apps for it. It was a CPU hog, and it was poorly accelerated. There were all sorts of reasons why in its desktop-browser-focused-incarnation, it was a poor fit for mobile devices. But it was already cross-platform, had a working tool-chain, and a lot of content. It really isn’t that great of a leap to think about possibilities outside of desktop browsers on x86.

                                                                                                        1. 1

                                                                                                          Yes, but the aforementioned hogginess meant it didn’t have acceptable performance on mobile. IIRC Adobe did manage to produce a version for Android but it never got any traction.

                                                                                                      3. 12

                                                                                                        Flash represented the only real competitor to iOS at the time

                                                                                                        Maybe, but the original iPhone was supposed to run mobile web apps. So, at least initially, there was nothing for Apple to protect by blocking Flash. To me, it seems more likely that Flash 1) was a major drain on the battery, and 2) had terrible mobile UX because the ecosystem predated ubiquitous touchscreens.

                                                                                                        1. 1

                                                                                                          I’m suggesting that Flash could have been the cross-platform solution that could have run on iOS, could have run on any other mobile OS, and could have served as the graphical shell for a new OS. There was a toolchain, and a developer base, and a lot of content. All that was missing was working software from Adobe 🤣

                                                                                                          1. 1

                                                                                                            RIM tried this with the PlayBook and it didn’t work out too well.

                                                                                                            1. 1

                                                                                                              So true. I didn’t suggest that Adobe would have succeeded; just that they were well positioned, and lacked understanding of the market and how it was shifting.

                                                                                                        2. 11

                                                                                                          I still think the #1 reason why Apple blocked it on the iPhone is that Flash represented the only real competitor to iOS at the time (pre-Android): Cross platform, graphical, tons of content and games.

                                                                                                          That is utter BS.

                                                                                                          Flash was catastrophic for battery life on laptops, and those are devices with actual battery capacity. The performance of flash when a (era appropriate) phone cpu was used was abysmal (see the many complaints about poor frame rates, etc on flash on android), so the idea that the vast library of existing flash games was somehow going to magically be available;e is nonsense. Flash, and all those flash apps, did not work with touch interfaces, and on top of that accessibility of desktop flash apps was already awful, and phones leverage accessibility interfaces much more aggressively than full size devices.

                                                                                                          Flash (and plugins in general) by design involve injecting 3rd party code into the browser processes, and they are responsible for unending biocompat problems over the years: they aggressively screwed with host browser internals, and would semi-regularly be responsible for the highest volume crashers for every browser. Other plugins were historically the source of yet more of the high volume crashes, but less significant over the OS as a whole because none were as mandatory as flash, so had nothing like the install volume of flash.

                                                                                                          Finally there is the catastrophic security story of flash. Flash spent years, maybe a decade as one of the largest sources of security critical bugs in the browser environment, and despite this made no effort to actually improve its security profile: browser vendors recognized the problem and spent decades (even before chrome) trying to make the engines intrinsically more secure (hardened allocators, runtime type checking, etc) eventually (chrome) more sandboxing and process isolation (which again, flash made hard). In the same time Adobe did nothing to try and fix or harden anything.

                                                                                                          Finally, to address “competing with the App Store”: the App Store did not originally exist, there was no store for there to be competition with. The app story for iPhone was *web apps” - it was developers demanding native apps that led to the App Store.

                                                                                                          1. 1

                                                                                                            I’m not going to argue random engineering points that are outside of the realm I was describing.

                                                                                                            Apple wouldn’t have preemptively blocked Flash if it weren’t a threat to their business.

                                                                                                            1. 8

                                                                                                              Apple did not “block flash”, apple did not implement support for a fundamentally unsound technology. This isn’t “everything existed and then apple removed it”, this is “there was no such thing, and they didn’t add it”. More over, making a BS claim about engineering decisions, and then saying you’re ignoring engineering matters that drove the decision is itself BS.

                                                                                                              It’s like saying “Tesla not letting me replace the car battery with a 9v Duracell battery is just because they don’t want a competitor. Obviously I’m going to ignore the engineering reasons because they are relevant to this decision to restrict competitors”.

                                                                                                              You need to acknowledge that engineering constraints impact engineering decisions, rather than dismissing them because you don’t understand them, or have a bizarre misunderstanding of the ecosystem. Again: flash was not a competitor to the App Store: there was no f’ing App Store.

                                                                                                          2. 10

                                                                                                            Billions of users

                                                                                                            There weren’t a billion online users in 2006.

                                                                                                            Content exceeding any of the app stores at the time

                                                                                                            There weren’t any app stores at the time.

                                                                                                            Covering lots of different platforms

                                                                                                            If you count “lots” on one hand, sure.

                                                                                                            I still think the #1 reason why Apple blocked it on the iPhone is that Flash represented the only real competitor to iOS at the time (pre-Android): Cross platform, graphical, tons of content and games.

                                                                                                            The first iPhone (2007) didn’t have the app store – the original idea that web pages would simply be added to the home screen (and maybe get some new APIs in the process) suggested to me at least, that owning the channel (or app store) wasn’t something Apple had been thinking about yet.

                                                                                                            Symbian phones at the time (2006) had flash player but it was even worse than the “desktop” player, and really since Adobe took over flash, it only ever got worse. If there were apps and games that “worked” on desktop, they almost certainly crashed the entire phone, but if you put in the work to make a “lite” flash player app, it still might not work at all because of bugs in the extension loader. Flash was already a dumpster fire with a bad reputation.

                                                                                                            It was this version of flash that would’ve been demoed to Apple, and it would’ve been this version that was rejected and since nobody was thinking app store yet, this suggests to me whatever reason flash didn’t make it had much more to do with flash than with Apple.

                                                                                                            Completely and fairly suddenly dead-ended / desupported / shut down

                                                                                                            This is Adobe’s fault. They bought Macromedia, thought they could just sit on it and do nothing for years, then when they did do something, they could do it half-assed. Go read the investor’s reports from those years – zero mention of App stores or anything they’re r&d doing to help users – it’s all, lock in those hardware integrators with licensing and it’s going to go on forever because flash (as an integrated tool) “is the best”. Seriously read them. Nobody who has ever used flash could read that crap and say yeah, this is going to be hot. Adobe had killed flash’s chances before the iPhone ever happened.

                                                                                                            1. 2

                                                                                                              The App Store was announced in fall of 2007 and must have been planned even before the launch of the iPhone. That said, I’m sure they imagined it initially as being like the app stores on feature phones at that time: a small number of blessed versions of Snake and Solitaire that charge you $3/month on your phone bill. The idea of a user friendly App Store probably took more time to work out and it seems like they even surprised themselves with how popular it turned out to be.

                                                                                                              1. 4

                                                                                                                The App Store was announced in fall of 2007 and

                                                                                                                Go read the iPhone announcement. Zero mention of an app store. Go read the developer guidance we got prior to the release of the. Zero mention of an SDK or a publishing channel.

                                                                                                                must have been planned even before the launch of the iPhone

                                                                                                                Why?

                                                                                                                I’m sure they imagined it initially as being like the app stores on feature phones at that time: a small number of blessed versions of Snake and Solitaire that charge you $3/month on your phone bill.

                                                                                                                I’m not sure they imagined anything at all. I remember those websites that would send you a ringtone via a premium SMS number, and they worked just fine on early iPhones. The wap/wml sites that delivered calculators and snake and other such things were obsolete as soon as you had a web browser.

                                                                                                                However even if they imagined something like that, remember that the SDK didn’t even come out until 2008 – which is two years after Adobe and Apple would’ve been talking about putting flash on the iPhone, so the idea that sort of thing was precious enough to forego short-term revenue (and “block” Adobe) just seems preposterous to me. It just seems much more likely that Flash sucked and nobody wanted to license the suck if they didn’t have to.

                                                                                                                1. 3

                                                                                                                  Zero mention of an SDK or a publishing channel

                                                                                                                  Possibly even less than zero. The App Store only made sense because the iPhone was successful. This was what killed all of the Symbian ones. The Symbian ecosystem was like the mainframe ecosystem: you could, with some rewriting, port a program from one Symbian phone to another, but you definitely couldn’t write an app targeting the thousands of different models of Symbian phones that were available at the time. If the iPhone had been successful on the scale of the Mac (5-7% market share), then developing apps targeting the iPhone wouldn’t have been a particularly sound investment for most companies. The pitch from Apple was that the iPhone was great at running web apps and so you explicitly didn’t have to write an iPhone app, you wrote a web app and tweaked it very slightly to make it work well on the iPhone. 90% of your users were on desktops anyway, so you didn’t want to invest more than a few percent of the total development costs on the mobile segment.

                                                                                                                  Remember that the iPhone predated Android. At the time, the competition was a mess of Symbian (with at least 5 different UI frameworks, each one exclusive to one line of phones), a few Maemo / MeeGo / whatever it’s called this week Linux devices, some PalmOS devices, some WinCE things, and so on. It wasn’t clear that the ecosystem would coalesce around a small number of operating systems anywhere nearly as quickly as it did, or that mobile providers would stop having such stupid plans (I had a 40 MiB/month data allowance with a smartphone contract then!) and make mobile Internet actually possible (remember WAP?).

                                                                                                                  I wouldn’t be surprised if Apple had been thinking about launching an App Store, but they couldn’t have done it without the phone already being far more successful than expected.

                                                                                                                  1. 3

                                                                                                                    I’m basing fall 2007 on Wikipedia: https://en.wikipedia.org/wiki/App_Store_(iOS/iPadOS)#History To be fair, that just announced an SDK. The actual store was unveiled the following summer.

                                                                                                                    My belief is that Flash was technically unsound and that was the main reason for excluding it from iPhone.

                                                                                                              2. 10

                                                                                                                Security holes, security holes, security holes. Adobe wanted Flash to be the one-system-does-it-all, and so added all sorts of access to system resources. Of course, they had security rules for the access, but of course they weren’t all that well thought out, and they were forever trying to patch zero-days. They finally realized that they were trying to bail the ocean, and rather than continue they bailed.

                                                                                                                1. 6

                                                                                                                  I don’t remember many ACL-based vulnerabilities with flash. The main problem was that it was a huge codebase full of memory-safety bugs that ran with ambient authority of the user (browsers weren’t typically sandboxed back then) and so a single bug allowed arbitrary code execution with the user’s privilege. On *nix, there was a wrapper to run plug-ins in a separate process, which let you sandbox Flash, and there it wasn’t nearly so bad.

                                                                                                                  1. 2

                                                                                                                    I totally remember the security holes. The plug-ins were a non-stop disaster.

                                                                                                                    The thing is, there’s a difference between making a browser plug-in, and making a graphical OS (probably mounted on top of *BSD or Linux, like iOS and Android.) I’m not suggesting that Adobe had the talent package to pull that off; I’m suggesting that they had the business position and IP portfolio from which such a project could have been launched.

                                                                                                                    1. 3

                                                                                                                      They had positioned Flash and Adobe Air as a “one size fits all” development platform, and lots of people were using it to the hilt (I was one of them). They couldn’t remove all those nifty OS-level features without hamstringing well-intentioned products, so they tried to fix it, and fix it, and fix it. By the time they realized the depth of the trouble, it was too late, and all they could do was to give advance warning that it would be abandoned.

                                                                                                                      1. 2

                                                                                                                        I had friends there as it collapsed, and it sounded pretty ugly. It seems that the cost model of maintaining all of the plug-ins was super high, and the revenues had largely disappeared after Steve Jobs said that he wouldn’t allow it on the iPhone.

                                                                                                                        Ironically, Java first turned a profit not from licensing, tools, or support, but by selling ads (e.g. for browser toolsbars) on the Java installer, which was constantly being updated to fix security bugs. Adobe missed their opportunity.

                                                                                                                1. 32

                                                                                                                  I think most people don’t realize how radical the “Bell Labs gang”’s conceptualization of simplicity is. It is rooted in a deep suspicion of any kind of abstraction and a defeatist attitude when it comes to building them:

                                                                                                                  • The abstractions you build will always be leaky, and your users will be forced to understand the underlying system sooner or later, so don’t bother with creating a complete self-sufficient system of abstractions.

                                                                                                                  • Any abstraction complicates the system, so build as few abstractions as possible, and make the abstractions themselves as simple as possible.

                                                                                                                    (It’s worth stressing that “making abstractions themselves simple” is about the concept provided by the abstraction, not the implementation. For example, the implementation of GC and goroutines are very complex, but the concepts they introduce are simple. In fact, GC doesn’t so much introduce new concepts than take away the concept of memory deallocation.)

                                                                                                                  This attitude has long been criticized for resulting in leaky, incomplete, “half-assed” (as called by the author in a previous article), because it does. The UNIX-HATERS handbook labelled it as “worse is better” (which ironically got reclaimed by the Bell Labs gang). These criticisms are based on the anticipation that high-level abstractions should form a coherent system that completely covers a low-level system, and not require the user to understand the low-level system. But the Bell Labs gang says “you won’t get it right, so don’t bother”.

                                                                                                                  Dennis Ritchie said that “UNIX is very simple, it just needs a genius to understand its simplicity”. I don’t think it would take a genius to understand the simplicity of Unix, but it does require you to have a mental model of the system Unix runs on and what Unix’s abstractions are actually abstracting over.

                                                                                                                  Instead of passing judgements on which one of the Bell Labs gang and its critics are right, I think that it’s important to think of the design of computer systems as the constantly revolving field it is, with movements and counter-movements, instead of a monotonic approach towards an ideal state. Indeed, Unix and C were created as reactions against Multics (and presumably PL/I). Go was a reaction against C++ and Java. Rust is still too young to have its “Bell Labs gang” style reaction, but it would be very interesting to see one in future.

                                                                                                                  1. 7

                                                                                                                    (It’s worth stressing that “making abstractions themselves simple” is about the concept provided by the abstraction, not the implementation. For example, the implementation of GC and goroutines are very complex, but the concepts they introduce are simple. In fact, GC doesn’t so much introduce new concepts than take away the concept of memory deallocation.)

                                                                                                                    The “worse-is-better” philosophy described in Richard Gabriel’s essay [0] actually prioritizes implementation simplicity over interface simplicity. Maybe GC and goroutines don’t reflect this, but you wouldn’t expect every principle to be operative in every decision.

                                                                                                                    [0] https://people.cs.umass.edu/~emery/classes/cmpsci691st/readings/Misc/Worse-is-Better.pdf

                                                                                                                    1. 3

                                                                                                                      Thanks, you are right that it was Richard Gabriel who coined the term.

                                                                                                                      But I quibble with the characterization that the Bell Labs gang prioritizes implementation simplicity over interface simplicity. Unix’s fork() was not simple to implement (at least not a performant way) but it presented a simple interface for controlling process creation. Neither was a single-root filesystem at that time, but again the interface is relatively simple. C’s printf() is also not simple to implement but the API was nice and simple (for the time).

                                                                                                                      1. 10

                                                                                                                        Unix’s fork() was not simple to implement

                                                                                                                        Yes it was. The systems that it was designed for had one resident process in core at a time. Context switch meant writing that process out and reading another one in. With fork, you just skipped the second step, keeping the existing one and just updating some kernel data structures to say that this is really a new instance. It only became difficult to implement on systems with MMUs and multiple resident processes, but that was a decade later, by which time it was ingrained.

                                                                                                                        1. 2

                                                                                                                          I stand corrected then, perhaps Go shifted a bit more in the direction of interface simplicity.

                                                                                                                        2. 2

                                                                                                                          His example in the essay is how interrupted system calls are handled. In the “better” OS, there is a bunch of tricky work to do state switching in the kernel so the userspace API sees a simple call-return API no matter what. In Unix, the OS just throws everything away, returns an EINTR error, and expects userspace to put a loop around every system call so it can retry.

                                                                                                                          BTW, in early Bell Labs Unix, I’m pretty sure the implementation of fork was quite simple and performant, because there was no virtual memory. The performance tricks arrived with BSD, if I recall correctly. So that actually is an example of choosing a worse interface (fork is really quite a bizarre API compared to “create a new process”) for implementation simplicity.

                                                                                                                          1. 9

                                                                                                                            fork is really quite a bizarre API

                                                                                                                            I’m still not entirely sure it isn’t some sort of epic joke.

                                                                                                                            https://rachelbythebay.com/w/2014/08/19/fork/

                                                                                                                            Guess what happens when you don’t test [fork] for failure? Yep, that’s right, you probably treat “-1” (fork’s error result) as a pid.

                                                                                                                            That’s the beginning of the pain. The true pain comes later when it’s time to send a signal. Maybe you want to shut down a child process.

                                                                                                                            Do you kill(pid, signal)? Maybe you do kill(pid, 9).

                                                                                                                            Do you know what happens when pid is -1? You really should. It’s Important. Yes, with a capital I.

                                                                                                                            Here, I’ll paste from the kill(2) man page on my Linux box.

                                                                                                                            If pid equals -1, then sig is sent to every process for which the calling process has permission to send signals, except for process 1 (init), …

                                                                                                                            See that? Killing “pid -1” is equivalent to massacring every other process you are permitted to signal. If you’re root, that’s probably everything. You live and init lives, but that’s it. Everything else is gone gone gone.

                                                                                                                          2. 2

                                                                                                                            Abstraction and software in general is about creating a relatively simple interface with a relatively complex implementation. The philosophy of prioritizing implementation simplicity only makes sense within a spectrum of decision defined by other factors, so examples only make sense in comparison to some other system or group of engineers with similar goals and constraints.

                                                                                                                        3. 6

                                                                                                                          These criticisms are based on the anticipation that high-level abstractions should form a coherent system that completely covers a low-level system, and not require the user to understand the low-level system.

                                                                                                                          I haven’t seen that happen in the years that I’ve been around, at least. My experience with ambitious systems of that sort is:

                                                                                                                          • 97% are trash.
                                                                                                                          • 3% are actually quite pleasant, and good enough that you can mostly use them on their own terms.
                                                                                                                          • 0% are so good that you never need to source-dive, monkey-patch, or start reading CPU-level performance counters.
                                                                                                                          • “Having a mental model of the system it runs on and what its abstractions are actually abstracting over” will get you superior results 100% of the time.

                                                                                                                          In practice, I would generally rather have something that attempts less, that I can use as a solid part of the solution to my problem, than to use a library that attempts everything, which almost-but-not-quite solves my problem, and which has such an extensive vocabulary of its own special abstractions that interfacing it to something else to provide the missing part requires reverse-engineering the authors’ brains.

                                                                                                                          1. 4

                                                                                                                            This is an understandable viewpoint, but Go’s design is not simple. I usually start with the numeric types – which hardware was it designed for, and what safety properties are its abstractions designed to protect?

                                                                                                                            1. 6

                                                                                                                              I don’t understand what your point is, but I suspect you are using a more specialized definition of simple than the workman definition. In other words, talking past the Op.

                                                                                                                              1. 2

                                                                                                                                I typically assume that “simple” and “complex” are relative to the speaker’s experience. Let me sharpen the point: on which hardware does Go’s assortment of numeric types make sense? Are they abstracting over the hardware? I might pick on e.g. complex128, which I don’t think is a native type of any hardware, or uintptr, which enables unsafe actions that undermine the GC’s safety guarantees.

                                                                                                                                1. 6

                                                                                                                                  Neither of those types are commonly used in production Go code.

                                                                                                                                  1. 5

                                                                                                                                    uintptr does no such thing. You need to import the unsafe package to do anything unsafe.

                                                                                                                                    1. 2

                                                                                                                                      Most modern CPUs have registers that can fit a complex128, can add or subtract them in a single instruction, and multiply them in a handful (maybe 4). Division is more complicated, but then again I’ve worked with CPUs that lacked instructions for dividing integers, but I don’t think many people claimed that int8 wasn’t a native type :)

                                                                                                                              1. 3

                                                                                                                                I’m learning Plan 9 at the moment (specifically, 9front) and it’s fascinating to see the philosophical similarities between Go and the Plan 9 dialect of C.

                                                                                                                                http://doc.cat-v.org/plan_9/programming/c_programming_in_plan_9

                                                                                                                                A better idea is to give the programmer the ability to handle any error that comes in without worry of losing standards compliance or clarity, and to generate any error without falling into a surfeit of possibility. So the designers of Plan 9 decided to use strings instead of numbers. Each program has an error string which is set by routines when an error occurs. And each program returns a string to the host environment with the exits system call. The value given to exits can be accessed from rc through the environment variable $status.

                                                                                                                                So with a string, how do you represent a lack of error? Why, with a null pointer or null string! Because the constant 0 turns into a null pointer, the statement

                                                                                                                                exits(0);

                                                                                                                                does everything already. Of course you can also say

                                                                                                                                exits(nil);

                                                                                                                                or

                                                                                                                                exits(””);

                                                                                                                                1. 11

                                                                                                                                  I might be missing it, but would be nice if there were some screenshots

                                                                                                                                  1. 3

                                                                                                                                    lchat (line chat) is a line oriented front end for ii-like chat programs

                                                                                                                                    This means there literally is nothing to screenshot - it’s just lines of text in a terminal. Anything visually noticeable would come from the shell/terminal.

                                                                                                                                    1. 11

                                                                                                                                      it’s just lines of text in a terminal

                                                                                                                                      But that’s something you can show. It sets expectations.

                                                                                                                                      1. 7

                                                                                                                                        That still can be shown. I have no idea what to expect from this so I won’t bother.

                                                                                                                                        People working in Open Source need to learn a little bit of technical writing and marketing stuff.

                                                                                                                                        1. 5

                                                                                                                                          I’d argue that people need to learn not to tell other people what to do in their free time. ;)

                                                                                                                                          I also wouldn’t be surprised if at least some suckless devs try to avoid marketing on purpose.

                                                                                                                                          On the technical writing bit. I wished more commercial tools came with proper man pages rather than huge pages of buzz words or a list of which company “uses” it.

                                                                                                                                          1. 8

                                                                                                                                            As mat commented below, author posted his work here, so obviously want to show it and acquire potential users. It’s a waste of time creating something for others and not showing it’s capabilities with a clear, concise explanation. When I open source something for the benefit of the public, sometimes I spend MORE time properly documenting it and making it easier to use, showcasing what it can do and what value does it provide for the users.

                                                                                                                                            No need for buzzwords, just describe me what the thing does in a couple of sentences/screenshots.

                                                                                                                                            “Marketing” has real value, not just bullshit, but can be abused obviously. That’s not what I suggested here.

                                                                                                                                            As for comment on free time, I’m so tired of the idea that if you doing something in your free time, you are not allowed to do it properly, or provide high quality work, I don’t understand that reasoning, that’s just nonsense.

                                                                                                                                            1. 3

                                                                                                                                              younix posted their work here, so I feel like it’s probably safe to assume they were looking for feedback.

                                                                                                                                              do you have any examples of tools that have a buzzword-laden marketing page but no man pages? this is not a phenomenon with which I am familiar

                                                                                                                                              1. 3

                                                                                                                                                I’d argue that people need to learn not to tell other people what to do in their free time. ;)

                                                                                                                                                You’ve just dismissed any critique of… literally anything completed outside of wage labor. This is not a useful contribution to any kind of discussion. ;)

                                                                                                                                                1. 1

                                                                                                                                                  How so? You didn’t criticize, you imperatively told people what to do. I did that in the same style as your sentence.

                                                                                                                                                  Also despite not quoting it I gave you a reason for why it might not be the way you want it to be.

                                                                                                                                                  Just for you to respond that my criticism of your statement is “not useful”.

                                                                                                                                              2. 1

                                                                                                                                                and marketing stuff.

                                                                                                                                                I’ve seen that claim - poor marketing - leveled at a few outfits including suckless and sourcehut.

                                                                                                                                                I think it’s wrong, and in fact their marketing is excellent. Consider the niche they’ve gone after, and won.

                                                                                                                                            2. 1

                                                                                                                                              I thought about that, too. In default its just “tail -f out” with an “>” input prompt.

                                                                                                                                              The UI of lchat is outsourced to the .filter program/script and the other .title and .prompt files. If you have something fancy there, than its worth to screenshot it. I experimented with the filter/indent.c program and some awk and sed scripts, but none of them is ready to use yet.

                                                                                                                                              When someone creates some cool filter for lchat, I would publish them on the suckless website.

                                                                                                                                            1. 2

                                                                                                                                              What does this imply?

                                                                                                                                              1. 16

                                                                                                                                                GParted in 3D is now legal

                                                                                                                                                1. 1

                                                                                                                                                  … in countries that allow software to be patented. Some countries - for example, New Zealand, exclude software from patents, meaning 3D GParted should always have been legal there.

                                                                                                                                              1. 2

                                                                                                                                                Starting to learn Plan 9 properly. Day one has resulted in a bunch of notes, and a corrupt filesystem requiring re-installation.

                                                                                                                                                I think I’m going to have only a few, simple, goals for 2023:

                                                                                                                                                • Learn Plan 9 (specifically, 9front) well enough to know whether I want to switch to it from FreeBSD, and whether that’s feasible (given non-negotiable requirements to use both Signal and Mattermost).
                                                                                                                                                • Get my weight down to 86kg.
                                                                                                                                                • Fix my approach to work (currently very heavy on meetings; struggling to have any time for deep thinking or strategic work).

                                                                                                                                                Mercifully point 3 can wait until I’m back in the office (virtually speaking). At the moment I’m enjoying spending most of my time on leave with my family :)

                                                                                                                                                1. 3

                                                                                                                                                  If I may be allowed to go off-topic for a second and plug a coupe of books that couldn’t be reasonably expensed:

                                                                                                                                                  https://www.amazon.com.au/Unix-Primer-Plus-Waite-Group/dp/0672220288

                                                                                                                                                  I found this book in the local small-town library as a child, when I was around ten years old. Up until then I’d only ever used home 8-bit microcomputers like Amstrad CPCs and Apple 2s. It blew my tiny mind :)

                                                                                                                                                  I bought a copy around 30 years later and found that it had aged surprisingly well. I was particularly surprised by the fact that several of the Unix users and programmers in the book were female; I honestly hadn’t expected that for a book of this vintage.

                                                                                                                                                  You could actually take this book and use it to find your way around a modern FreeBSD or Linux system with surprisingly little friction. I don’t know whether that says good or bad things about our profession ;)

                                                                                                                                                  https://www.amazon.com.au/Programming-Z80-Rodnay-Zaks/dp/0895880695

                                                                                                                                                  This was my Bible as a ten year old hobbyist. I borrowed it from the library so often I was asked to leave it on the shelves for a bit in case anyone else wanted it. The funny thing is that as an adult I remembered it being this huge weighty tome; when I actually bought a copy though it’s a fairly slim technical book.

                                                                                                                                                  It’s still a very useful reference if you’re into Z80-based retrocomputing. And Zaks himself is still around; I was able to send him a thank-you note on LinkedIn before I abandoned that site.

                                                                                                                                                  1. 1

                                                                                                                                                    The funny thing is that as an adult I remembered it being this huge weighty tome; when I actually bought a copy though it’s a fairly slim technical book.

                                                                                                                                                    Amazon says that it’s 620 pages. Maybe it reads like a slim book even if it’s not?

                                                                                                                                                    1. 2

                                                                                                                                                      The surprise was mostly physical - even at 600 odd pages it’s still fairly physically slim.

                                                                                                                                                      Also only the first 186 pages are instructional; the rest is a reference.

                                                                                                                                                  1. 1

                                                                                                                                                    I’m not particularly a fan of the UK police or many of the laws they enforce (although this is a bit academic for me personally, I don’t live there and have never been). That said, I don’t think that it’s inherently immoral for the police to build devices to surveil people they are investigating for crimes, and a Raspberry Pi is a reasonable device to build a surveillance device on from a purely technical perspective.

                                                                                                                                                    In fact, I myself might want to build RasPi-based surveillance devices much like ones the police are using in order to surveil people - perhaps even counter-surveilling the police! Or I might want to build devices to counteract potential surveillance from the police upon me or my friends. Either way, I’d probably have something to learn from a former cop who build surveillance devices as part of his cop work. I don’t object to the Raspberry Pi organization hiring this guy.

                                                                                                                                                    1. 5

                                                                                                                                                      I don’t think that it’s inherently immoral for the police to build devices to surveil people they are investigating for crimes

                                                                                                                                                      That would be A-OK if they limited themselves to that but there have been many[1] instances[2] where they’ve crossed not only ethical but legal boundaries.

                                                                                                                                                      1. 5

                                                                                                                                                        In fact I would be very surprised to hear of any Police agency who even made an effort to operate within the spirit of laws relating to surveillance. Overreach, abuse, and corruption are normal in these areas.