1.  

    The x86, despite all its foibles (of which it had more than a few) had some really nice stuff for OS support, like hardware task switching, that most modern operating systems abandoned due to portability concerns. x86_64 went so far as to neuter hardware task switching entirely in long mode.

    Other features useful to operating system support on the x86 that were more-or-less ignored were multiple protection rings (generally only one or two are used), selective mapping of the IO address space depending per process (used occasionally, but not nearly as often as it should given how neat the feature is…), and segmentation in protected mode (everyone always just sets the segment registers to all of memory).

    One neat use of the last point there (segmentation in protected mode) is vx32, which allowed SFI-based embedded x86 execution environments in user space.

    1.  

      para 1

      I think that stuff in 286 seemed to be a relic of when it was trying to be a “baby” iAPX 432 of sorts. Intel seems to de-emphasized that stuff pretty early on.

      para 2

      OS/2 used all four rings, AFAIK.

    1. 17

      The Reddit trick, with appending .json to the end, isn’t unique to that site. It’s a common trait in Rails apps (GitHub is the gigantic exception, but GitHub is both old and atypical for a Rails app).

      Here it is on lobsters: https://lobste.rs/s/31hkbx/four_cool_urls.json

      Here it is on users.rust-lang.org: https://users.rust-lang.org/t/passing-a-mutable-reference-based-on-self/24108.json (it applies to any other discourse.org-based forum)

      It’s basically implemented with respond_to “content negotiation”, which is smart enough to handle file suffixes as an override for the Accept header: https://stackoverflow.com/a/9492463/3754495

      1. 5

        The Reddit trick, with appending .json to the end, isn’t unique to that site. It’s a common trait in Rails apps

        To be clear to all, Reddit isn’t a Rails app, so you have to give them some credit. But that’s cool, I didn’t know that :-)

        1. 4

          As johnaj said, Reddit is (AFAIK) Python, but GitHub has some limited support for it: you can append .diff or .patch to a pull request or commit, for example.

          1. 3

            Whaaaat! I didn’t even know Lobsters could do that. Thanks for the tip cuz I definitely needed that.

            1. 2

              Similarly OData has the $format=media/type query parameter that I’ve seen other non-OData endpoints adopt.

            1. 10

              Here’s the designer’s page with the font:

              https://www.cambus.net/spleen-monospaced-bitmap-fonts/

              I can’t say I’m a huge fan, but lately I’ve been appreciating serif fonts (even for monospace) like Go Mono.

              1. 9

                It reminds me a lot of Terminus, except that it uses a more balanced mix of sharp and curved corners, for more sci-fi feel, where Terminus just makes everything a 45° bevel.

                They’re both definitely in the camp of ‘geometric shapes stretched to fit 8×16 character cells’ though, as opposed to the more natural shapes of Sudo, Monoid or the classic -*-lucidatypewriter-medium-r-*-*-12-*-75-75-*-*-iso10646-1

                1. 4

                  I’m a sucker for a (non-Courier) monospace serif. So far the only ones I’ve seen are Luxi Mono, Go Mono, and whatever the old Sun console font was.

                  1. 3

                    Yes! That old Sun console font (“Sun 12x22”) was the one I didn’t know I was looking for! Go Mono comes quite close imho.

                    1. 2

                      It was also known as Sun Gallant, I believe.

                    2. 1

                      There are also:

                      PT Mono probably deserves an honourable mention. Some of its glyphs have serifs & some don’t.

                      1. 1

                        Some of its glyphs have serifs & some don’t.

                        Plex Mono is another nice “hybrid.”

                    3. 3

                      My first impression isn’t positive either. Curiously, I have the same issue with the monospaced font in the screenshots as with the article font: The spacing between the letters is too large relative to the spacing between words, giving the appearance of a jumble of single letters rather than words. Is that just me?

                      1. 1

                        Due to this I decided to try Go Mono as my terminal font for the next days. Mono-serifs has some appeal because it somewhat hides the kerning problems of monospace fonts.

                      1. 4

                        A reminder I created a Gopher version too. Unfortunately I don’t host it because I’m slightly concerned about hitting the servers too hard as a third party; maybe I’ll get around to fixing that.

                        1. 3

                          I’ve got one too :)

                          gopher gopher://sdf.org/1/users/julienxx/Lobste.rs

                          1. 2

                            In the past year I’ve had to send out one abuse report for excessive traffic to lobste.rs. A crawler was making multiple simultaneous and systemic page requests and impacting service for everyone else. That is something that is difficult to do accidentally: any caching, rate limiting, or request economization is probably sufficient–a protocol front-end like Gopher or Finger aren’t, prima facie, excessive or inappropriate in the same way this scraper was.

                            That said, the IRC bot announces new story submissions using push (email) notifications. I did this to avoid polling out of the same concern you have here. We are in control of our entire stack, and so have the luxury of being able to solve resource or request problems end-to-end as folk discover or develop means of interacting with the site and community. Any of you are welcome in #lobsters if you have questions or concerns about whether your software is a burden on the servers or our community.

                            1. 2

                              Thanks for the warning! Both my finger & gopher toys are hitting the /hottest.json endpoint and they do some caching of the response for several minutes.

                              Given the popularity of these protocols I guess they’re not adding too much pressure on the lobste.rs stack :)

                              1. 2

                                Both my finger & gopher toys are hitting the /hottest.json

                                That is what it’s for. The two most popular endpoints are / (17.7% of hits over the past year) and /rss (18.9% of hits over the past year). /hottest.json by comparison is 0.7% of hits for the same time period.

                                Given the popularity of these protocols I guess they’re not adding too much pressure on the lobste.rs stack

                                Correct. And good work @julienxx, @calvin, and other folk developing on or for Internet protocols that are not HTTP.

                          1. 2

                            Lots more interesting stuff on the mailing list.

                            There seems to be a trend, if I’m not incorrect in my reading, of “let’s rewrite a bunch of the core logic in JS”.

                            1. 4

                              Looking at SLoC right now, the codebase is almost exactly split between C++ and JS.

                              language    files blank comment   code
                              --------------------------------------
                              C++           360 36718   26562 207587
                              JavaScript   1098 39149   63692 195828
                              CSS           278  7371    2664  30455
                              C              83  5339    8278  29463
                              C/C++ Header  413  7091    8979  24034
                              IDL           238  3205       0  18852
                              XML            40  1365     690  16902
                              JSON           24     7       0   5367
                              DTD           180   772    1360   5344
                              Python         24   893    2422   3740
                              
                              1. 5

                                people forget that Mozilla was an early pioneer in writing desktop applications in JavaScript; much of the UI chrome to go with XUL is written is JS

                                1. 2

                                  Right, but didn’t they back away from it a lot with Firefox 1.0? I thought the original Mozilla/Seamonkey UI was all XUL/JS, but doing UI in JS in 2003 used too much RAM and was too slow? It feels to me like the cycle is completing itself, and now the advantages of JS start to outweigh the cost, partly because JS performance has been substantially improved.

                                  That said, the idea of async JS to do message filtration seems like a Really Good Idea. And I won’t miss XPCOM, and never really understood why it was there since all the modules are effectively advertising interfaces across what is ultimately a large statically linked codebase.

                            1. 13

                              The counter argument would be Moxie of course:

                              One of the controversial things we did with Signal early on was to build it as an unfederated service. Nothing about any of the protocols we’ve developed requires centralization; it’s entirely possible to build a federated Signal Protocol-based messenger, but I no longer believe that it is possible to build a competitive federated messenger at all.

                              So the big challenge will come when users expect some new feature which ActivityPub currently does not provide.

                              1. 14

                                Mastodon and the ActivityPub community have been iterating and pumping out new features on a rapid basis. On a protocol levle, ActivityPub itself is an iteration on the Activity Streams and ActivityPump protocols; themselves an iteration on OStatus. And there are plenty of ActivityPub instances that weren’t initially envisioned: PeerTube, MediaGoblin, NextCloud, … and chess?

                                I suppose moxie would argue that Mastodon isn’t or won’t be competitive.

                                I argue Signal, just like Twitter, will run out of money.

                                1. 5

                                  Signal will become what WhatsApp was meant to become. WhatsApp could have been a secure messaging layer for businesses and consumers but Facebook made them an offer they couldn’t refuse so that dream wasn’t realized.

                                  Signal now has a foundation and they have one of the original founders of WhatsApp bankrolling the operation. I don’t think they will run out of money and might even realize the original WhatsApp dream.

                                2. 10

                                  That quote is not really a good counter argument, it basically reads like “federation is bad because I said so.” You have to read the rest of his post to tease out his arguments:

                                  • federation makes it difficult to make changes
                                  • federation still favors a service single provider (e.g. gmail and email)

                                  (Note: I don’t agree with moxie, just posting his counter argument for others to read)

                                  1. 8

                                    The counter argument would be Moxie of course

                                    I’d have a lot easier time taking his arguments seriously if he hadn’t threatened legal action against a free software project simply for trying to build an interoperable client.

                                    1. 4

                                      Mastodon seems to cope quite well with this, possibly because there are few implementations and upgrading the server application isn’t too hard.

                                      But I think the counter argument is entirely correct - it’s not possible (or at least very hard) to build a competitive federated messenger - and that’s completely fine. Competition is one of the parts of the centralised model that leads to de-prioritising users needs so that platforms can be monetise to keep it alive and “competitive”.

                                      1. 5

                                        Wait, what about matrix though?

                                        1. 2

                                          To clarify my opinion a bit - I’m suggesting that federated networks won’t succeed by the metrics used to measure if something is “competitive”, not that federated networks don’t work. I think Mastodon and Matrix are both really good projects that will be much better than the alternatives long term, since there won’t be many incentives not to prioritise the needs of their users.

                                          1. 2

                                            Matrix from what I heard has scaling issues; we’re talking “three people on a single server massively increases load” bad. I think it’s due to protocol flaws?

                                            1. 5

                                              Any of matrix’s scaling issues come from federation (trying to sync room state across many different homeserver instances) and the poor state resolution algorithm they were using up until this past summer. Three (or thousands) of users on a single server participating in a room is not a concern, as that is a centralized instance.

                                              Highly recommend following the matrix blog and TWIM for project updates, especially for anything about synapse (their reference homeserver implementation). It was recently updated to python 3 and the memory footprint has drastically reduced. Keep a lookout for the “next generation” homeserver implementation, Dendrite, sometime after the Matrix 1.0 spec releases.

                                              1. 2

                                                I remember reading that this was because the current reference server implementation is simply not optimized. They’re rewriting it in Go (IIRC the new server is called Dendrite), but we’ll have to wait and see how performance changes.

                                        1. 1

                                          Stuff I don’t really know:

                                          • Parallelism: I write embarassingly scalar solutions for problems.

                                          • Hardware: How does the CPU work? It’s just a series of transistors, and everything is built on those, but there’s definitely gaps.

                                          • Algorithms and Data Structures: I’m ashamed to say it - it gets really fuzzy after linked lists. This doesn’t help my funcprog attempts.

                                          • Graphics and Game Programming: I’m not good at graphics, especially because I don’t know the underlying math. For some reason, the game logic loop seems to escape me.

                                          Stuff I’m working at being better at:

                                          • Assembly:: I started learning PowerPC assembly for a project, and even if I have to constantly refer to the ISA manual, I can sort of understand basic sequences and even write very simple chunks; enough to optimize a JIT.

                                          • Portability: Also due to that project, I have a better perception of POSIX, C, and where they fall short. I can identify endianness issues.

                                          • Communication: A soft skill, but it’s the most important when working on FLOSS projects. Being able to tell people clearly what you need and what they need, even if it involves big abstract concepts.

                                          • Databases: I have a basic comprehension of SQL now, but I’m still a little lost on how DBs work internally.

                                          • Networking: I have a much better idea of how TCP/IP and Ethernet work nowadays, though not really from the programmer’s perspective.

                                          1. 1

                                            I find it hard to take the whole genre of “yet another Markdown notes application” seriously until they catch up to the featureset of OneNote or org-mode. Very much dime a dozen.

                                            1. 3

                                              One essential feature to me for note taking are images (specifically screenshots). “Markdown” is a strong hint that it doesn’t handle images at all. OneNote does that quite well. It just lacks a good journalling function and needs to be cross-platform and Open Source.

                                              1. 1

                                                You can actually attach arbitrary files to notes in Notable, and even render attachments inline. I think it works fine but you need to somehow link the two.

                                            1. 34
                                              On the twelfth day of Christmas
                                              Lobsters linked for me:
                                              12 Docker toolings
                                              11 Python NeurNets
                                              10 Lines of J lang
                                              9 Framework Flamewars
                                              8 Learn the Monads
                                              7 "What's your week"ings
                                              6 Rust is Cool-ings
                                              5 License Rants
                                              4 Microcodes
                                              3 Reviews
                                              2 Tag Requests
                                              and a Post about Open B S D
                                              
                                              1. 9

                                                10 Lines of J lang

                                                That’s an awfully long J program.

                                              1. 4

                                                C - natively uses 8-bit char able to handle only the ASCII character set. C99 introduced wchar_t meaning a 16-bit wide characters able to handle all Unicode via the surrogate pair method used by JavaScript (just don’t try to implement this yourself unless you are really really into this kind of thing).

                                                Wrong. C strings have an implementation defined encoding. Other than requiring it to be null-terminated, portable C programs can’t assume that strings are ASCII.

                                                In common POSIX-y configuration, like Ubuntu and macOS, C strings are UTF-8. Go ahead and make an emoji filename on your Linux box; it’ll work just fine (and be described as having a length of 4 by wc -c).

                                                Linux and Windows even allow you to even configure it to use alternate codepages instead of ASCII. Configure HKLM\SYSTEM\CurrentControlSet\Control\Nls\CodePage\ACP on Windows and the LC_ALL and LANG environment variable on Linux to choose what encoding the C strings will use.

                                                Let’s also, for sake of argument, pretend that there aren’t C implementations that use EBCDIC. They don’t support Unicode anyway, so it doesn’t matter.

                                                1. 7

                                                  Let’s also, for sake of argument, pretend that there aren’t C implementations that use EBCDIC. They don’t support Unicode anyway, so it doesn’t matter.

                                                  They actually do…

                                                  1. 4

                                                    Indeed they do. I used them to implement Swift on z systems!

                                                    1. 1

                                                      Okay, so they do support it. Now I know…

                                                  2. 2

                                                    Thanks for the feedback, I’ll post an update correcting this.

                                                    That makes sense as C standards very rarely define how things should be implemented in any way, shape or form, even when a particular implementation is ubiquitous. This makes it easy to fall into the trap of assuming that something is part of the spec when actually it’s not (e.g. char is 8 bits when spec says at least 8 bits, long int is 32 bits long when it’s at least 32 bits, and so on).

                                                  1. 1

                                                    I’m interested in this but haven’t used it. Anybody have any experience actually using coreboot?

                                                    1. 3

                                                      If you’re running a BSD, then it seems like you might want to stay away.

                                                      1. 3

                                                        https://mail.coreboot.org/pipermail/coreboot/2018-December/088044.html indicates that NetBSD doesn’t have that issue.

                                                        The problem is less in the “project’s origins” as alluded by Bryan, but in the testing that people do: the ThinkPad support is community provided, and apparently most people working on coreboot-on-Thinkpads use Linux.

                                                        If somebody wants to get to the root of that issue, they can expect a supportive developer community, but coreboot is very much focused on developers, not consumers.

                                                      2. 3

                                                        I’m running coreboot on all my PC’s:

                                                        • PCengines APU2 with OpenBSD
                                                        • ThinkPad X200 with OpenBSD
                                                        • ASUS KGPE-D16 with dualboot Gentoo / HardenedBSD
                                                        • ASUS KGPE-D16 with HardenedBSD

                                                        I also ran in the past ASUS F2A85-M with dualboot Gentoo / FreeBSD and ASROCK E350M1 with dualboot FreeBSD / 9front.

                                                        My wife has ThinkPad X230 with Ubuntu.

                                                        Generally, coreboot has its quirks but once you work it around, it works. If you have some questions, feel free to ask.

                                                        1. 2

                                                          Yes, reflashed my ThinkPad x60s some years ago now, had success on dfly, free, open, NetBSD. reflashed it with a new build couple of weeks ago, no issues under NetBSD. Helped someone with an x220 to reflash it a couple of years back and there was not issues on OpenBSD at the time. No idea if there have been any regressions. Currently waiting for a SOIC-8 clip so I can reflash my x230. I use the SeaBIOS payload on the x60s and x220 image I put together, the x230 will likely be the same but I may try tianocore as well. Don’t care for grub.

                                                          1. 1

                                                            I “used” it to boot FreeBSD (with non-upstreamed tegra210 patches) on the Nintendo Switch :D (ultimately not that interesting since the only connection to the outside world was a janky UART.. nothing showed up on XHCI when plugging in stuff via a USB-C-to-A adapter)

                                                            A bit disappointed that there’s no framebuffer support for tegra210 in coreboot. (I thought Google would care to get display as early as possible on the Pixel C, but looks like they trust Linux to always start booting very quickly.)

                                                            Coreboot also supports the Rockchip RK3399 — because chromebooks — so I’d like to see coreboot on the ROCKPro64, but unlike the Chromebooks, this board has DDR4 memory instead of DDR3, so there’s no memory training code (I wonder if it’s possible to attach the blob?)

                                                            Also, I wonder if it’s possible to get an RK3399 Chromebook and just replace the depthcharge payload with TianoCore EDK2… (or at least U-Boot, that should work for sure)

                                                          1. 8

                                                            As someone who spent a lot of time using Win3.1/Win98, seeing deep dives into these stacks and usage is really interesting.

                                                            One “desert island “ project I’ve had for a while is to pull out some user interface guidelines from those times and try to build apps out of those for things like instant messaging or task management.

                                                            I get a lot of these apps existed in the past but I feel like going back to these older design styles with today’s knowledge could lead to interesting places

                                                            1. 2

                                                              I feel there’s been a decline in things like HIGs; like HCI is focused on branding over consistent user experiences. There’s been some revisiting (hamburger menus are copied from Xerox’s UIs, skipping the Macintosh) but I think immersing into the context of both their creation and environment would be good for modern applications to learn from.

                                                            1. 1

                                                              Oops, the canonical URL finder claims another victim. This is the URL.

                                                              1. 4

                                                                I’ve got a 9360 model with the QHD screen, after years of hating on laptops because of the sub-par characteristics. Very satisfied with it.

                                                                My criteria is pretty much just:

                                                                • A screen resolution that isn’t 1377x768 (It’s 2018! Why are these still shipping?)
                                                                • Screen must not have adaptive brightness, or at least have the ability to completely disable this
                                                                • WiFi/Bluetooth must not be Broadcom. Linux support is a crapshoot when it comes to these chips.
                                                                • User upgradeable components (Thankfully, Dell provides an user manual describing how to replace the M2 hard drive and wireless chip)
                                                                • Standard UEFI implementation (i.e. ability to disable Secure Boot)
                                                                • Standard keyboard layout (funky layouts are a pain)

                                                                Unfortunately, laptop vendors are only in the game to make a buck, and their offerings aren’t acceptable. At least Apple does this right.

                                                                1. 2

                                                                  Screen must not have adaptive brightness

                                                                  Isn’t that a completely software thing? Are there implementations of adaptive brightness directly in firmware now?

                                                                    1. 1

                                                                      As bwasti has commented, it was enabled implemented in firmware. However, you were unable to enable/disable the functionality until a recent firmware update made it available. I find that crazy!

                                                                    2. 2

                                                                      Standard UEFI implementation (i.e. ability to disable Secure Boot)

                                                                      Any laptop that ships with Windows (or can ship with Windows) and is using x86 architecture must have “disable Secure Boot” option:

                                                                      (…) Intel-based systems certified for Windows 8 must allow secure boot to enter custom mode or be disabled

                                                                      Source: https://en.wikipedia.org/wiki/Unified_Extensible_Firmware_Interface#Secure_boot_criticism

                                                                      1. 2

                                                                        Or even better, add your own key to the chain of trust, remove the ones that aren’t yours, and sign your own kernel.

                                                                        1. 2

                                                                          Exactly. That’s what I do (with sbupdate), additionally booting directly kernel as an EFI application (so kernel acts as a bootloader, no GRUB necessary!).

                                                                      2. 2

                                                                        A screen resolution that isn’t 1377x768 (It’s 2018! Why are these still shipping?)

                                                                        I bought one of these recently for development. Since my environment is command line based, extra pixels don’t really help much; they can make everything smaller, but there are practical limits on what’s comfortable/what my eyes can do. Probably my “ideal” resolution would be a little higher, but 1080p on a 13” laptop really requires software scaling to be usable, which introduces its own share of bugs and quirks, so it’s not as simple as “more is better.”

                                                                        The unexpected/unplanned bonus is that it can run VMs at 1024x768 which allows it to run legacy systems without scaling, making them much nicer. I don’t spend that much time emulating legacy systems, but I do use them to test my software on older environments, and it’s kind of a feature to have them work so well. It also needs less GPU/uses less power/has better battery life.

                                                                        Not saying it’s the right thing for everyone, but maybe the answer to “why?” is because some of us actually want them.

                                                                        1. 1

                                                                          Maybe they (1377x768) are shipping because people still like them? I’d prefer my x230 for work on the go over both of the T4x0p I’ve used any day. So yeah, it’s a bit apples to oranges, but afaik the XPS 13 has a similar resolution compared to what the T4x0p has on 14” - I find it cramped and small.

                                                                          1. 2

                                                                            The X200s isn’t really any bigger than the X230 but has a much better 1440x900 display.

                                                                            1. 2

                                                                              Not saying stuff can’t be improved, but this was re: QHD ( 2560 × 1440 ) - and I’m absolutely not a fan of huge resolutions. At least until the support in Linux (with external screens) is on the level of OSX. Not that I’m a huge fan of OSX, but I’ve never seen any problems with Retina MBP + Normal screen vs Linux on HiDPI + normal screen.

                                                                            2. 1

                                                                              1377x76

                                                                              Sorry for being nitpick here, but it’s actually 1366×768. It still exists because it’s much cheaper than a FHD (1920x1080) screen. In a extremely low margin laptop business, leveling the parts cost is major revenue optimization strategy (even for Apple). Same reason why low-powered crappy netbooks still exist.

                                                                          1. 1

                                                                            If it’s just yet another setup.exe downloader, and not a real package manager, then why should I care?

                                                                            1. 5

                                                                              You probably wouldn’t, but that’s also not what it is; it is indeed a real package manager, albeit still a relatively simple one à la Homebrew. The GitHub repo honestly actually provides a better overview than the official homepage, but as a quick summary, Scoop:

                                                                              • Installs in the user directory, so you don’t need to deal with UAC pop-ups;
                                                                              • Handles dependencies;
                                                                              • Handles upgrades and updates;
                                                                              • When it does have to work with a setup.exe for whatever reason, avoids you having to deal with it by extracting and setting things up behind-the-scenes; and
                                                                              • Is trivially extensible

                                                                              Some of the above is admittedly cultural (the team prefers finding and sourcing portable apps whenever possible), but some is also unique to Scoop’s implementation. For what it’s worth, I’ve submitted at least one new formula to Scoop and updated a few from time to time, and found the process really simple; the feel is similar to Homebrew, in a good way, and makes it feel significantly lighter-weight than something like Chocolatey.

                                                                              1. 1

                                                                                Installs in the user directory, so you don’t need to deal with UAC pop-ups

                                                                                When I was on Vista, you would’ve sold me with that one line.

                                                                                1. 1

                                                                                  Ah, that’s potentially damn handy. Thanks for that bit of info.

                                                                                  If that’s the case it should work on my Windows VM I use to get access to my corporate overlord’s network on my own hardware :)

                                                                              1. 1

                                                                                Dunno how I feel about this. I don’t run NextCloud yet but I’ve been considering it, and my experiences running a Mastodon instance for a few months left me unwilling to try again. Maybe they’ve scaled the requirements, footprint and admin surfaces back to a sane level.

                                                                                1. 7

                                                                                  Actually this is a ActivityPub implementation, not a Mastodon one, which actually makes this a little more interesting.

                                                                                  By using the popular ActivityPub standard, Nextcloud users can subscribe to and share status updates with users in the so-called ‘fediverse’, an interconnected and decentralized network of independently operated servers!

                                                                                  Mastodon is probably the best known implementation of ActivityPub protocol, but there are actually a bunch of federated applications based around ActivityPub. For example there is also:

                                                                                  • PeerTube (YouTube-ish)
                                                                                  • PixelFed (Flickr/imgur-ish)
                                                                                  • Diaspora (Facebook-ish)

                                                                                  One of the kind of cool things is that all of these applications are using the same federated publishing protocol, they can federate with each other. I can reply to a thread on PeerTube in Mastodon, and PeerTube will understand it as a reply and display it as such, or you can publish an album on PixelFed and I can see as a posted album in my Diaspora.

                                                                                  1. 1

                                                                                    I didn’t realize that Diaspora had joined the Fediverse! Good on them!

                                                                                  2. 2

                                                                                    running nextcloud is pretty easy with docker

                                                                                    1. 2
                                                                                      1. 1

                                                                                        Running it might be easy, administrating and keeping it running never is. This goes for pretty much every server software out there.

                                                                                      2. 1

                                                                                        I’ve been running NextCloud for years, mainly for the very robust calendar which also happens to have a great UI and stellar integration with other calendar clients (Lightning, Android calendar, iPhone calendar, etc.)

                                                                                        1. 1

                                                                                          The post doesn’t seem to say either way whether it’s a reskinned Mastodon server or an independent reimplementation, does it?

                                                                                          1. 2

                                                                                            Looking at the source code it looks like it’s a PHP backend like the rest of NextCloud with a Vue.js frontend

                                                                                            From a cursory inspection it doesn’t look like they’re running all the infra necessary to run a full Mastodon node.

                                                                                            I suspect but don’t know that you’re actually just using their app to federate from one of their instances they’re running behind the curtain, but again I have no bullet proof evidence on that.

                                                                                            1. 4

                                                                                              ActivityPub is an open standard with some lightweight implementations (Mastodon is not one of them). From my cursory look at the source, I think this is a full activitypub compatible server.

                                                                                            2. 1

                                                                                              No it doesn’t give much detail at all. If it’s a reskinned stock mastodon server, that’s a hefty chunk of infrastructure required to run the thing (PostgresSQL, Redis for Sidekiq, etc.) and a lot of under the hood complexity go wrong.

                                                                                              I have mad respect for Eugen and the work they’re doing, but if it is in fact a stock Mastodon server, I’m out. I’m not a Ruby on Rails hacker and don’t have time to become one, and my installation hosed itself pretty hard.

                                                                                              1. 1

                                                                                                There’s always Pleroma if you want lightweight ActivityPub.

                                                                                                1. 1

                                                                                                  Pieroma is lightweight, but its upgrade story and to a lesser extent its installation story are … Putting it kindly, lightly sketched out :)

                                                                                                  You have to want to become an Elixir/Phoenix hacker if you really want to run a Pieroma with confidence. Not that that’s a bad thing at all mind, but you should be aware of that before you sign up.

                                                                                                  At least that was the case a few months ago when my Mastodon instance ate itself.

                                                                                          1. 4

                                                                                            The thing is, you mayn’t tell others what to work on, so you can’t prevent then from working on different UIs.

                                                                                            I think that’s a good thing: had we been locked into Macintosh-inspired UIs, we would not have experimented with tiling WMs, which are IMHO an advancement.

                                                                                            1. 2

                                                                                              Tiling WMs are nothing new; see Cedar, Genera, or Windows 1.0; one could argue tiling over overlapping is in fact, a regression.

                                                                                              1. 1

                                                                                                I think one can only argue about this subjectively. I personnaly like overlapping in general, and tiling in the terminal with tmux. I expeiremented with lots of tiling window managers, and I always ended up going back to overlapping.

                                                                                            1. 2

                                                                                              How are downstream packagers/maintainers taking the additional Rust dependency, with all the implications that brings when packaging? (i.e: cargo, vendoring, static linking preferences, etc.)

                                                                                              1. 4

                                                                                                From my peanut gallery, I noticed there is/was (?) at least some full-blown drama happening in the Debian community (via), and some stir in the Alpine community too (this one seemed much quieter) :]

                                                                                                1. 2

                                                                                                  I haven’t been able to build the package since the transition to Rust. We’re using the pre-Rust version, even for platforms with Rust support. If someone manages to figure out why it doesn’t build, I guess we’ll keep the old librsvg for non-Rust platforms for as long as possible (we have a lot of those).

                                                                                                  for other rust packages, we have resorted to having every package “vendor” its own crates (as opposed to independent packages), but with an additional wrapper to build into our package system, so that we have a local mirror & checksums as with other fetched artifacts.

                                                                                                  1. 3

                                                                                                    Who is “we”? I.e. what particular downstream dependency are you talking about? Per your submission history, is it maybe netbsd?

                                                                                                1. 3

                                                                                                  So here’s the list of parts we need to build a working, useful Unix system:

                                                                                                  • init
                                                                                                  • a supervisor
                                                                                                  • a login program
                                                                                                  • a shell
                                                                                                  • a C library

                                                                                                  Isn’t really more needed when it comes to Linux? Using only that, you will have an empty /dev, as mknod isn’t part of the shell (not even talking about udev), and I think you get a kernel panic in such case.

                                                                                                  On a side note, I’ve been working on a self-bootstrapping distro for quite a while, and I was stunned by the amount of programs needed to reach this goal (think gcc, yacc, perl, python, etc…)

                                                                                                  1. 1

                                                                                                    defvs entries aren’t populated from the userspace for a while now, and udev isn’t a requirement unless you handle hotplug.

                                                                                                    1. 1

                                                                                                      defvs entries aren’t populated from the userspace for a while now

                                                                                                      I thought systemd/udev populated /dev on modern systems

                                                                                                      1. 3

                                                                                                        Indeed, devfs has been marked obsolete in 2003 in favor of udev:

                                                                                                        https://lwn.net/Articles/44731/

                                                                                                        Of course, you could just pre-create the device nodes, as was done before udev and devfs ;).

                                                                                                        1. 2

                                                                                                          Slip of the pen, it’s devtmpfs.

                                                                                                          https://lwn.net/Articles/330985/

                                                                                                        2. 2

                                                                                                          See my sibling reply. Neither udev nor systemd are requirements for a usable system, Linux predates both by many years.

                                                                                                        3. 1

                                                                                                          Who creates them then? The kernel itself? Take /dev/console for example. Wouldn’t it prevent the kernel to boot if it is not present? AFAIK, udev does more than hotplugging, as it replaces what devfs used to do.

                                                                                                          1. 4

                                                                                                            When a device driver registers new device, the kernel creates a node in devtmpfs. There is no need to manage it with udev in static configurations. Many embedded Linux systems never run udev. There’s been no practical hard requirement for mknod since 2.6.

                                                                                                            1. 2

                                                                                                              Take /dev/console for example. Wouldn’t it prevent the kernel to boot if it is not present?

                                                                                                              The kernel does not write to the console (or any other device) by opening a device node in the filesystem. The device driver already lives inside the kernel, there’s no need to go via the filesystem (it writes to the console well before the root filesystem is mounted). So no, it wouldn’t prevent the kernel from booting if /dev/console wasn’t present. (It might create a problem for early userspace, though IIRC even init will have handles to the console set up directly by the kernel).

                                                                                                              1. 1

                                                                                                                This makes sense indeed, thanks for the reply!

                                                                                                                I wonder to what extent a system would be usable with an empty /dev. Would a shell actually start without a TTY? I was playing with containers the other day, and running mksh inside it required that I create a few nodes in $chroot/dev/ before being able to start it. Maybe other shells can work around that?

                                                                                                                1. 1

                                                                                                                  Containers share a kernel, which is already aware of the devices, on an isolated file system and process space where there is limited kernel introspection in this regard. Thus the rules are a little different.

                                                                                                                  1. 1

                                                                                                                    I don’t know the specific details of various shells, but in theory I think it should be possible to have a shell that doesn’t try to open any devices. (It’s a pretty onerous restriction though; there’s not much you’ll be able to do in a system with no device nodes).

                                                                                                                  2. 1

                                                                                                                    Though the fork children could always inherit standard output et al.

                                                                                                                    1. 1

                                                                                                                      That’s what I was implying trying to imply, yes.