1. 6

    When it first was posted to HN I was incredibly disappointed. There is no cryptography, user accounts are completely controlled by the server owner, there isn’t an easy way to have accounts on multiple servers, discoverability on a single person server is near impossible, etc.

    After looking past it’s faults though, it probably is the first modern federated network to become popular. That’s an achievement. The UI/UX is good enough for people to actually want to use it. There is even enough diversity (in terms of interests) for lots of interesting conversations and people outside the tech world.

    It also probably kicked off the creation of other decentralized services based on activitypub (like PeerTube). There was even an active effort to bring ActivityPub to Lobsters for a while.

    Very excited for the next two years of Mastodon.

    1. 8

      There is no cryptography

      Where would you be expecting cryptography? I’m not the kind of person who advocates for cryptography, for it’s own sake, so I’d be curious to see where you think it’s missing. To validate identities? To protect data (but then again, nearly everything is public)?

      user accounts are completely controlled by the server owner, there isn’t an easy way to have accounts on multiple servers

      Well there is account redirection and profile metadata. Both can be used to create a ad hoc system for multiple accounts. Again, what would you (or anyone else, especially critics) be imagining this could or should look like?

      discoverability on a single person server is near impossible, etc.

      This is true, maybe an external service (or protocol) could be set up for this, to help people find others. Until then this is a good starting point.

      1.  

        Where would you be expecting cryptography?

        I was imagining every user with a public/private key so that…

        • public posts are signed
        • DMs are encrypted
        • key could easily move from instance to instance and be cryptographically proven to be the same

        Again, what would you (or anyone else, especially critics) be imagining this could or should look like?

        Just a specific piece of machine readable metadata that says “I am also x, y, z.” Does this already exist?

        Until then this is a good starting point.

        Thanks for that! Found some interesting users.

        1.  

          Just a specific piece of machine readable metadata that says “I am also x, y, z.” Does this already exist?

          Apparently it does! Just checked on my https://mastodon.social/@isagalaev, the links to my web site and flickr on the right have rel="me".

          1.  

            Neat, could’ve sworn that wasn’t there before.

            1.  

              It’s a very new feature!

              1.  

                Well, the original post is pretty much about how much Mastodon changed over the 2 year period. :-)

            2.  

              Actually every user has a public/private key and all public posts are signed.

              Check this out, a random user:

              $ curl -H"Accept:application/activity+json" https://apoil.org/users/nasa | jq
              {
               ...
                "publicKey": {
                  "id": "https://apoil.org/users/nasa#main-key",
                  "owner": "https://apoil.org/users/nasa",
                  "publicKeyPem": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA1/oA+ovirWaOy84/ulTs\nyagWc9ktVQXo6qFxVdryz2zLN2WCtk82GnfiQKQZ3bk9kN8WArRUBfFF6Rx038SU\nFfB950DVr8MBnCOeE6uy/48pU5ER2UY0Sz3lPDBgLWrjQRL+e3cg05cO+aY3J+l8\nOrzme9wVqn48e4DG1AnJnbIdNb9i5QKQa/q1LaaAyGUwS8T/jIGecRZowT4I874k\nikVwpWbOIg+P2zoi40HqPj+DJlCSs3hh3P/zK7p4Vn8fDcqQkUO82zkRU4sSphOi\ndcAFJ2M2bxEpDghxv0MQMjY+WTrEepLT+YJFBbxFJYdCrbHzYErOkYfvJReMmkb4\n4wIDAQAB\n-----END PUBLIC KEY-----\n"
                },
                "endpoints": {
                  "sharedInbox": "https://apoil.org/inbox"
                }
              }
              

              And the notes are signed using Linked Data Signatures. (I personally don’t like LD signatures for various reasons but that’s another matter).

              The keys in a normal user’s case are of course completely handled by the server, but they don’t have to be. I’ve built a prototype ActivityPub client/servers where clients held the private keys themselves and it worked very fine.

              As for end-to-end security see for example this ticket which is about adding OpenPGP. There is also a ticket about persistent identifiers (public keys etc.) but sadly I can’t find it now.

              1.  

                I was imagining every user with a public/private key so that…

                • public posts are signed
                • DMs are encrypted
                • key could easily move from instance to instance and be cryptographically proven to be the same

                What would be interesting, if I wouldn’t use mastodon in my web browser – I just wouldn’t trust it. As an optional extension that could be worth while talking about, but I have the feeling that it would have to be done on a lower level (ActivityPub), rather than just on one implementation.

                1.  

                  Encrypted DMs would be neat.

                  I’ve been using Matrix/Riot as a e2e encrypted instant messenger, but so far I’ve been disappointed with the user experience. If Mastodon added e2e DMs in real time, i’d happily give that a shot as a replacement.

                  1.  

                    Matrix is a whole ’nother can of worms. Client support is okay now (we have native desktop clients), but the server is still incredibly slow.

                    There are a few efforts at alternative servers, but none are usable yet. Hopefully they will be usable soon enough.

                    1.  

                      I agree with your points, but I was specifically talking about e2e.

                2.  

                  Well there is account redirection and profile metadata. Both can be used to create a ad hoc system for multiple >accounts. Again, what would you (or anyone else, especially critics) be imagining this could or should look like?

                  The dumb thing that happens on reddit a lot is some subreddit mod’s account gets hacked and then they can vandalise anything. Account redirection can be controlled by the owner, as well as profile metadata.

                  Basically the mastadon model isn’t very good at handling the fact that trust in a host can change over time. We all have that old gmail account we can’t quite shut down but wish we could just move somewhere else.

                  There’s a potential model here where user accounts themselves could be controlled at an individual level, and the accounts could then connect to a network (but the primary account info is still hosted by you). So instead of saying that your identity is “somemastadon.instance/username” you say it’s “myown.website/mastadon”, and in “somemastadon.instance” it knows to poll you for information/put you in the proverbial phone book.

                  This is quite complicated but could also be left to power users, with most people just opting to have their account be hosted on the instance. Meanwhile the nerds can have fun and host their timeline themselves without having to have a full blown instance to run.

                  1.  

                    There’s an open issue on mastodon ( https://github.com/tootsuite/mastodon/issues/2668 ) and plume ( https://github.com/Plume-org/Plume/issues/94 ) to let you point a domain at an existing instance and have it host your toots.

                    Would that do what you are looking for?

                    1.  

                      Yep, that sounds right!

                      Some of those threads seem to cover the trickiness around identity but, ironically, e-mail providers have gotten most of this pretty right over the years.

                      EDIT: actually, I think there is another model of this, a bit more interesting, where I actually host my own data and the larger network is simply mirroring my data. That way I don’t have to rely on them to be holding onto all my data in the case I decide to leave. This is a bit more tricky, granted, but it’s a model that would be more durable to trust-breaking scenarios

                      I think the one thing that mastodon would need to get right is around usernames. My username should be rtpg@myown.domain, even if it’s being hosted on mastadon.social. There might be a lot of trickiness involved in making sure other instances respect that mechanism (ultimately allowing for host redirection)

                3.  

                  I run my own instance. It’s not trivial, although it’s not too challenging since Mastodon releases an official docker container (you have to run the same container three times, one of web, one for streaming and one for sidekiq/jobs). Here’s what I wrote to maintain everything:

                  https://github.com/sumdog/bee2/

                  I generally like Mastodon, although I’m glad I run my own instance. With all the crazy drama that happens on some of these instances, I’m glad I’m in total control of my own data (although this leads to its own problems, like people not running security upgrades).

                  Any other crustaceans on a Mastodon instance? Post your user Ids and I’ll follow you: @djsumdog@hitchhiker.social.

                  1.  

                    Any other crustaceans on a Mastodon instance?

                    There was a thread asking that question a while back: https://lobste.rs/s/7qazoc/crustaceans_mastodon_where_are_you

                    Post your user Ids and I’ll follow you: @djsumdog@hitchhiker.social.

                    I’m on zge@icosahedron.website. There’s a little issue that lobste.rs’ markdown interprets this as an email address by default, so you should probably use a markdown link to make it easier for people to open your profile. Maybe something could be done to make it easier to post ActivityPub addresses, but they’re rather easy to mistake for email addresses.

                    1.  

                      ayeee lol issa me!

                    2.  

                      I mean, there’s cryptography in the sense of HTTP Signatures. What kind of use of cryptography (or rather did you expect some kind of PSK stuff going on) did you expect?

                      It’s amazing how far it’s gotten so far - excited to see how far it can go.

                      1.  

                        Yup, I expected something like this - even if it were to be opt-in.

                    1. 22

                      This may sound defensive. I apologize for my poor writing. Instead, I want to suggest that the entirety of the OP is written from the wrong mindset and that the below points are specific inflections of that wrong mindset.

                      The article ignores the number one reason that Go was written: SPEED OF COMPILE TIMES! The article also ignores another very important reason that Go was written: It is for programmers, “not capable of understanding a brilliant language but we want to use them to build good software”. The quote is by Rob Pike.

                      The article places some importance on immutable types, would the average programmer know how to leverage an immutable type to any benefit from it?

                      “The standard library of Rust is just as rich as that of go” - REALLY? Where is net/http? That absence alone makes this statement an outright lie. Looking for json, xml? Again not in the stdlib. Compression and archiving like tar, zip, bz2, lzw, gzip? Again in the Go stdlib, not in the Rust std. Cryptography including symmetric, asymmetric, and hashes? In the Go stdlib and absent from Rust std. I could go on, but I’d have to refer below the fold of the Go standard lib. Compare https://golang.org/pkg/ to https://doc.rust-lang.org/stable/std/ for yourself.

                      “The package ecosystem of Rust outmatches…” Maybe, but not in some important aspects, consider https://github.com/search?q=language%3ARust+stars%3A%3E1000&type=Repositories vs. https://github.com/search?l=&p=1&q=language%3AGo+stars%3A%3E1000&ref=advsearch&type=Repositories&utf8=✓

                      “I think we could call Rust a superior language to Go in, quite literally, every single way possible.” Not in speed of compile time. Not in ease of use for the average and below average developer. When these two points are your most important values, Rust does not look superior at all.

                      Regarding passing the critical point and being a mainstay, I absolutely agree. Rust is here to stay and I’m glad that it is. Regarding it being a better language than any other for most tasks, I absolutely disagree. Rust’s place is to replace C++. It is a simpler, more sane, language than C++ to be used in the same places, when that level of control is needed. For anything else, a more simple language with less mental load required and faster compile times is better suited to the task.

                      Finally, on the mindset and point of view, if “superior” does not take the human aspect into consideration at all, this post may have a lot of truth to it, however, code is written by humans. Humans have different needs than a bullet lists of supported features. Keeping in mind the goals of the Go programming language when it was written (from Rob Pikes 2009 Google Tech Talks presentation): type safety, memory safety, good support for concurrency, GC, and speed to compile.

                      It is easy to forget that as projects grow, compile speeds become non-trivial. Many languages had tackled all of those things, except the last. Go continues to put emphasis on this. When compile speed was greatly slowed with the 1.4 release, it was increased greatly in the next few releases until it was faster than it had been before. This is an important principle in developer productivity. If we stop valuing this, then one of the most important parts of Go isn’t valued. If you aren’t going to value that, then you must say so. It is, after all, one of the most important parts of the language.

                      Continuing on the mindset and point of view: the article places little value on the simplicity of Go. This is another one of Go’s greatest strengths. There is no doubt that generics, and memory management in Rust make it more complex than Go. Go’s simplicity is such a huge strength that many developers do not want generics in the language. They don’t want that added complexity. To ignore this simplicity as a value is to ignore one of the most important part of the language.

                      Given these additional things which we must value when comparing things, the conclusions made in the article simply are not that simple. Yes, there is a place for Rust. There is also a place for Go. Should anything being written in Go be written in Rust instead as the article suggest? Absolutely not.

                      1. 6

                        “The standard library of Rust is just as rich as that of go” - REALLY?

                        Yeah, that’s a silly statement to make, given that Rust specifically tries to have a small stdlib and pushes non-essential things to the Crates ecosystem. I think this is a trade-off that works for Rust’s favor in the long run, but I understand people who prefer the Go/Python philosophy.

                        1. 9

                          “The standard library of Rust is just as rich as that of go” - REALLY? Where is net/http? That absence alone makes this statement an outright lie. Looking for json, xml? Again not in the stdlib. Compression and archiving like tar, zip, bz2, lzw, gzip? Again in the Go stdlib, not in the Rust std. Cryptography including symmetric, asymmetric, and hashes? In the Go stdlib and absent from Rust std. I could go on, but I’d have to refer below the fold of the Go standard lib. Compare https://golang.org/pkg/ to https://doc.rust-lang.org/stable/std/ for yourself.

                          That was my reaction too. The amount of stuff one can do with Go without having to choose between multiple similar but different libraries and without having to write basic stuff oneself is amazing and easy.

                          1. 4

                            “The article ignores the number one reason that Go was written: SPEED OF COMPILE TIMES! The article also ignores another very important reason that Go was written: It is for programmers, “not capable of understanding a brilliant language but we want to use them to build good software”. The quote is by Rob Pike.”

                            You nailed it right here. Two, supporting points. First, Pike actually developed on Oberon-2 at one point loving its fast flow and lack of segfaults in common uses. He wanted that experience in Go. Second, Google has to hire, train, and make productive a humongous number of people from many backgrounds in shortest time possible. That’s at least their common case which the second point optimizes for. If these arent necessary or are frowned upon, people evaluating languages in such situations might want something other than Go.

                            Also, Ill add that we dont inherently need Go or rapid compiles to achieve that. A language with long compiles might have quick-good-enough mode for fast iterations with final result sent through optimizing compiler. The second problem can be solved with a distinction between a simpler core with advanced stuff optional and layered on top. Coding guidelines with tools that enforce it can keep the simple core the default. Advanced stuff is allowed where it makes sense (ie macros eliminating boilerplate). I also thought might be helpful to have tool that converts those features into human-readable, core form preserving comments so less skilled can still maintain it.

                            1.  

                              One thing I find interesting is that the original “blub” language was Java. Go shares the same goal of being accessible to a wide variety of programmers, yet takes an incredibly different tack from Java (embracing generics in 2.0 closes some of the gap. At a meta-level, I suppose you could say they took the same tack: release generics a decade after the language was released).

                            1. 2

                              I totally flunked my electronics test I had to take yesterday, so I’ll just be relaxing a bit, working on some projects I had to set aside for a while, playing around with some graphics and taking the time to read a bit until the next semester starts… on Monday.

                              1. 4

                                I think porting the Emacs’ C codebase is a waste of time if you are still using the same elisp implementation, maybe they want to offer the same known interface to long time users, but I think implementing a Emacs like editor with a proper lisp would be a better idea.

                                1. 4

                                  The price would be loosing ton’s of libraries and extentions written over the years, that rely on things such as dynamic scoping.

                                  1. 2

                                    but I think implementing a Emacs like editor with a proper lisp would be a better idea.

                                    This has been done a bunch of times before already.

                                    1. 1

                                      It’s just that they aren’t as popular as GNU Emacs.

                                      1. 2

                                        But they’re still usable, right? So your primary wishes (an Emacs with a proper lisp) is fulfilled.

                                        1. 2

                                          If you can call an editor without magit usable.

                                    1. 4

                                      Have you got any examples of what it produces? Some kind of before-and-after thing? Or am I just missing something?

                                      1. 2

                                        Here is an example output from one of my articles. It basically runs the webpage through Readability and exports it as PDF. It can also collate many web pages into a PDF file (similar to Wikipedia’s Create PDF book functionality).

                                      1. 5

                                        The only thing keeping me from looking further into Go is binary size. Yes I know, it might not matter that much nowadays, but I do care about that.

                                        The article was delightful to read and I’m glad more people discover Go and make use of it nonetheless.

                                        1. 11

                                          Yes, it is a bit odd, but yet we think nothing about 10s or 100s of megabytes of installed dynamic language runtimes and RAM overhead in the 50-100MB range (minimum!). Granted those runtimes are shared, but for us we just compile our go code into a single binary (command/subcommands) so the binary overhead is at least mitigated and as @zge says, it is nice to be able to drop the binary onto a box and just run it.

                                          1. 2

                                            Indeed it is very nice, and I give it to the Go developers that they mandated static linking despite the problems to allow this flexibility.

                                            RAM overhead is a difficult matter though. The Linux kernel is a bit more slacky with memory when lots is available, but I with my system for instance have a RAM usage of ~70MB after boot, which is definitely a value one can live with. It can easily bloat up with many programs though, so your point is definitely valid.

                                            We’ll see what the future brings in this regard.

                                            1. 2

                                              Wait, are you saying you work on a computer that, after OS, only has 70MB free? If so, why? I’m just curious.

                                              1. 1

                                                they didn’t mandate static linking, dynamic Go programs are possible. it isn’t backwards compatible so that’s a thing to watch out for.

                                            2. 4

                                              Considering that people usually write Go on one machine, and let it run on another, having everything statically built is welcome. But I agree that it feels weird for native applications.

                                              And usually, running go build -ldflags "-w -s" manages to cut the size by 1/2, though I haven’t necessarily noticed any great performance improvements.

                                              1. 1

                                                It’s discouraged to strip Go binaries as it can lead to unexpected problems, but your point is a good one. Still, I am used to very small statically linked binaries using musl libc. Going static doesn’t necessarily imply a gigantic growth in binary size and the Go developers acknowledge that it is a real problem (see this)

                                                1. 4

                                                  That is not true.

                                                2. 1

                                                  UPX is really very effective at compressing Go programs, too.

                                              1. 5

                                                Man I remember when Google+ was opened to the public and there was actually something going on there, and people were “hoping” it could win facebook users over (retroactively naive). Circles seemed superficially cool, there were interesting groups, some people really spent time to become popular…

                                                In a certain way it reminds me of Mastodon today, although I would say that due to quite relevant technical factors, Mastodon will be able to avoid G+’s fate.

                                                1. 4

                                                  I had (like many others) similar hope for Google Wave. Nowadays I don’t trust any Google products to stick around and started self hosting my data whenever I can.

                                                  1. 1

                                                    Yeah, I had high hopes for it when it debuted. It really seemed like it had the chance to become a less obnoxious Twitter as well. It’s not entirely clear to me why it failed. I stopped using it after they redesigned it to look more like Twitter (lower information density), but I suspect that wasn’t what really did it in.

                                                  1. 3

                                                    What’s the reason that GNOME has adopted Javascript as it’s extension language? Aren’t there many more sane (and lightweight) languages and environments the could have chosen from? Or was is a strategical decision to make it “easier” to attract new developers?

                                                    1. 2

                                                      I’ll tell you I had a tough time with the Gio/GLib bindings in Gnome Javascript.

                                                      Gnome Clocks exposes data of type “aa{sv}” in gsettings/dconf, as described in an XML file. Already by that point I was scratching my head. This is the data I was trying to access:

                                                      sevagh:top-bar-clocks $ gsettings get org.gnome.clocks world-clocks
                                                      [{'location': <(uint32 2, <('Oakland', 'KOAK', true, [(0.65832848982162007, -2.133408063190589)], [(0.65981076304875375, -2.1340280914073602)])>)>}, {'location': <(uint32 2, <('Montreal', 'CYUL', true, [(0.79354303905785273, -1.2871803233458181)], [(0.79354303905785273, -1.2871803233458181)])>)>}]
                                                      sevagh:top-bar-clocks $
                                                      sevagh:top-bar-clocks $ dconf read /org/gnome/clocks/world-clocks
                                                      [{'location': <(uint32 2, <('Oakland', 'KOAK', true, [(0.65832848982162007, -2.133408063190589)], [(0.65981076304875375, -2.1340280914073602)])>)>}, {'location': <(uint32 2, <('Montreal', 'CYUL', true, [(0.79354303905785273, -1.2871803233458181)], [(0.79354303905785273, -1.2871803233458181)])>)>}]
                                                      

                                                      This is what the beginnings of my code looked like, before copying from existing Gnome Javascript code that interacted with Clocks:

                                                      function getCitiesFromGnomeClocks() {
                                                              var ret = new Array();
                                                              var gnome_clocks = new Gio.Settings({schema: "org.gnome.clocks"});
                                                              var world_clocks = gnome_clocks.get_value("world-clocks");
                                                              var time_to_display = "";
                                                              for (var i = 0; i < world_clocks.n_children(); i++) {
                                                                      var x = world_clocks.get_child_value(i);
                                                                      for (var j = 0; j < x.n_children(); j++) {
                                                                              var y = x.get_child_value(j);
                                                                              for (var k = 0; k < y.n_children(); k++) {
                                                                                      var z = y.get_child_value(k);
                                                                                      if (z.classify() == 118) {
                                                                                              var a, b = z.unpack();
                                                                                              var c = b.unpack();
                                                                                              for (var l = 0; l < c.length; l++) {
                                                                                                      var d = c[l];
                                                                                                      if (d.classify() == 118) {
                                                                                                              var e = d.unpack();
                                                                                                              var ICAO_airport_code = e.get_child_value(1).get_string().toString().split(",")[0];
                                                                                                              ret.push(ICAO_airport_code);
                                                                                                      }
                                                                                              }
                                                                                      }
                                                                              }
                                                                      }
                                                              }
                                                              return ret
                                                      }
                                                      

                                                      The documentation wasn’t the best. This is how real Gnome Javascript does it:

                                                              let clocks = settings.get_value('world-clocks').deep_unpack();
                                                              for (let i = 0; i < clocks.length; i++) {
                                                                  if (!clocks[i].location)
                                                                      continue;
                                                                  let l = world.deserialize(clocks[i].location);
                                                                  if (l)
                                                                      this._locations.push({ location: l });
                                                              }
                                                      

                                                      It was frustrating at times.

                                                      1. 1

                                                        gnome-shell is written in JavaScript so there’s that. The documentation is a bit weak but you can read the source. and in general the introspection xml can also create bindings to other languages like Python. (for gnome-shell extensions you are stuck with JS though)

                                                        you can also try code in looking glass, or generic code that does not depend on the shell inside gjs

                                                        1. 1

                                                          Nice reference I found while working on it: https://github.com/julio641742/gnome-shell-extension-reference

                                                        1. 22

                                                          These days I would almost prefer if services didn’t daemonize themselves. Daemonization can be solved in the service manager if needed.

                                                          1. 10

                                                            A thousand times, yes.

                                                            Run in the foreground, log to stdout; the service manager will deal with log rotation & alerting/restarting on exit, etc.

                                                            1. 1

                                                              The only problem I have with this is structured logging. Lots of languages dump a stacktrace of several lines when the app crashes. But each of those lines is then a separate log entry.

                                                              1. 1

                                                                A simple approach would be to ensure that stdout has one entry pre line, while stderr is used for stack traces & co.

                                                                1. 1

                                                                  That’s why I add the process ID and line number when I log a crash. That way, I can collate the output from a crash and don’t have to worry about line lengths when logging via syslog().

                                                              2. 2

                                                                almost? I have never wanted this… I just use daemontools or systemd.

                                                              1. -2

                                                                As a result, there’s no need for Proof-of-Work consensus, which means that Dat and P2P aren’t inherently wasteful.

                                                                As great as the work that Paul does is, it’s really hard for me to sometimes take him seriously when he writes stuff like this. I really do not understand why he needs to do that. It’s not true, and it only detracts from his message.

                                                                1. 8

                                                                  What part of that is untrue, and how? Dat is not based on any expensive operation, and proof of work is wasteful.

                                                                  1. -2

                                                                    The part about proof-of-work being wasteful is untrue. Something is only wasteful when it’s brought in comparison to something else that is less wasteful. If you consider proof-of-work to be wasteful, you’ll have to point to a more efficient system that accomplishes what Bitcoin does. I know of no such system.

                                                                    1. 4

                                                                      If you consider proof-of-work to be wasteful, you’ll have to point to a more efficient system that accomplishes what Bitcoin does. I know of no such system.

                                                                      How about solving any other problem than reverse-hashing? There is absolutely no utility in finding a hash starting with n “0”‘s. Sure, it would be more complicated, maybe not as elegant on first glance, but I don’t see why it shouldn’t be possible.

                                                                      1. 0

                                                                        Do you think you’re the first person to ask that question?

                                                                        I would answer your question but there’s little point. I’ll just get downvoted for sharing what I’ve learned over the years with you. So figure it out yourself.

                                                                        1. 0

                                                                          I don’t understand why you assume that I think I’m the first person to think of this. All I know is that it’s not commonly discussed, for some reason. And secondly, why care so much about imaginary Internet points – that’s really not something that should influence what you say or don’t say. Other than that, my profile has a link to my contact page, so I’d be trilled if you could tell me more about what you know.

                                                                      2. 2

                                                                        I assume you mean reaching consensus on a global scale without having to trust a central authority?

                                                                        1. 4

                                                                          *without having to trust more than 1) the leaders of the largest hashpools 2) the developers of the system.

                                                                          1. 0

                                                                            Such a system as the one you described does not exist, and in Bitcoin trust for all of the above is minimized across all of those entities (in other words, it’s spread out, not concentrated in any one of them).

                                                                        2. -4

                                                                          ok

                                                                          you’ll come around eventually, i trust.

                                                                          1. 4

                                                                            I (strongly) disagree with itistoday on this topic, but there is zero place here for your behavior.

                                                                            1. 1

                                                                              Why is it acceptable to just walk in, say something facile and dubious, then back that up with an ungrounded statement of opinion? My counter-argument was appropriately rigorous, not to mention hopefully optimistic for the future of their character and wisdom.

                                                                              1. 4

                                                                                He’s wrong (imo) that distributed trust is a particularly important outcome.

                                                                                From that (imo incorrect) base, he’s got a perfectly good argument. There isn’t really a better way to do it yet.

                                                                                Rather than making a serious attempt to understand him, you’ve resorted to condescension. Put a bit more effort in.

                                                                                1. 1

                                                                                  In isolation, that’s totally fair.

                                                                                  In the context of bitcoin-worshipping ancaps, it gets a little tedious. He also took it as self-evident that whatever it was about Bitcoin he meant was understood, after the condescending, “marginal efficiency is relative,” line, after which he* probably had to wipe his monitor clean of spittle because his internal monologue came roaring out via unconscious and unintelligible lateral lisp.

                                                                                  So why does he deserve the respect, time, and effort?

                                                                                  *) given a “he” pronoun because, come on.

                                                                                  1. 2

                                                                                    He doesn’t deserve your time and effort - you didn’t have to respond.

                                                                                    You chose to spend your time and effort on an answer, but not your respect. That’s what has no place here.

                                                                                    1. 1

                                                                                      A point well made, that I concede.

                                                                      3. 4

                                                                        As someone who wrote both a P2P system and a cryptocurrency, I would say that P2P and PoW are orthogonal to each other. You can imagine a centralized system which accepts data which has a PoW, and you can imagine a P2P system that synchronizes data without PoW. Where he is wrong is comparing them as though they solve the same problems.

                                                                        The consensus algorithm in what people call PoW cryptocurrencies isn’t the PoW, but the idea that the longest chain wins. PoW just slows the process down so that block generation happens at a specific fixed interval (10 minutes for bitcoin for example) on average. PoW is about making the blockchain a decentralized clock. This is why Satoshi Nakamoto in the original bitcoin whitepaper called it a timestamp server (a clock). One way to make a decentralized clock in a P2P system without PoW is to use vector clocks, which have their own problems and costs.

                                                                      1. 3

                                                                        What exactly is this? A general/tech-inclining news aggressor? Where do the links come from? Some AI or are they scraped from various sources like a planet site? What relation does this have to https://sub.cafe – a parallel project, or is there some connection between the two?

                                                                        Just posting a link like this is confusing and doesn’t say much. Add a comment if you know more, or maybe add a short note to the title “Newscafe: An AI-based news aggressor”or whatever it is – would help a lot.

                                                                        1. 1

                                                                          Found this poking around a bit:

                                                                          Newscafe is my newest project and it’s up at news.sub.cafe. Right now it fetches some RSS feeds and ranks the links by number of shares on Facebook. But it can be much more with better sources and interesting metadata.

                                                                          (Here)[https://sub.cafe/lucian/] (Sorry can’t find a way to link to a specific post.)

                                                                          1. 1

                                                                            Sub is the parent app/domain and it’s a social network.

                                                                            Newscafe is a automated news site like Microsoft/Google/Apple News. I should have called it Sub News.

                                                                          1. 16

                                                                            This seems to bring up many of the points that the README Maturity Model mentioned, and I already disagreed with back then.

                                                                            I mentioned this on HN once, and I’ll say it again: documents like these might look nice on GitHub, but when I open it locally, I really would like to not have that much HTML flying around. Put stuff like that on a web page (like the ones that GitHub offers for free), or a manual page.

                                                                            I disagree with on a lot of things with the plan9/suckless community, but at least they know how to make a nice README: stagit, ii, st, (and my attempt at it) … which can be converted into a decent looking page using any markdown converter.

                                                                            That’s an awesome README, that I would want to, and can read.

                                                                            1. 1

                                                                              (and my attempt at it)

                                                                              FYI, your website doesn’t seem to be working for me. I’m getting “Address Not Found”.

                                                                              1. 1

                                                                                Someone already mentioned that to me just today. There’s a 99% chance it’s because I’m too cheap to purchase a IPv4 address for my VPS.

                                                                            1. 1

                                                                              I agree with “Item 4: Use incremental search for Navigation”, but I’d go further - look into helm-swoop and ace-jump mode. Moving around efficiently is a rich mine of ideas and things to try. And it’s worth it!

                                                                              1. 0

                                                                                I’ve recently switched from ace-jump-mode to avy and I can really recommend it – one can decide to jump to charachters, words, subwords, lines. It’s also available in the standard ELPA repo, which is another plus.

                                                                                Addition: My current setup is just

                                                                                (use-package avy
                                                                                  :config
                                                                                  (avy-setup-default)
                                                                                  :bind (("C-z C-z" . avy-goto-subword-1)
                                                                                         ("C-z z" . avy-goto-char)))
                                                                                

                                                                                This sets up all they keys to use the home-row (I previously had to change avy’s behavior not to use numbers) and turns on jumping to avy from isearch (that’s the (avy-setup-default)) part. If anyone wants to check it out this might server as a good start. The only thing I’m still looking for is how to configure (or if necessary add) the ordering to use less letters the closer is it to the cursor.

                                                                                1. 2

                                                                                  Thanks, yeah avy looks much nicer. A few extra tweaks to get you there faster, nice.

                                                                                  https://github.com/abo-abo/avy to save people a search :)

                                                                              1. 1

                                                                                I thought for sure this was going to be about org-mode, but these are pretty good, too.

                                                                                A couple of these are definitely personal preferences (like mapping Caps-lock to Ctrl, removing the UI, etc,) but most are generally good advice, IMO.

                                                                                There are a few things I would add, first for #6 about buffers. Get familiar with ibuffer (M-x ibuffer). It’s really convenient for seeing what files are open, what temp buffers are around, which processes are running, etc. and it can manipulate multiple buffers at a time (save and close multiple buffers, find/replace in multiple buffers, etc.).

                                                                                And for section #8, I’d point out the “C-h” shortcuts. For example, “C-h k” is a shortcut for “M-x describe-key”, “C-h f” is “M-x describe-function”, etc. “C-h ?” brings up a buffer showing all of the other context sensitive help functions available.

                                                                                For more advanced users, I’d suggest getting familiar with the “customize-*” functions instead of manually adding configuration settings to .emacs.

                                                                                1. 1

                                                                                  For more advanced users, I’d suggest getting familiar with the “customize-*” functions instead of manually adding configuration settings to .emacs.

                                                                                  That’s funny, my impression is usually the opposite. The Easy Customization Interface is used either when one doesn’t know too much about Elisp or want’s to get a first look at what some package has to offer in terms of changing it’s behavior. Whenever I decide to permanently (more or less) add something to my “official” (ie. public) configuration, I take it out of my custom.el file and add it to my literate conf – it seems more natural and I have more control over what’s going on. So why would you advise (advanced) users to instead use “customize”?

                                                                                  1. 3

                                                                                    Maybe “intermediate” would have been better than “advanced,” but I prefer customizing that way because the interface shows the documentation along with the input fields, and the input widgets ensure the correct types are input and usually makes sure that only acceptable values are input.

                                                                                    For example, customizing the variable “org-agenda-custom-commands” might look like this in elisp, and it’s not clear what each value represents:

                                                                                    (add-to-list 'org-agenda-custom-commands 
                                                                                          '("w" "@work" tags-todo "@work"
                                                                                             ((org-agenda-overriding-header "Work"))))
                                                                                    

                                                                                    But the customize interface has individual input fields for each value there (“w”, “@work”, …) with descriptive names, so I know “w” is the access key, the first “@work” is a description, etc.

                                                                                    That said, I also often copy the elisp from customize to another file or tweak it by hand in my .emacs.

                                                                                    1. 1

                                                                                      I consider myself a moderately-advanced Emacs user, and I prefer using customize for any setting that it supports. I only have a few custom functions and keybindings set up in my .emacs file and everything else is set in customize.

                                                                                  1. 1

                                                                                    Can someone explain to me why OpenBSD still packages Emacs 21.4? I accidentally installed it once just before I lost my Internet connection and it was quite an experience – yet I don’t understand why anyone would insist on using it, let alone have it as an alternative to 26.1.

                                                                                    1. 2

                                                                                      Probably for the same reason they still ship an old GCC: licensing. They reject all GPLv3 software.

                                                                                      1. 1

                                                                                        But they do ship Emacs 26.1. as well?

                                                                                        1. 1

                                                                                          Emacs on my OpenBSD system is 26.1, installed from ports.

                                                                                        2. 1

                                                                                          As @phaer implied, I also don’t think the license is the case. OpenBSD developers avoid GPLv3 on the base system, as far as I know Emacs is part of the collection for packages ports.

                                                                                        3. 1

                                                                                          I was also curious about it, as an Emacs user myself I don’t know what’s the benefit behind 21.4.

                                                                                        1. 5
                                                                                          • A period prediction tool using standard linux utilities
                                                                                          • Investigating two bugs on Alpine Linux
                                                                                          • Regular maintenance work as usual

                                                                                          IRL i got socialist literature from my grandparents a while ago, and now hope to find time to read some of the books.

                                                                                          1. 2

                                                                                            hello, I am a beginner in os dev. and i wanted to contribute to alpine linux. should i start by trying to fix bugs or should i install it and playground with it initially.

                                                                                            1. 2

                                                                                              My involvement with alpine boils down that i’m using it as desktop system and for production servers, and if i find bugs or things that annoy me, i try to work out fixes. Also writing documentation. Rather boring work actually, but afterwards people are glad somebody did it.

                                                                                            2. 2

                                                                                              IRL i got socialist literature from my grandparents a while ago, and now hope to find time to read some of the books.

                                                                                              That’s not something you see on a regular basis.

                                                                                              1. 2

                                                                                                Yeah, one would usually use AFK. IRL makes it sound like the Internet is outside of reality or something.

                                                                                                I hope to find some time to read a little as well. Young Marx is quite fun.

                                                                                            1. 3

                                                                                              Documentation for the syntax is at http://mandoc.bsd.lv/man/mdoc.7.html.

                                                                                              1. 2

                                                                                                https://manpages.bsd.lv/ is also a good resource if one has never written [gt]roff and/or manpages before.

                                                                                                1. 1

                                                                                                  Oof, that looks like a much better resource. The syntax still needs some getting used to, but being shown the benefits of semantic markup (i.e. how does the PDF conversion look? Does it work well?) might persuade me to write some mandoc.

                                                                                                  1. 1

                                                                                                    The syntax still needs some getting used to

                                                                                                    It becomes fairly pleasant. I’ve converted a few pages from man to mdoc for the suckless project (although my patches haven’t been accepted) and all you really need is the manpage you linked as a reference. I’ve also written a few myself, and once you understand the boilerplate + semantic, the rest is easy.

                                                                                                    how does the PDF conversion look? Does it work well?

                                                                                                    It’s really easy: running

                                                                                                    $ mandoc -Tpdf ed.1 > ed.pdf
                                                                                                    

                                                                                                    on ed.1 results in this file. Nothing too special imo.

                                                                                              1. 7

                                                                                                I guess it depends on what you consider to be a wiki. I’ve got an org-mode knowledge base in ~/Notes that I treat like a wiki in the sense that I create in-line hyperlinks whenever the name of an “article” occurs in a sentence. It’s nice and structured to satisfy my obsession with everything being orderly, but in most situations I just use ag.el to find what I’m looking for.

                                                                                                1. 1

                                                                                                  How do you add new stuff? Using captures, and if yes what’s your system? If not, what do you do?

                                                                                                  I’ve been maintaining a “notes.org” file that consists of 90% stuff I looked up on the Internet when I needed it, in case I don’t have a connecting, and it’s basically just a list of headers. What I’m wondering is how to get started with a org-mode wiki.

                                                                                                  1. 3

                                                                                                    I’ll bite. My org usage has evolved, and what I describe will at best be the penultimate way of how i use it (i’m using penultimate ironically here, i’ve evolved my note usage so many times I can’t count).

                                                                                                    What I do is use org like so (note, I use use-package heavily, adapt to fit, most of this crazy is me making things prettier):

                                                                                                      (use-package org
                                                                                                        :ensure org-plus-contrib
                                                                                                        :bind (("C-c a" . org-agenda)
                                                                                                               ("C-c b" . org-iswitchb)
                                                                                                               ("C-c c" . org-capture)
                                                                                                               ("C-c l" . org-store-link)
                                                                                                               ("C-c p" . org-latex-export-to-pdf))
                                                                                                       :config
                                                                                                       (progn
                                                                                                         (custom-set-variables
                                                                                                          '(org-log-done t)
                                                                                                          '(org-hide-leading-stars t)
                                                                                                          '(org-hide-emphasis-markers t)
                                                                                                          '(org-confirm-babel-evaluate nil)
                                                                                                          '(org-capture-templates
                                                                                                            '(("t" "Todo" entry (file+headline "~/src/bitbucket.org/mitchty/org/gtd.org" "Tasks")
                                                                                                               "* TODO %?\n  %i\n  %a")
                                                                                                              ("n" "Note" entry (file+datetree "~/src/bitbucket.org/mitchty/org/notes.org")
                                                                                                               "* %?\nRandom Note entered on %U\n  %i\n  %a")
                                                                                                              ("m" "Todo from email" entry (file+headline "~/src/bitbucket.org/mitchty/org/gtd.org" "INBOX")
                                                                                                               "* TODO %?, Link: %a")
                                                                                                              ("u" "Url" entry (file+headline "~/src/bitbucket.org/mitchty/org/urls.org" "Urls")
                                                                                                               "* %u\n\n %i" :prepend t)
                                                                                                               ))
                                                                                                          )
                                                                                                    
                                                                                                         ;; typing stuff like the mode for a snippet is for chumps
                                                                                                         (add-to-list 'org-structure-template-alist '("el" "#+BEGIN_SRC emacs-lisp\n?\n#+END_SRC" ""))
                                                                                                         (add-to-list 'org-structure-template-alist '("hs" "#+BEGIN_SRC haskell\n?\n#+END_SRC" ""))
                                                                                                         (add-to-list 'org-structure-template-alist '("pl" "#+BEGIN_SRC perl\n?\n#+END_SRC" ""))
                                                                                                         (add-to-list 'org-structure-template-alist '("py" "#+BEGIN_SRC python\n?\n#+END_SRC" ""))
                                                                                                         (add-to-list 'org-structure-template-alist '("sh" "#+BEGIN_SRC sh\n?\n#+END_SRC" ""))
                                                                                                    
                                                                                                         (org-babel-do-load-languages 'org-babel-load-languages
                                                                                                                                      (append org-babel-load-languages
                                                                                                                                              '(
                                                                                                                                                (C . t)
                                                                                                                                                (plantuml . t)
                                                                                                                                                (ditaa . t)
                                                                                                                                                (emacs-lisp . t)
                                                                                                                                                (haskell . t)
                                                                                                                                                (latex . t)
                                                                                                                                                (perl . t)
                                                                                                                                                (python . t)
                                                                                                                                                (ruby  . t)
                                                                                                                                                (shell . t)
                                                                                                                                                )))
                                                                                                         (add-hook 'after-init-hook (lambda () (org-reload)))
                                                                                                         )
                                                                                                       )
                                                                                                      (use-package org-bullets
                                                                                                        :after org
                                                                                                        :init
                                                                                                        (custom-set-variables '(org-bullets-bullet-list '("・" "◦" "•" "◉")))
                                                                                                        :config
                                                                                                        (progn
                                                                                                          (add-hook 'org-mode-hook (lambda () (org-bullets-mode 1)))
                                                                                                          (when window-system
                                                                                                          (let* ((variable-tuple (cond ((x-list-fonts "Source Sans Pro") '(:font "Source Sans Pro"))
                                                                                                                                       ((x-list-fonts "Lucida Grande")   '(:font "Lucida Grande"))
                                                                                                                                       ((x-list-fonts "Verdana")         '(:font "Verdana"))
                                                                                                                                       ((x-family-fonts "Sans Serif")    '(:family "Sans Serif"))
                                                                                                                                       (nil (warn "Cannot find a Sans Serif Font."))))
                                                                                                                 (base-font-color     (face-foreground 'default nil 'default))
                                                                                                                 (headline           `(:inherit default :weight bold :foreground ,base-font-color)))
                                                                                                            (custom-theme-set-faces 'user
                                                                                                                                    `(org-level-8 ((t (,@headline ,@variable-tuple))))
                                                                                                                                    `(org-level-7 ((t (,@headline ,@variable-tuple))))
                                                                                                                                    `(org-level-6 ((t (,@headline ,@variable-tuple))))
                                                                                                                                    `(org-level-5 ((t (,@headline ,@variable-tuple))))
                                                                                                                                    `(org-level-4 ((t (,@headline ,@variable-tuple :height 1.1))))
                                                                                                                                    `(org-level-3 ((t (,@headline ,@variable-tuple :height 1.25))))
                                                                                                                                    `(org-level-2 ((t (,@headline ,@variable-tuple :height 1.5))))
                                                                                                                                    `(org-level-1 ((t (,@headline ,@variable-tuple :height 1.75))))
                                                                                                                                    `(org-document-title ((t (,@headline ,@variable-tuple :height 1.5 :underline nil)))))))
                                                                                                          (font-lock-add-keywords 'org-mode
                                                                                                                                  '(("^ +\\([-*]\\) "
                                                                                                                                     (0 (prog1 () (compose-region (match-beginning 1) (match-end 1) "•"))))))
                                                                                                          )
                                                                                                        )
                                                                                                      (use-package ox-reveal
                                                                                                        :after org)
                                                                                                      )
                                                                                                    

                                                                                                    I store that all in a private git repo I host on my own site. I keep work and home separated in general.

                                                                                                    Then I just link to files (the captures let me link to where I was in a file when I took the note, aka say i’m reading some source and have a “is this variable unsigned int or not, doesn’t matter, can check later” moment I can quick capture that and refile that away later.

                                                                                                    Basically, I just capture notes and move them around so the agenda deals with things later. Tag stuff as appropriate so it shows up in the agenda and move on with life. YMMV though, I’m only 4 years into my org journey, so still at the beginner stage.

                                                                                                    1. 1

                                                                                                      I add new material by going to wherever I feel it belongs and writing a few sentences. The notes system I have is a little bit more flushed out than a knowledge dump, since I use it as a medium for exercising the philosophy that “if you can’t explain it simply, you don’t understand it well enough.” I suppose I do indirectly use captures, as that’s my way of adding to my GTD inbox, but I spend time processing any facts I put in there - either condensing them into something coherent for my notes, or creating an org-drill card.

                                                                                                      My system might not be the best starting point if you’re looking to make a wiki using org-mode, since it’s largely tailored towards satisfying my obsessiveness. If you have issues with a single “notes.org” file, I’d recommend writing them down and thinking about how you might design an organizational system that doesn’t have those issues. Alternatively, you could look into packages that do the organization for you (e.g. org-brain). Best of luck in finding something that works for you.

                                                                                                  1. 1

                                                                                                    I also have to thank you for the podcast. Even though I’ve been using Emacs for close to 5 years (1/4 of my life) I still managed to learn a few things, or at the very least you pushed me to try some features I dismissed at first (eg. using ivy). I’m looking forward to how the podcast develops. My only tip would be not to focus too much on your personal configuration, since over time this might just take too long and people just starting to listen might get put off.

                                                                                                    1. 2

                                                                                                      Thanks!

                                                                                                      Yes, I came to the same conclusion after recording and listening to the last episode. I’ll keep the “config news” short and simple from now on.